cmd/compile: move Used from gc.Node to gc.Name

josharian · josharian · commit fc08a19cef1b · 2017-04-27T22:58:13.000Z
Node.Used was written to from the backend concurrently with reads of Node.Class for the same ONAME Nodes. I do not know why it was not failing consistently under the race detector, but it is a race. This is likely also a problem with Node.HasVal and Node.HasOpt. They will be handled in a separate CL. Fix Used by moving it to gc.Name and making it a separate bool. There was one non-Name use of Used, marking OLABELs as used. That is no longer needed, now that goto and label checking happens early in the front end. Leave the getters and setters in place, to ease changing the representation in the future (or changing to an interface!). Updates #20144 Change-Id: I9bec7c6d33dcb129a4cfa9d338462ea33087f9f7 Reviewed-on: https://go-review.googlesource.com/42015 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
@@ -398,7 +398,7 @@ func transformclosure(xfunc *Node) {
 				addr := newname(lookup("&" + v.Sym.Name))
 				addr.Type = types.NewPtr(v.Type)
 				addr.SetClass(PAUTO)
-				addr.SetUsed(true)
+				addr.Name.SetUsed(true)
 				addr.Name.Curfn = xfunc
 				xfunc.Func.Dcl = append(xfunc.Func.Dcl, addr)
 				v.Name.Param.Heapaddr = addr
@@ -622,7 +622,7 @@ func makepartialcall(fn *Node, t0 *types.Type, meth *types.Sym) *Node {
 	}
 	ptr := newname(lookup("rcvr"))
 	ptr.SetClass(PAUTO)
-	ptr.SetUsed(true)
+	ptr.Name.SetUsed(true)
 	ptr.Name.Curfn = xfunc
 	xfunc.Func.Dcl = append(xfunc.Func.Dcl, ptr)
 	var body []*Node
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
@@ -1443,7 +1443,7 @@ func (e *EscState) initEscRetval(call *Node, fntype *types.Type) {
 		ret.SetClass(PAUTO)
 		ret.Name.Curfn = Curfn
 		e.nodeEscState(ret).Loopdepth = e.loopdepth
-		ret.SetUsed(true)
+		ret.Name.SetUsed(true)
 		ret.Pos = call.Pos
 		cE.Retval.Append(ret)
 	}
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
@@ -520,11 +520,11 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {
 	}
 
 	if c == 0 && n.HasCall() {
-		fmt.Fprintf(s, " hascall")
+		fmt.Fprint(s, " hascall")
 	}
 
-	if c == 0 && n.Used() {
-		fmt.Fprintf(s, " used(%v)", n.Used())
+	if c == 0 && n.Name != nil && n.Name.Used() {
+		fmt.Fprint(s, " used")
 	}
 }
 
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
@@ -71,13 +71,13 @@ func tempnamel(pos src.XPos, curfn *Node, nn *Node, t *types.Type) {
 func temp(t *types.Type) *Node {
 	var n Node
 	tempnamel(lineno, Curfn, &n, t)
-	asNode(n.Sym.Def).SetUsed(true)
+	asNode(n.Sym.Def).Name.SetUsed(true)
 	return n.Orig
 }
 
 func tempAt(pos src.XPos, curfn *Node, t *types.Type) *Node {
 	var n Node
 	tempnamel(pos, curfn, &n, t)
-	asNode(n.Sym.Def).SetUsed(true)
+	asNode(n.Sym.Def).Name.SetUsed(true)
 	return n.Orig
 }
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
@@ -745,7 +745,6 @@ func mkinlcall1(n *Node, fn *Node, isddd bool) *Node {
 	body := subst.list(fn.Func.Inl)
 
 	lab := nod(OLABEL, retlabel, nil)
-	lab.SetUsed(true) // avoid 'not used' when function doesn't have return
 	body = append(body, lab)
 
 	typecheckslice(body, Etop)
@@ -817,7 +816,7 @@ func inlvar(var_ *Node) *Node {
 	n := newname(var_.Sym)
 	n.Type = var_.Type
 	n.SetClass(PAUTO)
-	n.SetUsed(true)
+	n.Name.SetUsed(true)
 	n.Name.Curfn = Curfn // the calling function, not the called one
 	n.SetAddrtaken(var_.Addrtaken())
 
@@ -830,7 +829,7 @@ func retvar(t *types.Field, i int) *Node {
 	n := newname(lookupN("~r", i))
 	n.Type = t.Type
 	n.SetClass(PAUTO)
-	n.SetUsed(true)
+	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
@@ -842,7 +841,7 @@ func argvar(t *types.Type, i int) *Node {
 	n := newname(lookupN("~arg", i))
 	n.Type = t.Elem()
 	n.SetClass(PAUTO)
-	n.SetUsed(true)
+	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
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
@@ -1046,7 +1046,7 @@ func clearImports() {
 			// leave s->block set to cause redeclaration
 			// errors if a conflicting top-level name is
 			// introduced by a different file.
-			if !asNode(s.Def).Used() && nsyntaxerrors == 0 {
+			if !asNode(s.Def).Name.Used() && nsyntaxerrors == 0 {
 				pkgnotused(asNode(s.Def).Pos, asNode(s.Def).Name.Pkg.Path, s.Name)
 			}
 			s.Def = nil
@@ -1056,9 +1056,9 @@ func clearImports() {
 		if IsAlias(s) {
 			// throw away top-level name left over
 			// from previous import . "x"
-			if asNode(s.Def).Name != nil && asNode(s.Def).Name.Pack != nil && !asNode(s.Def).Name.Pack.Used() && nsyntaxerrors == 0 {
+			if asNode(s.Def).Name != nil && asNode(s.Def).Name.Pack != nil && !asNode(s.Def).Name.Pack.Name.Used() && nsyntaxerrors == 0 {
 				pkgnotused(asNode(s.Def).Name.Pack.Pos, asNode(s.Def).Name.Pack.Name.Pkg.Path, "")
-				asNode(s.Def).Name.Pack.SetUsed(true)
+				asNode(s.Def).Name.Pack.Name.SetUsed(true)
 			}
 
 			s.Def = nil
diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
@@ -449,7 +449,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
 		// parser.new_dotname
 		obj := p.expr(expr.X)
 		if obj.Op == OPACK {
-			obj.SetUsed(true)
+			obj.Name.SetUsed(true)
 			return oldname(restrictlookup(expr.Sel.Value, obj.Name.Pkg))
 		}
 		return p.setlineno(expr, nodSym(OXDOT, obj, p.name(expr.Sel)))
@@ -611,7 +611,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 	case *syntax.Name:
 		name := p.name(expr)
 		if n := oldname(name); n.Name != nil && n.Name.Pack != nil {
-			n.Name.Pack.SetUsed(true)
+			n.Name.Pack.Name.SetUsed(true)
 		}
 		return name
 	case *syntax.SelectorExpr:
@@ -621,7 +621,7 @@ func (p *noder) packname(expr syntax.Expr) *types.Sym {
 			yyerror("%v is not a package", name)
 			pkg = localpkg
 		} else {
-			asNode(name.Def).SetUsed(true)
+			asNode(name.Def).Name.SetUsed(true)
 			pkg = asNode(name.Def).Name.Pkg
 		}
 		return restrictlookup(expr.Sel.Value, pkg)
@@ -1125,7 +1125,7 @@ func (p *noder) pragma(pos src.Pos, text string) syntax.Pragma {
 func mkname(sym *types.Sym) *Node {
 	n := oldname(sym)
 	if n.Name != nil && n.Name.Pack != nil {
-		n.Name.Pack.SetUsed(true)
+		n.Name.Pack.Name.SetUsed(true)
 	}
 	return n
 }
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
@@ -80,8 +80,8 @@ func cmpstackvarlt(a, b *Node) bool {
 		return a.Xoffset < b.Xoffset
 	}
 
-	if a.Used() != b.Used() {
-		return a.Used()
+	if a.Name.Used() != b.Name.Used() {
+		return a.Name.Used()
 	}
 
 	ap := types.Haspointers(a.Type)
@@ -118,13 +118,13 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 	// Mark the PAUTO's unused.
 	for _, ln := range fn.Dcl {
 		if ln.Class() == PAUTO {
-			ln.SetUsed(false)
+			ln.Name.SetUsed(false)
 		}
 	}
 
 	for _, l := range f.RegAlloc {
 		if ls, ok := l.(ssa.LocalSlot); ok {
-			ls.N.(*Node).SetUsed(true)
+			ls.N.(*Node).Name.SetUsed(true)
 		}
 	}
 
@@ -136,10 +136,10 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 				n := a.Node.(*Node)
 				// Don't modify nodfp; it is a global.
 				if n != nodfp {
-					n.SetUsed(true)
+					n.Name.SetUsed(true)
 				}
 			case *ssa.AutoSymbol:
-				a.Node.(*Node).SetUsed(true)
+				a.Node.(*Node).Name.SetUsed(true)
 			}
 
 			if !scratchUsed {
@@ -159,7 +159,7 @@ func (s *ssafn) AllocFrame(f *ssa.Func) {
 		if n.Op != ONAME || n.Class() != PAUTO {
 			continue
 		}
-		if !n.Used() {
+		if !n.Name.Used() {
 			fn.Dcl = fn.Dcl[:i]
 			break
 		}
@@ -308,7 +308,7 @@ func debuginfo(fnsym *obj.LSym, curfn interface{}) []*dwarf.Var {
 
 		switch n.Class() {
 		case PAUTO:
-			if !n.Used() {
+			if !n.Name.Used() {
 				Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")
 			}
 			name = obj.NAME_AUTO
diff --git a/src/cmd/compile/internal/gc/pgen_test.go b/src/cmd/compile/internal/gc/pgen_test.go
@@ -25,8 +25,19 @@ func typeWithPointers() *types.Type {
 	return t
 }
 
+func markUsed(n *Node) *Node {
+	n.Name.SetUsed(true)
+	return n
+}
+
+func markNeedZero(n *Node) *Node {
+	n.Name.SetNeedzero(true)
+	return n
+}
+
 func nodeWithClass(n Node, c Class) *Node {
 	n.SetClass(c)
+	n.Name = new(Name)
 	return &n
 }
 
@@ -72,13 +83,13 @@ func TestCmpstackvar(t *testing.T) {
 			true,
 		},
 		{
-			nodeWithClass(Node{flags: nodeUsed}, PAUTO),
+			markUsed(nodeWithClass(Node{}, PAUTO)),
 			nodeWithClass(Node{}, PAUTO),
 			true,
 		},
 		{
 			nodeWithClass(Node{}, PAUTO),
-			nodeWithClass(Node{flags: nodeUsed}, PAUTO),
+			markUsed(nodeWithClass(Node{}, PAUTO)),
 			false,
 		},
 		{
@@ -92,13 +103,13 @@ func TestCmpstackvar(t *testing.T) {
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{flags: nameNeedzero}}, PAUTO),
+			markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
 			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
 			true,
 		},
 		{
 			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{flags: nameNeedzero}}, PAUTO),
+			markNeedZero(nodeWithClass(Node{Type: &types.Type{}}, PAUTO)),
 			false,
 		},
 		{
@@ -112,18 +123,18 @@ func TestCmpstackvar(t *testing.T) {
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
 			true,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
 			false,
 		},
 		{
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-			nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
+			nodeWithClass(Node{Type: &types.Type{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
 			false,
 		},
 	}
@@ -141,34 +152,34 @@ func TestCmpstackvar(t *testing.T) {
 
 func TestStackvarSort(t *testing.T) {
 	inp := []*Node{
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{flags: nodeUsed, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: typeWithoutPointers(), Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{flags: nameNeedzero}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
+		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),
 	}
 	want := []*Node{
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 0, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 10, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{Xoffset: 20, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PFUNC),
-		nodeWithClass(Node{flags: nodeUsed, Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{flags: nameNeedzero}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 2}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{Width: 1}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "abc"}}, PAUTO),
-		nodeWithClass(Node{Type: &types.Type{}, Name: &Name{}, Sym: &types.Sym{Name: "xyz"}}, PAUTO),
-		nodeWithClass(Node{Type: typeWithoutPointers(), Name: &Name{}, Sym: &types.Sym{}}, PAUTO),
+		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),
 	}
 	// haspointers updates Type.Haspointers as a side effect, so
 	// exercise this function on all inputs so that reflect.DeepEqual
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
@@ -250,7 +250,7 @@ func (lv *Liveness) valueEffects(v *ssa.Value) (pos int32, effect liveEffect) {
 	// variable" ICEs (issue 19632).
 	switch v.Op {
 	case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:
-		if !n.Used() {
+		if !n.Name.Used() {
 			return -1, 0
 		}
 	}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
@@ -4964,7 +4964,7 @@ func (e *ssafn) namedAuto(name string, typ ssa.Type, pos src.XPos) ssa.GCNode {
 	n.Orig = n
 
 	s.Def = asTypesNode(n)
-	asNode(s.Def).SetUsed(true)
+	asNode(s.Def).Name.SetUsed(true)
 	n.Sym = s
 	n.Type = t
 	n.SetClass(PAUTO)
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go

Original file line number	Diff line number	Diff line change
`@@ -1443,7 +1443,7 @@ func (e EscState) initEscRetval(call Node, fntype *types.Type) {`
`1443`	`1443`	`ret.SetClass(PAUTO)`
`1444`	`1444`	`ret.Name.Curfn = Curfn`
`1445`	`1445`	`e.nodeEscState(ret).Loopdepth = e.loopdepth`
`1446`		`- ret.SetUsed(true)`
	`1446`	`+ ret.Name.SetUsed(true)`
`1447`	`1447`	`ret.Pos = call.Pos`
`1448`	`1448`	`cE.Retval.Append(ret)`
`1449`	`1449`	`}`
Original file line number	Diff line number	Diff line change
`@@ -520,11 +520,11 @@ func (n *Node) jconv(s fmt.State, flag FmtFlag) {`
`520`	`520`	`}`
`521`	`521`
`522`	`522`	`if c == 0 && n.HasCall() {`
`523`		`- fmt.Fprintf(s, " hascall")`
	`523`	`+ fmt.Fprint(s, " hascall")`
`524`	`524`	`}`
`525`	`525`
`526`		`- if c == 0 && n.Used() {`
`527`		`- fmt.Fprintf(s, " used(%v)", n.Used())`
	`526`	`+ if c == 0 && n.Name != nil && n.Name.Used() {`
	`527`	`+ fmt.Fprint(s, " used")`
`528`	`528`	`}`
`529`	`529`	`}`
`530`	`530`
Original file line number	Diff line number	Diff line change
`@@ -80,8 +80,8 @@ func cmpstackvarlt(a, b *Node) bool {`
`80`	`80`	`return a.Xoffset < b.Xoffset`
`81`	`81`	`}`
`82`	`82`
`83`		`- if a.Used() != b.Used() {`
`84`		`- return a.Used()`
	`83`	`+ if a.Name.Used() != b.Name.Used() {`
	`84`	`+ return a.Name.Used()`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`ap := types.Haspointers(a.Type)`
`@@ -118,13 +118,13 @@ func (s ssafn) AllocFrame(f ssa.Func) {`
`118`	`118`	`// Mark the PAUTO's unused.`
`119`	`119`	`for _, ln := range fn.Dcl {`
`120`	`120`	`if ln.Class() == PAUTO {`
`121`		`- ln.SetUsed(false)`
	`121`	`+ ln.Name.SetUsed(false)`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`for _, l := range f.RegAlloc {`
`126`	`126`	`if ls, ok := l.(ssa.LocalSlot); ok {`
`127`		`- ls.N.(*Node).SetUsed(true)`
	`127`	`+ ls.N.(*Node).Name.SetUsed(true)`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`@@ -136,10 +136,10 @@ func (s ssafn) AllocFrame(f ssa.Func) {`
`136`	`136`	`n := a.Node.(*Node)`
`137`	`137`	`// Don't modify nodfp; it is a global.`
`138`	`138`	`if n != nodfp {`
`139`		`- n.SetUsed(true)`
	`139`	`+ n.Name.SetUsed(true)`
`140`	`140`	`}`
`141`	`141`	`case *ssa.AutoSymbol:`
`142`		`- a.Node.(*Node).SetUsed(true)`
	`142`	`+ a.Node.(*Node).Name.SetUsed(true)`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`if !scratchUsed {`
`@@ -159,7 +159,7 @@ func (s ssafn) AllocFrame(f ssa.Func) {`
`159`	`159`	`if n.Op != ONAME \|\| n.Class() != PAUTO {`
`160`	`160`	`continue`
`161`	`161`	`}`
`162`		`- if !n.Used() {`
	`162`	`+ if !n.Name.Used() {`
`163`	`163`	`fn.Dcl = fn.Dcl[:i]`
`164`	`164`	`break`
`165`	`165`	`}`
`@@ -308,7 +308,7 @@ func debuginfo(fnsym obj.LSym, curfn interface{}) []dwarf.Var {`
`308`	`308`
`309`	`309`	`switch n.Class() {`
`310`	`310`	`case PAUTO:`
`311`		`- if !n.Used() {`
	`311`	`+ if !n.Name.Used() {`
`312`	`312`	`Fatalf("debuginfo unused node (AllocFrame should truncate fn.Func.Dcl)")`
`313`	`313`	`}`
`314`	`314`	`name = obj.NAME_AUTO`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ func (lv Liveness) valueEffects(v ssa.Value) (pos int32, effect liveEffect) {`
`250`	`250`	`// variable" ICEs (issue 19632).`
`251`	`251`	`switch v.Op {`
`252`	`252`	`case ssa.OpVarDef, ssa.OpVarKill, ssa.OpVarLive, ssa.OpKeepAlive:`
`253`		`- if !n.Used() {`
	`253`	`+ if !n.Name.Used() {`
`254`	`254`	`return -1, 0`
`255`	`255`	`}`
`256`	`256`	`}`