cmd/compile: reduce use of **Node parameters
Escape analysis has a hard time with tree-like
structures (see #13493 and #14858).
This is unlikely to change.
As a result, when invoking a function that accepts
a **Node parameter, we usually allocate a *Node
on the heap. This happens a whole lot.
This CL changes functions from taking a **Node
to acting more like append: It both modifies
the input and returns a replacement for it.
Because of the cascading nature of escape analysis,
in order to get the benefits, I had to modify
almost all such functions. The remaining functions
are in racewalk and the backend. I would be happy
to update them as well in a separate CL.
This CL was created by manually updating the
function signatures and the directly impacted
bits of code. The callsites were then automatically
updated using a bespoke script:
https://gist.github.com/josharian/046b1be7aceae244de39
For ease of reviewing and future understanding,
this CL is also broken down into four CLs,
mailed separately, which show the manual
and the automated changes separately.
They are CLs 20990, 20991, 20992, and 20993.
Passes toolstash -cmp.
name old time/op new time/op delta
Template 335ms ± 5% 324ms ± 5% -3.35% (p=0.000 n=23+24)
Unicode 176ms ± 9% 165ms ± 6% -6.12% (p=0.000 n=23+24)
GoTypes 1.10s ± 4% 1.07s ± 2% -2.77% (p=0.000 n=24+24)
Compiler 5.31s ± 3% 5.15s ± 3% -2.95% (p=0.000 n=24+24)
MakeBash 41.6s ± 1% 41.7s ± 2% ~ (p=0.586 n=23+23)
name old alloc/op new alloc/op delta
Template 63.3MB ± 0% 62.4MB ± 0% -1.36% (p=0.000 n=25+23)
Unicode 42.4MB ± 0% 41.6MB ± 0% -1.99% (p=0.000 n=24+25)
GoTypes 220MB ± 0% 217MB ± 0% -1.11% (p=0.000 n=25+25)
Compiler 994MB ± 0% 973MB ± 0% -2.08% (p=0.000 n=24+25)
name old allocs/op new allocs/op delta
Template 681k ± 0% 574k ± 0% -15.71% (p=0.000 n=24+25)
Unicode 518k ± 0% 413k ± 0% -20.34% (p=0.000 n=25+24)
GoTypes 2.08M ± 0% 1.78M ± 0% -14.62% (p=0.000 n=25+25)
Compiler 9.26M ± 0% 7.64M ± 0% -17.48% (p=0.000 n=25+25)
name old text-bytes new text-bytes delta
HelloSize 578k ± 0% 578k ± 0% ~ (all samples are equal)
CmdGoSize 6.46M ± 0% 6.46M ± 0% ~ (all samples are equal)
name old data-bytes new data-bytes delta
HelloSize 128k ± 0% 128k ± 0% ~ (all samples are equal)
CmdGoSize 281k ± 0% 281k ± 0% ~ (all samples are equal)
name old exe-bytes new exe-bytes delta
HelloSize 921k ± 0% 921k ± 0% ~ (all samples are equal)
CmdGoSize 9.86M ± 0% 9.86M ± 0% ~ (all samples are equal)
Change-Id: I277d95bd56d51c166ef7f560647aeaa092f3f475
Reviewed-on: https://go-review.googlesource.com/20959
Reviewed-by: Dave Cheney <dave@cheney.net>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 5faf3b8..cc3971c 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -29,7 +29,7 @@
// It's hard to be on the heap when not-used, but best to be consistent about &~PHEAP here and below.
for i, ln := range fn.Func.Dcl {
if ln.Op == ONAME && ln.Class&^PHEAP == PAUTO {
- typecheck(&ln, Erv|Easgn)
+ ln = typecheck(ln, Erv|Easgn)
fn.Func.Dcl[i] = ln
}
}
@@ -77,7 +77,7 @@
func walkstmtlist(s []*Node) {
for i := range s {
- walkstmt(&s[i])
+ s[i] = walkstmt(s[i])
}
}
@@ -139,13 +139,14 @@
}
}
-func walkstmt(np **Node) {
- n := *np
+// The result of walkstmt MUST be assigned back to n, e.g.
+// n.Left = walkstmt(n.Left)
+func walkstmt(n *Node) *Node {
if n == nil {
- return
+ return n
}
if n.Dodata == 2 { // don't walk, generated by anylit.
- return
+ return n
}
setlineno(n)
@@ -185,11 +186,12 @@
if n.Typecheck == 0 {
Fatalf("missing typecheck: %v", Nconv(n, FmtSign))
}
+ wascopy := n.Op == OCOPY
init := n.Ninit
n.Ninit.Set(nil)
- walkexpr(&n, &init)
- addinit(&n, init.Slice())
- if (*np).Op == OCOPY && n.Op == OCONVNOP {
+ n = walkexpr(n, &init)
+ n = addinit(n, init.Slice())
+ if wascopy && n.Op == OCONVNOP {
n.Op = OEMPTY // don't leave plain values as statements.
}
@@ -202,11 +204,11 @@
init := n.Ninit
n.Ninit.Set(nil)
- walkexpr(&n.Left, &init)
+ n.Left = walkexpr(n.Left, &init)
n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, typename(n.Left.Type), n.Left, nodnil())
- walkexpr(&n, &init)
+ n = walkexpr(n, &init)
- addinit(&n, init.Slice())
+ n = addinit(n, init.Slice())
case OBREAK,
ODCL,
@@ -230,19 +232,19 @@
fallthrough
case OCASE:
- walkstmt(&n.Right)
+ n.Right = walkstmt(n.Right)
case ODEFER:
hasdefer = true
switch n.Left.Op {
case OPRINT, OPRINTN:
- walkprintfunc(&n.Left, &n.Ninit)
+ n.Left = walkprintfunc(n.Left, &n.Ninit)
case OCOPY:
n.Left = copyany(n.Left, &n.Ninit, true)
default:
- walkexpr(&n.Left, &n.Ninit)
+ n.Left = walkexpr(n.Left, &n.Ninit)
}
// make room for size & fn arguments.
@@ -253,28 +255,28 @@
walkstmtlist(n.Left.Ninit.Slice())
init := n.Left.Ninit
n.Left.Ninit.Set(nil)
- walkexpr(&n.Left, &init)
- addinit(&n.Left, init.Slice())
+ n.Left = walkexpr(n.Left, &init)
+ n.Left = addinit(n.Left, init.Slice())
}
- walkstmt(&n.Right)
+ n.Right = walkstmt(n.Right)
walkstmtlist(n.Nbody.Slice())
case OIF:
- walkexpr(&n.Left, &n.Ninit)
+ n.Left = walkexpr(n.Left, &n.Ninit)
walkstmtlist(n.Nbody.Slice())
walkstmtlist(n.Rlist.Slice())
case OPROC:
switch n.Left.Op {
case OPRINT, OPRINTN:
- walkprintfunc(&n.Left, &n.Ninit)
+ n.Left = walkprintfunc(n.Left, &n.Ninit)
case OCOPY:
n.Left = copyany(n.Left, &n.Ninit, true)
default:
- walkexpr(&n.Left, &n.Ninit)
+ n.Left = walkexpr(n.Left, &n.Ninit)
}
// make room for size & fn arguments.
@@ -349,8 +351,7 @@
if n.Op == ONAME {
Fatalf("walkstmt ended up with name: %v", Nconv(n, FmtSign))
}
-
- *np = n
+ return n
}
func isSmallMakeSlice(n *Node) bool {
@@ -374,21 +375,21 @@
// complex side effects like statements are appended to init
func walkexprlist(s []*Node, init *Nodes) {
for i := range s {
- walkexpr(&s[i], init)
+ s[i] = walkexpr(s[i], init)
}
}
func walkexprlistsafe(s []*Node, init *Nodes) {
for i, n := range s {
s[i] = safeexpr(n, init)
- walkexpr(&s[i], init)
+ s[i] = walkexpr(s[i], init)
}
}
func walkexprlistcheap(s []*Node, init *Nodes) {
for i, n := range s {
s[i] = cheapexpr(n, init)
- walkexpr(&s[i], init)
+ s[i] = walkexpr(s[i], init)
}
}
@@ -449,11 +450,11 @@
panic("unreachable")
}
-func walkexpr(np **Node, init *Nodes) {
- n := *np
-
+// 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 {
if n == nil {
- return
+ return n
}
if init == &n.Ninit {
@@ -470,9 +471,9 @@
// annoying case - not typechecked
if n.Op == OKEY {
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
- return
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
+ return n
}
lno := setlineno(n)
@@ -506,14 +507,14 @@
OIMAG,
ODOTMETH,
ODOTINTER:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case OIND:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case ODOT:
usefield(n)
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case ODOTPTR:
usefield(n)
@@ -524,17 +525,17 @@
checknil(n.Left, init)
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case OEFACE:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
case OSPTR, OITAB:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case OLEN, OCAP:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
// replace len(*[10]int) with 10.
// delayed until now to preserve side effects.
@@ -550,8 +551,8 @@
}
case OLSH, ORSH:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
t := n.Left.Type
n.Bounded = bounded(n.Right, 8*t.Width)
if Debug['m'] != 0 && n.Etype != 0 && !Isconst(n.Right, CTINT) {
@@ -574,17 +575,17 @@
n.Right = n.List.Second()
}
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
case OOR, OXOR:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
- walkrotate(&n)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
+ n = walkrotate(n)
case OEQ, ONE:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
// Disable safemode while compiling this code: the code we
// generate internally can refer to unsafe.Pointer.
@@ -594,19 +595,19 @@
old_safemode := safemode
safemode = 0
- walkcompare(&n, init)
+ n = walkcompare(n, init)
safemode = old_safemode
case OANDAND, OOROR:
- walkexpr(&n.Left, init)
+ 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
- walkexpr(&n.Right, &ll)
- addinit(&n.Right, ll.Slice())
+ n.Right = walkexpr(n.Right, &ll)
+ n.Right = addinit(n.Right, ll.Slice())
case OPRINT, OPRINTN:
walkexprlist(n.List.Slice(), init)
@@ -635,7 +636,7 @@
if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
ll := ascompatte(n.Op, n, n.Isddd, t.Params(), n.List.Slice(), 0, init)
n.List.Set(reorder1(ll))
@@ -667,7 +668,7 @@
break
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
if n.Left.Op == ONAME && n.Left.Sym.Name == "Sqrt" && n.Left.Sym.Pkg.Path == "math" {
@@ -688,7 +689,7 @@
if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
ll := ascompatte(n.Op, n, false, t.Recvs(), []*Node{n.Left.Left}, 0, init)
lr := ascompatte(n.Op, n, n.Isddd, t.Params(), n.List.Slice(), 0, init)
@@ -700,7 +701,7 @@
case OAS:
init.AppendNodes(&n.Ninit)
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
n.Left = safeexpr(n.Left, init)
if oaslit(n, init) {
@@ -713,7 +714,7 @@
switch n.Right.Op {
default:
- walkexpr(&n.Right, init)
+ n.Right = walkexpr(n.Right, init)
case ODOTTYPE:
// TODO(rsc): The Isfat is for consistency with componentgen and orderexpr.
@@ -721,13 +722,13 @@
// That would allow inlining x.(struct{*int}) the same as x.(*int).
if isdirectiface(n.Right.Type) && !Isfat(n.Right.Type) && !instrumenting {
// handled directly during cgen
- walkexpr(&n.Right, init)
+ n.Right = walkexpr(n.Right, init)
break
}
// x = i.(T); n.Left is x, n.Right.Left is i.
// orderstmt made sure x is addressable.
- walkexpr(&n.Right.Left, init)
+ n.Right.Left = walkexpr(n.Right.Left, init)
n1 := Nod(OADDR, n.Left, nil)
r := n.Right // i.(T)
@@ -737,21 +738,21 @@
}
fn := syslook(assertFuncName(r.Left.Type, r.Type, false))
- substArgTypes(&fn, r.Left.Type, r.Type)
+ fn = substArgTypes(fn, r.Left.Type, r.Type)
n = mkcall1(fn, nil, init, typename(r.Type), r.Left, n1)
- walkexpr(&n, init)
+ n = walkexpr(n, init)
break opswitch
case ORECV:
// x = <-c; n.Left is x, n.Right.Left is c.
// orderstmt made sure x is addressable.
- walkexpr(&n.Right.Left, init)
+ n.Right.Left = walkexpr(n.Right.Left, init)
n1 := Nod(OADDR, n.Left, nil)
r := n.Right.Left // the channel
n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, typename(r.Type), r, n1)
- walkexpr(&n, init)
+ n = walkexpr(n, init)
break opswitch
case OAPPEND:
@@ -796,7 +797,7 @@
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
- walkexpr(&r, init)
+ r = walkexpr(r, init)
ll := ascompatet(n.Op, n.List, r.Type, 0, init)
for i, n := range ll {
@@ -811,7 +812,7 @@
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
- walkexpr(&r.Left, init)
+ r.Left = walkexpr(r.Left, init)
var n1 *Node
if isblank(n.List.First()) {
n1 = nodnil()
@@ -822,7 +823,7 @@
fn := chanfn("chanrecv2", 2, r.Left.Type)
r = mkcall1(fn, n.List.Second().Type, init, typename(r.Left.Type), r.Left, n1)
n = Nod(OAS, n.List.Second(), r)
- typecheck(&n, Etop)
+ n = typecheck(n, Etop)
// a,b = m[i];
case OAS2MAPR:
@@ -830,8 +831,8 @@
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
- walkexpr(&r.Left, init)
- walkexpr(&r.Right, init)
+ r.Left = walkexpr(r.Left, init)
+ r.Right = walkexpr(r.Right, init)
t := r.Left.Type
p := ""
if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
@@ -881,13 +882,13 @@
var_ := temp(Ptrto(t.Type))
var_.Typecheck = 1
n.List.SetIndex(0, var_)
- walkexpr(&n, init)
+ n = walkexpr(n, init)
init.Append(n)
n = Nod(OAS, a, Nod(OIND, var_, nil))
}
- typecheck(&n, Etop)
- walkexpr(&n, init)
+ n = typecheck(n, Etop)
+ n = walkexpr(n, init)
// TODO: ptr is always non-nil, so disable nil check for this OIND op.
@@ -895,8 +896,8 @@
init.AppendNodes(&n.Ninit)
map_ := n.List.First()
key := n.List.Second()
- walkexpr(&map_, init)
- walkexpr(&key, init)
+ map_ = walkexpr(map_, init)
+ key = walkexpr(key, init)
// orderstmt made sure key is addressable.
key = Nod(OADDR, key, nil)
@@ -912,7 +913,7 @@
if isdirectiface(e.Type) && !Isfat(e.Type) && !instrumenting {
// handled directly during gen.
walkexprlistsafe(n.List.Slice(), init)
- walkexpr(&e.Left, init)
+ e.Left = walkexpr(e.Left, init)
break
}
@@ -921,7 +922,7 @@
init.AppendNodes(&n.Ninit)
walkexprlistsafe(n.List.Slice(), init)
- walkexpr(&e.Left, init)
+ e.Left = walkexpr(e.Left, init)
t := e.Type // T
from := e.Left // i
@@ -955,7 +956,7 @@
Warn("type assertion (ok only) inlined")
}
n = Nod(OAS, ok, fast)
- typecheck(&n, Etop)
+ n = typecheck(n, Etop)
break
}
}
@@ -972,19 +973,19 @@
Warn("type assertion not inlined")
}
fn := syslook(assertFuncName(from.Type, t, true))
- substArgTypes(&fn, from.Type, t)
+ fn = substArgTypes(fn, from.Type, t)
call := mkcall1(fn, oktype, init, typename(t), from, resptr)
n = Nod(OAS, ok, call)
- typecheck(&n, Etop)
+ n = typecheck(n, Etop)
case ODOTTYPE, ODOTTYPE2:
if !isdirectiface(n.Type) || Isfat(n.Type) {
Fatalf("walkexpr ODOTTYPE") // should see inside OAS only
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case OCONVIFACE:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
// Optimize convT2E as a two-word copy when T is pointer-shaped.
if isnilinter(n.Type) && isdirectiface(n.Left.Type) {
@@ -1032,20 +1033,20 @@
l := temp(Ptrto(Types[TUINT8]))
n1 := Nod(OAS, l, sym.Def)
- typecheck(&n1, Etop)
+ n1 = typecheck(n1, Etop)
init.Append(n1)
fn := syslook("typ2Itab")
n1 = Nod(OCALL, fn, nil)
n1.List.Set(ll)
- typecheck(&n1, Erv)
- walkexpr(&n1, init)
+ n1 = typecheck(n1, Erv)
+ n1 = walkexpr(n1, init)
n2 := Nod(OIF, nil, nil)
n2.Left = Nod(OEQ, l, nodnil())
n2.Nbody.Set1(Nod(OAS, l, n1))
n2.Likely = -1
- typecheck(&n2, Etop)
+ n2 = typecheck(n2, Etop)
init.Append(n2)
l = Nod(OEFACE, l, n.Left)
@@ -1076,25 +1077,25 @@
// Allocate stack buffer for value stored in interface.
r = temp(n.Left.Type)
r = Nod(OAS, r, nil) // zero temp
- typecheck(&r, Etop)
+ r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, r.Left, nil)
- typecheck(&r, Erv)
+ r = typecheck(r, Erv)
}
ll = append(ll, r)
}
fn := syslook(convFuncName(n.Left.Type, n.Type))
if !Isinter(n.Left.Type) {
- substArgTypes(&fn, n.Left.Type, n.Left.Type, n.Type)
+ fn = substArgTypes(fn, n.Left.Type, n.Left.Type, n.Type)
} else {
- substArgTypes(&fn, n.Left.Type, n.Type)
+ fn = substArgTypes(fn, n.Left.Type, n.Type)
}
dowidth(fn.Type)
n = Nod(OCALL, fn, nil)
n.List.Set(ll)
- typecheck(&n, Erv)
- walkexpr(&n, init)
+ n = typecheck(n, Erv)
+ n = walkexpr(n, init)
case OCONV, OCONVNOP:
if Thearch.Thechar == '5' {
@@ -1123,23 +1124,23 @@
}
}
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case OANDNOT:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
n.Op = OAND
n.Right = Nod(OCOM, n.Right, nil)
- typecheck(&n.Right, Erv)
- walkexpr(&n.Right, init)
+ n.Right = typecheck(n.Right, Erv)
+ n.Right = walkexpr(n.Right, init)
case OMUL:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
- walkmul(&n, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
+ n = walkmul(n, init)
case ODIV, OMOD:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
// rewrite complex div into function call.
et := n.Left.Type.Etype
@@ -1157,7 +1158,7 @@
}
// Try rewriting as shifts or magic multiplies.
- walkdiv(&n, init)
+ n = walkdiv(n, init)
// rewrite 64-bit div and mod into function calls
// on 32-bit architectures.
@@ -1181,13 +1182,13 @@
}
case OINDEX:
- walkexpr(&n.Left, init)
+ n.Left = 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
- walkexpr(&n.Right, init)
+ n.Right = walkexpr(n.Right, init)
// if range of type cannot exceed static array bound,
// disable bounds check.
@@ -1236,8 +1237,8 @@
if n.Etype == 1 {
break
}
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
t := n.Left.Type
p := ""
@@ -1273,24 +1274,24 @@
Fatalf("walkexpr ORECV") // should see inside OAS only
case OSLICE, OSLICEARR, OSLICESTR:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right.Left, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right.Left = walkexpr(n.Right.Left, init)
if n.Right.Left != nil && iszero(n.Right.Left) {
// Reduce x[0:j] to x[:j].
n.Right.Left = nil
}
- walkexpr(&n.Right.Right, init)
+ n.Right.Right = walkexpr(n.Right.Right, init)
n = reduceSlice(n)
case OSLICE3, OSLICE3ARR:
- walkexpr(&n.Left, init)
- walkexpr(&n.Right.Left, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right.Left = walkexpr(n.Right.Left, init)
if n.Right.Left != nil && iszero(n.Right.Left) {
// Reduce x[0:j:k] to x[:j:k].
n.Right.Left = nil
}
- walkexpr(&n.Right.Right.Left, init)
- walkexpr(&n.Right.Right.Right, init)
+ n.Right.Right.Left = walkexpr(n.Right.Right.Left, init)
+ n.Right.Right.Right = walkexpr(n.Right.Right.Right, init)
r := n.Right.Right.Right
if r != nil && r.Op == OCAP && samesafeexpr(n.Left, r.Left) {
@@ -1305,7 +1306,7 @@
}
case OADDR:
- walkexpr(&n.Left, init)
+ n.Left = walkexpr(n.Left, init)
case ONEW:
if n.Esc == EscNone {
@@ -1314,10 +1315,10 @@
}
r := temp(n.Type.Type)
r = Nod(OAS, r, nil) // zero temp
- typecheck(&r, Etop)
+ r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, r.Left, nil)
- typecheck(&r, Erv)
+ r = typecheck(r, Erv)
n = r
} else {
n = callnew(n.Type.Type)
@@ -1330,8 +1331,8 @@
if (Isconst(n.Left, CTSTR) && len(n.Left.Val().U.(string)) == 0) || (Isconst(n.Right, CTSTR) && len(n.Right.Val().U.(string)) == 0) {
// TODO(marvin): Fix Node.EType type union.
r := Nod(Op(n.Etype), Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil))
- typecheck(&r, Erv)
- walkexpr(&r, init)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, init)
r.Type = n.Type
n = r
break
@@ -1341,8 +1342,8 @@
if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && n.Left.List.Len() == 2 && Isconst(n.Left.List.Second(), CTSTR) && strlit(n.Right) == strlit(n.Left.List.Second()) {
// TODO(marvin): Fix Node.EType type union.
r := Nod(Op(n.Etype), Nod(OLEN, n.Left.List.First(), nil), Nodintconst(0))
- typecheck(&r, Erv)
- walkexpr(&r, init)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, init)
r.Type = n.Type
n = r
break
@@ -1371,8 +1372,8 @@
r = Nod(OOROR, Nod(ONE, Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil)), r)
}
- typecheck(&r, Erv)
- walkexpr(&r, nil)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, nil)
} else {
// sys_cmpstring(s1, s2) :: 0
r = mkcall("cmpstring", Types[TINT], init, conv(n.Left, Types[TSTRING]), conv(n.Right, Types[TSTRING]))
@@ -1381,7 +1382,7 @@
r = Nod(Op(n.Etype), r, Nodintconst(0))
}
- typecheck(&r, Erv)
+ r = typecheck(r, Erv)
if n.Type.Etype != TBOOL {
Fatalf("cmp %v", n.Type)
}
@@ -1402,7 +1403,7 @@
case OCLOSE:
fn := syslook("closechan")
- substArgTypes(&fn, n.Left.Type)
+ fn = substArgTypes(fn, n.Left.Type)
n = mkcall1(fn, nil, init, n.Left)
case OMAKECHAN:
@@ -1418,7 +1419,7 @@
var_ := temp(hmap(t))
a = Nod(OAS, var_, nil) // zero temp
- typecheck(&a, Etop)
+ a = typecheck(a, Etop)
init.Append(a)
a = Nod(OADDR, var_, nil)
@@ -1428,13 +1429,13 @@
var_ = temp(mapbucket(t))
r = Nod(OAS, var_, nil) // zero temp
- typecheck(&r, Etop)
+ r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, var_, nil)
}
fn := syslook("makemap")
- substArgTypes(&fn, hmap(t), mapbucket(t), t.Key(), t.Type)
+ fn = substArgTypes(fn, hmap(t), mapbucket(t), t.Key(), t.Type)
n = mkcall1(fn, n.Type, init, typename(n.Type), conv(n.Left, Types[TINT64]), a, r)
case OMAKESLICE:
@@ -1454,18 +1455,18 @@
t = aindex(r, t.Type) // [r]T
var_ := temp(t)
a := Nod(OAS, var_, nil) // zero temp
- typecheck(&a, Etop)
+ a = typecheck(a, Etop)
init.Append(a)
r := Nod(OSLICE, var_, Nod(OKEY, nil, l)) // arr[:l]
r = conv(r, n.Type) // in case n.Type is named.
- typecheck(&r, Erv)
- walkexpr(&r, init)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, init)
n = r
} else {
// makeslice(t *Type, nel int64, max int64) (ary []any)
fn := syslook("makeslice")
- substArgTypes(&fn, t.Type) // any-1
+ fn = substArgTypes(fn, t.Type) // any-1
n = mkcall1(fn, n.Type, init, typename(n.Type), conv(l, Types[TINT64]), conv(r, Types[TINT64]))
}
@@ -1553,7 +1554,7 @@
n.Right = cheapexpr(n.Right, init)
n.Left = cheapexpr(n.Left, init)
- substArgTypes(&fn, n.Right.Type, n.Left.Type)
+ fn = substArgTypes(fn, n.Right.Type, n.Left.Type)
r := mkcall1(fn, n.Type, init, n.Left, n.Right)
// TODO(marvin): Fix Node.EType type union.
if Op(n.Etype) == ONE {
@@ -1567,8 +1568,8 @@
} else {
r = Nod(OOROR, Nod(ONE, Nod(OITAB, n.Left, nil), Nod(OITAB, n.Right, nil)), r)
}
- typecheck(&r, Erv)
- walkexpr(&r, init)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, init)
r.Type = n.Type
n = r
@@ -1580,7 +1581,7 @@
case OSEND:
n1 := n.Right
n1 = assignconv(n1, n.Left.Type.Type, "chan send")
- walkexpr(&n1, init)
+ n1 = walkexpr(n1, init)
n1 = Nod(OADDR, n1, nil)
n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, typename(n.Left.Type), n.Left, n1)
@@ -1601,7 +1602,7 @@
evconst(n)
n.Type = t
if n.Op == OLITERAL {
- typecheck(&n, Erv)
+ n = typecheck(n, Erv)
}
ullmancalc(n)
@@ -1611,7 +1612,7 @@
}
lineno = lno
- *np = n
+ return n
}
func reduceSlice(n *Node) *Node {
@@ -1720,7 +1721,7 @@
// have been pulled from the output arguments
if fncall(l, r.Type) {
tmp := temp(r.Type)
- typecheck(&tmp, Erv)
+ tmp = typecheck(tmp, Erv)
a := Nod(OAS, l, tmp)
a = convas(a, init)
mm = append(mm, a)
@@ -1771,11 +1772,11 @@
}
n.List.Set(lr0)
n.Esc = esc
- typecheck(&n, Erv)
+ n = typecheck(n, Erv)
if n.Type == nil {
Fatalf("mkdotargslice: typecheck failed")
}
- walkexpr(&n, init)
+ n = walkexpr(n, init)
}
a := Nod(OAS, nodarg(l, fp), n)
@@ -1848,8 +1849,8 @@
a := Nod(OAS2, nil, nil)
a.List.Set(alist)
a.Rlist.Set(lr)
- typecheck(&a, Etop)
- walkstmt(&a)
+ a = typecheck(a, Etop)
+ a = walkstmt(a)
init.Append(a)
lr = alist
r = lr[0]
@@ -1945,20 +1946,20 @@
if n.Op == OLITERAL {
switch n.Val().Ctype() {
case CTRUNE:
- defaultlit(&n, runetype)
+ n = defaultlit(n, runetype)
case CTINT:
- defaultlit(&n, Types[TINT64])
+ n = defaultlit(n, Types[TINT64])
case CTFLT:
- defaultlit(&n, Types[TFLOAT64])
+ n = defaultlit(n, Types[TFLOAT64])
}
}
if n.Op != OLITERAL && n.Type != nil && n.Type.Etype == TIDEAL {
- defaultlit(&n, Types[TINT64])
+ n = defaultlit(n, Types[TINT64])
}
- defaultlit(&n, nil)
+ n = defaultlit(n, nil)
all.SetIndex(i1, n)
if n.Type == nil || n.Type.Etype == TFORW {
continue
@@ -1972,13 +1973,13 @@
} else {
on = syslook("printiface")
}
- substArgTypes(&on, n.Type) // any-1
+ on = substArgTypes(on, n.Type) // any-1
} else if Isptr[et] || et == TCHAN || et == TMAP || et == TFUNC || et == TUNSAFEPTR {
on = syslook("printpointer")
- substArgTypes(&on, n.Type) // any-1
+ on = substArgTypes(on, n.Type) // any-1
} else if Isslice(n.Type) {
on = syslook("printslice")
- substArgTypes(&on, n.Type) // any-1
+ on = substArgTypes(on, n.Type) // any-1
} else if Isint[et] {
if et == TUINT64 {
if (t.Sym.Pkg == Runtimepkg || compiling_runtime != 0) && t.Sym.Name == "hex" {
@@ -2024,8 +2025,8 @@
walkexprlist(calls, init)
r = Nod(OEMPTY, nil, nil)
- typecheck(&r, Etop)
- walkexpr(&r, init)
+ r = typecheck(r, Etop)
+ r = walkexpr(r, init)
r.Ninit.Set(calls)
return r
}
@@ -2033,7 +2034,7 @@
func callnew(t *Type) *Node {
dowidth(t)
fn := syslook("newobject")
- substArgTypes(&fn, t)
+ fn = substArgTypes(fn, t)
return mkcall1(fn, Ptrto(t), nil, typename(t))
}
@@ -2181,7 +2182,7 @@
}
if isblank(n.Left) {
- defaultlit(&n.Right, nil)
+ n.Right = defaultlit(n.Right, nil)
goto out
}
@@ -2189,9 +2190,9 @@
map_ := n.Left.Left
key := n.Left.Right
val := n.Right
- walkexpr(&map_, init)
- walkexpr(&key, init)
- walkexpr(&val, init)
+ map_ = walkexpr(map_, init)
+ key = walkexpr(key, init)
+ val = walkexpr(val, init)
// orderexpr made sure key and val are addressable.
key = Nod(OADDR, key, nil)
@@ -2203,7 +2204,7 @@
if !Eqtype(lt, rt) {
n.Right = assignconv(n.Right, lt, "assignment")
- walkexpr(&n.Right, init)
+ n.Right = walkexpr(n.Right, init)
}
out:
@@ -2296,7 +2297,7 @@
}
if l.Op == OINDEX && Isfixedarray(l.Left.Type) {
- reorder3save(&l.Right, all, i, &early)
+ l.Right = reorder3save(l.Right, all, i, &early)
l = l.Left
continue
}
@@ -2312,18 +2313,18 @@
break
case OINDEX, OINDEXMAP:
- reorder3save(&l.Left, all, i, &early)
- reorder3save(&l.Right, all, i, &early)
+ l.Left = reorder3save(l.Left, all, i, &early)
+ l.Right = reorder3save(l.Right, all, i, &early)
if l.Op == OINDEXMAP {
all[i] = convas(all[i], &mapinit)
}
case OIND, ODOTPTR:
- reorder3save(&l.Left, all, i, &early)
+ l.Left = reorder3save(l.Left, all, i, &early)
}
// Save expression on right side.
- reorder3save(&all[i].Right, all, i, &early)
+ all[i].Right = reorder3save(all[i].Right, all, i, &early)
}
early = append(mapinit.Slice(), early...)
@@ -2334,17 +2335,18 @@
// assignments in all up to but not including the ith assignment,
// copy into a temporary during *early and
// replace *np with that temp.
-func reorder3save(np **Node, all []*Node, i int, early *[]*Node) {
- n := *np
+// 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 {
if !aliased(n, all, i) {
- return
+ return n
}
q := temp(n.Type)
q = Nod(OAS, q, n)
- typecheck(&q, Etop)
+ q = typecheck(q, Etop)
*early = append(*early, q)
- *np = q.Left
+ return q.Left
}
// what's the outer value that a write to n affects?
@@ -2590,7 +2592,7 @@
if v.Class&^PHEAP != PPARAMOUT {
as := Nod(OAS, v, v.Name.Param.Stackparam)
v.Name.Param.Stackparam.Typecheck = 1
- typecheck(&as, Etop)
+ as = typecheck(as, Etop)
as = applywritebarrier(as)
nn = append(nn, as)
}
@@ -2639,11 +2641,11 @@
r := Nod(OCALL, fn, nil)
r.List.Set(va[:n])
if fn.Type.Results().NumFields() > 0 {
- typecheck(&r, Erv|Efnstruct)
+ r = typecheck(r, Erv|Efnstruct)
} else {
- typecheck(&r, Etop)
+ r = typecheck(r, Etop)
}
- walkexpr(&r, init)
+ r = walkexpr(r, init)
r.Type = t
return r
}
@@ -2662,7 +2664,7 @@
}
n = Nod(OCONV, n, nil)
n.Type = t
- typecheck(&n, Erv)
+ n = typecheck(n, Erv)
return n
}
@@ -2675,9 +2677,9 @@
default:
Fatalf("chanfn %d", n)
case 1:
- substArgTypes(&fn, t.Type)
+ fn = substArgTypes(fn, t.Type)
case 2:
- substArgTypes(&fn, t.Type, t.Type)
+ fn = substArgTypes(fn, t.Type, t.Type)
}
return fn
}
@@ -2687,7 +2689,7 @@
Fatalf("mapfn %v", t)
}
fn := syslook(name)
- substArgTypes(&fn, t.Key(), t.Type, t.Key(), t.Type)
+ fn = substArgTypes(fn, t.Key(), t.Type, t.Key(), t.Type)
return fn
}
@@ -2696,13 +2698,13 @@
Fatalf("mapfn %v", t)
}
fn := syslook(name)
- substArgTypes(&fn, t.Key(), t.Type, t.Key())
+ fn = substArgTypes(fn, t.Key(), t.Type, t.Key())
return fn
}
func writebarrierfn(name string, l *Type, r *Type) *Node {
fn := syslook(name)
- substArgTypes(&fn, l, r)
+ fn = substArgTypes(fn, l, r)
return fn
}
@@ -2763,8 +2765,8 @@
cat := syslook(fn)
r := Nod(OCALL, cat, nil)
r.List.Set(args)
- typecheck(&r, Erv)
- walkexpr(&r, init)
+ r = typecheck(r, Erv)
+ r = walkexpr(r, init)
r.Type = n.Type
return r
@@ -2816,7 +2818,7 @@
// instantiate growslice(Type*, []any, int) []any
fn := syslook("growslice")
- substArgTypes(&fn, s.Type.Type, s.Type.Type)
+ fn = substArgTypes(fn, s.Type.Type, s.Type.Type)
// s = growslice(T, s, n)
nif.Nbody.Set1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type), s, nn)))
@@ -2834,7 +2836,7 @@
nptr1.Etype = 1
nptr2 := l2
fn := syslook("typedslicecopy")
- substArgTypes(&fn, l1.Type, l2.Type)
+ fn = substArgTypes(fn, l1.Type, l2.Type)
var ln Nodes
ln.Set(l)
nt := mkcall1(fn, Types[TINT], &ln, typename(l1.Type.Type), nptr1, nptr2)
@@ -2852,7 +2854,7 @@
} else {
fn = syslook("slicecopy")
}
- substArgTypes(&fn, l1.Type, l2.Type)
+ fn = substArgTypes(fn, l1.Type, l2.Type)
var ln Nodes
ln.Set(l)
nt := mkcall1(fn, Types[TINT], &ln, nptr1, nptr2, Nodintconst(s.Type.Type.Width))
@@ -2867,7 +2869,7 @@
nptr2 := Nod(OSPTR, l2, nil)
fn := syslook("memmove")
- substArgTypes(&fn, s.Type.Type, s.Type.Type)
+ fn = substArgTypes(fn, s.Type.Type, s.Type.Type)
var ln Nodes
ln.Set(l)
@@ -2908,7 +2910,7 @@
func walkappend(n *Node, init *Nodes, dst *Node) *Node {
if !samesafeexpr(dst, n.List.First()) {
n.List.SetIndex(0, safeexpr(n.List.Index(0), init))
- walkexpr(n.List.Addr(0), init)
+ n.List.SetIndex(0, walkexpr(n.List.Index(0), init))
}
walkexprlistsafe(n.List.Slice()[1:], init)
@@ -2950,7 +2952,7 @@
nx.Left = Nod(OLT, Nod(OSUB, Nod(OCAP, ns, nil), Nod(OLEN, ns, nil)), na)
fn := syslook("growslice") // growslice(<type>, old []T, mincap int) (ret []T)
- substArgTypes(&fn, ns.Type.Type, ns.Type.Type)
+ fn = substArgTypes(fn, ns.Type.Type, ns.Type.Type)
nx.Nbody.Set1(Nod(OAS, ns,
mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type), ns,
@@ -3005,12 +3007,12 @@
} else {
fn = syslook("slicecopy")
}
- substArgTypes(&fn, n.Left.Type, n.Right.Type)
+ fn = substArgTypes(fn, n.Left.Type, n.Right.Type)
return mkcall1(fn, n.Type, init, n.Left, n.Right, Nodintconst(n.Left.Type.Type.Width))
}
- walkexpr(&n.Left, init)
- walkexpr(&n.Right, init)
+ n.Left = walkexpr(n.Left, init)
+ n.Right = walkexpr(n.Right, init)
nl := temp(n.Left.Type)
nr := temp(n.Right.Type)
var l []*Node
@@ -3035,7 +3037,7 @@
// Call memmove.
fn := syslook("memmove")
- substArgTypes(&fn, nl.Type.Type, nl.Type.Type)
+ fn = substArgTypes(fn, nl.Type.Type, nl.Type.Type)
nwid := temp(Types[TUINTPTR])
l = append(l, Nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
nwid = Nod(OMUL, nwid, Nodintconst(nl.Type.Type.Width))
@@ -3060,7 +3062,7 @@
if a == AMEM {
n := syslook("memequal")
- substArgTypes(&n, t, t)
+ n = substArgTypes(n, t, t)
*needsize = 1
return n
}
@@ -3072,15 +3074,15 @@
ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
- typecheck(&ntype, Etype)
+ ntype = typecheck(ntype, Etype)
n.Type = ntype.Type
*needsize = 0
return n
}
-func walkcompare(np **Node, init *Nodes) {
- n := *np
-
+// 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 {
// Given interface value l and concrete value r, rewrite
// l == r
// to
@@ -3103,7 +3105,7 @@
x := temp(r.Type)
if haspointers(r.Type) {
a := Nod(OAS, x, nil)
- typecheck(&a, Etop)
+ a = typecheck(a, Etop)
init.Append(a)
}
ok := temp(Types[TBOOL])
@@ -3119,8 +3121,8 @@
expr.List.Append(x)
expr.List.Append(ok)
expr.Rlist.Append(a)
- typecheck(&expr, Etop)
- walkexpr(&expr, init)
+ expr = typecheck(expr, Etop)
+ expr = walkexpr(expr, init)
if n.Op == OEQ {
r = Nod(OANDAND, ok, Nod(OEQ, x, r))
@@ -3128,8 +3130,8 @@
r = Nod(OOROR, Nod(ONOT, ok, nil), Nod(ONE, x, r))
}
init.Append(expr)
- finishcompare(np, n, r, init)
- return
+ n = finishcompare(n, n, r, init)
+ return n
}
// Must be comparison of array or struct.
@@ -3138,11 +3140,11 @@
switch t.Etype {
default:
- return
+ return n
case TARRAY:
if Isslice(t) {
- return
+ return n
}
case TSTRUCT:
@@ -3165,13 +3167,13 @@
l = temp(Ptrto(t))
a := Nod(OAS, l, Nod(OADDR, cmpl, nil))
a.Right.Etype = 1 // addr does not escape
- typecheck(&a, Etop)
+ a = typecheck(a, Etop)
init.Append(a)
r = temp(Ptrto(t))
a = Nod(OAS, r, Nod(OADDR, cmpr, nil))
a.Right.Etype = 1 // addr does not escape
- typecheck(&a, Etop)
+ a = typecheck(a, Etop)
init.Append(a)
var andor Op = OANDAND
@@ -3199,22 +3201,22 @@
if expr == nil {
expr = Nodbool(n.Op == OEQ)
}
- finishcompare(np, n, expr, init)
- return
+ n = finishcompare(n, n, expr, init)
+ return n
}
if t.Etype == TARRAY {
// Zero- or single-element array, of any type.
switch t.Bound {
case 0:
- finishcompare(np, n, Nodbool(n.Op == OEQ), init)
- return
+ n = finishcompare(n, n, Nodbool(n.Op == OEQ), init)
+ return n
case 1:
l0 := Nod(OINDEX, l, Nodintconst(0))
r0 := Nod(OINDEX, r, Nodintconst(0))
a := Nod(n.Op, l0, r0)
- finishcompare(np, n, a, init)
- return
+ n = finishcompare(n, n, a, init)
+ return n
}
}
@@ -3240,8 +3242,8 @@
if expr == nil {
expr = Nodbool(n.Op == OEQ)
}
- finishcompare(np, n, expr, init)
- return
+ n = finishcompare(n, n, expr, init)
+ return n
}
// Chose not to inline. Call equality function directly.
@@ -3258,22 +3260,25 @@
r = Nod(ONOT, r, nil)
}
- finishcompare(np, n, r, init)
- return
+ n = finishcompare(n, n, r, init)
+ return n
}
-func finishcompare(np **Node, n, r *Node, init *Nodes) {
- // Using np here to avoid passing &r to typecheck.
- *np = r
- typecheck(np, Erv)
- walkexpr(np, init)
- r = *np
+// The result of finishcompare MUST be assigned back to nn, e.g.
+// n.Left = finishcompare(n.Left, x, r, init)
+func finishcompare(nn *Node, n, r *Node, init *Nodes) *Node {
+ // Use nn here to avoid passing r to typecheck.
+ nn = r
+ nn = typecheck(nn, Erv)
+ nn = walkexpr(nn, init)
+ r = nn
if r.Type != n.Type {
r = Nod(OCONVNOP, r, nil)
r.Type = n.Type
r.Typecheck = 1
- *np = r
+ nn = r
}
+ return nn
}
func samecheap(a *Node, b *Node) bool {
@@ -3307,24 +3312,24 @@
return false
}
-func walkrotate(np **Node) {
+// The result of walkrotate MUST be assigned back to n, e.g.
+// n.Left = walkrotate(n.Left)
+func walkrotate(n *Node) *Node {
if Thearch.Thechar == '0' || Thearch.Thechar == '7' || Thearch.Thechar == '9' {
- return
+ return n
}
- n := *np
-
// Want << | >> or >> | << or << ^ >> or >> ^ << on unsigned value.
l := n.Left
r := n.Right
if (n.Op != OOR && n.Op != OXOR) || (l.Op != OLSH && l.Op != ORSH) || (r.Op != OLSH && r.Op != ORSH) || n.Type == nil || Issigned[n.Type.Etype] || l.Op == r.Op {
- return
+ return n
}
// Want same, side effect-free expression on lhs of both shifts.
if !samecheap(l.Left, r.Left) {
- return
+ return n
}
// Constants adding to width?
@@ -3349,23 +3354,22 @@
if s == 0 || s == w {
n = n.Left
}
-
- *np = n
- return
+ return n
}
}
- return
+ return n
}
// TODO: Could allow s and 32-s if s is bounded (maybe s&31 and 32-s&31).
- return
+ return n
}
// walkmul rewrites integer multiplication by powers of two as shifts.
-func walkmul(np **Node, init *Nodes) {
- n := *np
+// The result of walkmul MUST be assigned back to n, e.g.
+// n.Left = walkmul(n.Left, init)
+func walkmul(n *Node, init *Nodes) *Node {
if !Isint[n.Type.Etype] {
- return
+ return n
}
var nr *Node
@@ -3377,7 +3381,7 @@
nl = n.Right
nr = n.Left
} else {
- return
+ return n
}
neg := 0
@@ -3395,7 +3399,7 @@
pow = powtwo(nr)
if pow < 0 {
- return
+ return n
}
if pow >= 1000 {
// negative power of 2, like -16
@@ -3406,7 +3410,7 @@
w = int(nl.Type.Width * 8)
if pow+1 >= w { // too big, shouldn't happen
- return
+ return n
}
nl = cheapexpr(nl, init)
@@ -3425,24 +3429,25 @@
n = Nod(OMINUS, n, nil)
}
- typecheck(&n, Erv)
- walkexpr(&n, init)
- *np = n
+ n = typecheck(n, Erv)
+ n = walkexpr(n, init)
+ return n
}
// walkdiv rewrites division by a constant as less expensive
// operations.
-func walkdiv(np **Node, init *Nodes) {
+// The result of walkdiv MUST be assigned back to n, e.g.
+// n.Left = walkdiv(n.Left, init)
+func walkdiv(n *Node, init *Nodes) *Node {
// if >= 0, nr is 1<<pow // 1 if nr is negative.
// TODO(minux)
if Thearch.Thechar == '0' || Thearch.Thechar == '7' || Thearch.Thechar == '9' {
- return
+ return n
}
- n := *np
if n.Right.Op != OLITERAL {
- return
+ return n
}
// nr is a constant.
@@ -3465,7 +3470,7 @@
if pow+1 >= w {
// divisor too large.
- return
+ return n
}
if pow < 0 {
@@ -3484,7 +3489,7 @@
}
if m.Bad != 0 {
- return
+ return n
}
// We have a quick division method so use it
@@ -3500,7 +3505,7 @@
switch Simtype[nl.Type.Etype] {
default:
- return
+ return n
// n1 = nl * magic >> w (HMUL)
case TUINT8, TUINT16, TUINT32:
@@ -3508,13 +3513,13 @@
Nodconst(nc, nl.Type, int64(m.Um))
n1 := Nod(OHMUL, nl, nc)
- typecheck(&n1, Erv)
+ n1 = typecheck(n1, Erv)
if m.Ua != 0 {
// Select a Go type with (at least) twice the width.
var twide *Type
switch Simtype[nl.Type.Etype] {
default:
- return
+ return n
case TUINT8, TUINT16:
twide = Types[TUINT32]
@@ -3552,7 +3557,7 @@
Nodconst(nc, nl.Type, m.Sm)
n1 := Nod(OHMUL, nl, nc)
- typecheck(&n1, Erv)
+ n1 = typecheck(n1, Erv)
if m.Sm < 0 {
// add the numerator.
n1 = Nod(OADD, n1, nl)
@@ -3606,7 +3611,7 @@
Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
n1 := Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
if pow == 1 {
- typecheck(&n1, Erv)
+ n1 = typecheck(n1, Erv)
n1 = cheapexpr(n1, init)
// n = (nl+ε)&1 -ε where ε=1 iff nl<0.
@@ -3622,7 +3627,7 @@
Nodconst(nc, nl.Type, (1<<uint(pow))-1)
n2 := Nod(OAND, n1, nc) // n2 = 2^pow-1 iff nl<0.
- typecheck(&n2, Erv)
+ n2 = typecheck(n2, Erv)
n2 = cheapexpr(n2, init)
n3 := Nod(OADD, nl, n2)
@@ -3686,9 +3691,9 @@
goto ret
ret:
- typecheck(&n, Erv)
- walkexpr(&n, init)
- *np = n
+ n = typecheck(n, Erv)
+ n = walkexpr(n, init)
+ return n
}
// return 1 if integer n must be in range [0, max), 0 otherwise
@@ -3954,9 +3959,9 @@
var walkprintfunc_prgen int
-func walkprintfunc(np **Node, init *Nodes) {
- n := *np
-
+// The result of walkprintfunc MUST be assigned back to n, e.g.
+// n.Left = walkprintfunc(n.Left, init)
+func walkprintfunc(n *Node, init *Nodes) *Node {
if n.Ninit.Len() != 0 {
walkstmtlist(n.Ninit.Slice())
init.AppendNodes(&n.Ninit)
@@ -3989,14 +3994,14 @@
a = Nod(n.Op, nil, nil)
a.List.Set(printargs)
- typecheck(&a, Etop)
- walkstmt(&a)
+ a = typecheck(a, Etop)
+ a = walkstmt(a)
fn.Nbody.Set1(a)
funcbody(fn)
- typecheck(&fn, Etop)
+ fn = typecheck(fn, Etop)
typecheckslice(fn.Nbody.Slice(), Etop)
xtop = append(xtop, fn)
Curfn = oldfn
@@ -4004,7 +4009,7 @@
a = Nod(OCALL, nil, nil)
a.Left = fn.Func.Nname
a.List.Set(n.List.Slice())
- typecheck(&a, Etop)
- walkexpr(&a, init)
- *np = a
+ a = typecheck(a, Etop)
+ a = walkexpr(a, init)
+ return a
}
