aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/internal/gc/walk.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/internal/gc/walk.go')
-rw-r--r--src/cmd/internal/gc/walk.go948
1 files changed, 365 insertions, 583 deletions
diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go
index dfb965e35e..b242fd42aa 100644
--- a/src/cmd/internal/gc/walk.go
+++ b/src/cmd/internal/gc/walk.go
@@ -18,35 +18,31 @@ const (
)
func walk(fn *Node) {
- var s string
- var l *NodeList
- var lno int
-
Curfn = fn
if Debug['W'] != 0 {
- s = fmt.Sprintf("\nbefore %v", Sconv(Curfn.Nname.Sym, 0))
+ s := fmt.Sprintf("\nbefore %v", Sconv(Curfn.Nname.Sym, 0))
dumplist(s, Curfn.Nbody)
}
- lno = int(lineno)
+ lno := int(lineno)
// Final typecheck for any unused variables.
// It's hard to be on the heap when not-used, but best to be consistent about &~PHEAP here and below.
- for l = fn.Dcl; l != nil; l = l.Next {
+ for l := fn.Dcl; l != nil; l = l.Next {
if l.N.Op == ONAME && l.N.Class&^PHEAP == PAUTO {
typecheck(&l.N, Erv|Easgn)
}
}
// Propagate the used flag for typeswitch variables up to the NONAME in it's definition.
- for l = fn.Dcl; l != nil; l = l.Next {
+ for l := fn.Dcl; l != nil; l = l.Next {
if l.N.Op == ONAME && l.N.Class&^PHEAP == PAUTO && l.N.Defn != nil && l.N.Defn.Op == OTYPESW && l.N.Used != 0 {
l.N.Defn.Left.Used++
}
}
- for l = fn.Dcl; l != nil; l = l.Next {
+ for l := fn.Dcl; l != nil; l = l.Next {
if l.N.Op != ONAME || l.N.Class&^PHEAP != PAUTO || l.N.Sym.Name[0] == '&' || l.N.Used != 0 {
continue
}
@@ -69,13 +65,13 @@ func walk(fn *Node) {
}
walkstmtlist(Curfn.Nbody)
if Debug['W'] != 0 {
- s = fmt.Sprintf("after walk %v", Sconv(Curfn.Nname.Sym, 0))
+ s := fmt.Sprintf("after walk %v", Sconv(Curfn.Nname.Sym, 0))
dumplist(s, Curfn.Nbody)
}
heapmoves()
if Debug['W'] != 0 && Curfn.Enter != nil {
- s = fmt.Sprintf("enter %v", Sconv(Curfn.Nname.Sym, 0))
+ s := fmt.Sprintf("enter %v", Sconv(Curfn.Nname.Sym, 0))
dumplist(s, Curfn.Enter)
}
}
@@ -96,9 +92,7 @@ func samelist(a *NodeList, b *NodeList) bool {
}
func paramoutheap(fn *Node) int {
- var l *NodeList
-
- for l = fn.Dcl; l != nil; l = l.Next {
+ for l := fn.Dcl; l != nil; l = l.Next {
switch l.N.Class {
case PPARAMOUT,
PPARAMOUT | PHEAP:
@@ -117,13 +111,11 @@ func paramoutheap(fn *Node) int {
// adds "adjust" to all the argument locations for the call n.
// n must be a defer or go node that has already been walked.
func adjustargs(n *Node, adjust int) {
- var callfunc *Node
var arg *Node
var lhs *Node
- var args *NodeList
- callfunc = n.Left
- for args = callfunc.List; args != nil; args = args.Next {
+ callfunc := n.Left
+ for args := callfunc.List; args != nil; args = args.Next {
arg = args.N
if arg.Op != OAS {
Yyerror("call arg not assignment")
@@ -147,14 +139,7 @@ func adjustargs(n *Node, adjust int) {
}
func walkstmt(np **Node) {
- var init *NodeList
- var ll *NodeList
- var rl *NodeList
- var cl int
- var n *Node
- var f *Node
-
- n = *np
+ n := *np
if n == nil {
return
}
@@ -198,7 +183,7 @@ func walkstmt(np **Node) {
if n.Typecheck == 0 {
Fatal("missing typecheck: %v", Nconv(n, obj.FmtSign))
}
- init = n.Ninit
+ init := n.Ninit
n.Ninit = nil
walkexpr(&n, &init)
addinit(&n, init)
@@ -212,7 +197,7 @@ func walkstmt(np **Node) {
if n.Typecheck == 0 {
Fatal("missing typecheck: %v", Nconv(n, obj.FmtSign))
}
- init = n.Ninit
+ init := n.Ninit
n.Ninit = nil
walkexpr(&n.Left, &init)
@@ -264,7 +249,7 @@ func walkstmt(np **Node) {
case OFOR:
if n.Ntest != nil {
walkstmtlist(n.Ntest.Ninit)
- init = n.Ntest.Ninit
+ init := n.Ntest.Ninit
n.Ntest.Ninit = nil
walkexpr(&n.Ntest, &init)
addinit(&n.Ntest, init)
@@ -302,9 +287,10 @@ func walkstmt(np **Node) {
if (Curfn.Type.Outnamed != 0 && count(n.List) > 1) || paramoutheap(Curfn) != 0 {
// assign to the function out parameters,
// so that reorder3 can fix up conflicts
- rl = nil
+ rl := (*NodeList)(nil)
- for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ var cl int
+ for ll := Curfn.Dcl; ll != nil; ll = ll.Next {
cl = int(ll.N.Class) &^ PHEAP
if cl == PAUTO {
break
@@ -323,7 +309,7 @@ func walkstmt(np **Node) {
if count(n.List) == 1 && count(rl) > 1 {
// OAS2FUNC in disguise
- f = n.List.N
+ f := n.List.N
if f.Op != OCALLFUNC && f.Op != OCALLMETH && f.Op != OCALLINTER {
Fatal("expected return of call, have %v", Nconv(f, 0))
@@ -335,12 +321,12 @@ func walkstmt(np **Node) {
// move function calls out, to make reorder3's job easier.
walkexprlistsafe(n.List, &n.Ninit)
- ll = ascompatee(int(n.Op), rl, n.List, &n.Ninit)
+ ll := ascompatee(int(n.Op), rl, n.List, &n.Ninit)
n.List = reorder3(ll)
break
}
- ll = ascompatte(int(n.Op), nil, 0, Getoutarg(Curfn.Type), n.List, 1, &n.Ninit)
+ ll := ascompatte(int(n.Op), nil, 0, Getoutarg(Curfn.Type), n.List, 1, &n.Ninit)
n.List = ll
case ORETJMP:
@@ -395,31 +381,7 @@ func walkexprlistcheap(l *NodeList, init **NodeList) {
}
func walkexpr(np **Node, init **NodeList) {
- var r *Node
- var l *Node
- var var_ *Node
- var a *Node
- var ok *Node
- var map_ *Node
- var key *Node
- var ll *NodeList
- var lr *NodeList
- var t *Type
- var et int
- var old_safemode int
- var v int64
- var lno int32
- var n *Node
- var fn *Node
- var n1 *Node
- var n2 *Node
- var sym *Sym
- var buf string
- var p string
- var from string
- var to string
-
- n = *np
+ n := *np
if n == nil {
return
@@ -445,7 +407,7 @@ func walkexpr(np **Node, init **NodeList) {
return
}
- lno = setlineno(n)
+ lno := setlineno(n)
if Debug['w'] > 1 {
Dump("walk-before", n)
@@ -515,7 +477,7 @@ func walkexpr(np **Node, init **NodeList) {
// replace len(*[10]int) with 10.
// delayed until now to preserve side effects.
- t = n.Left.Type
+ t := n.Left.Type
if Isptr[t.Etype] != 0 {
t = t.Type
@@ -532,7 +494,7 @@ func walkexpr(np **Node, init **NodeList) {
ORSH:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
- t = n.Left.Type
+ t := n.Left.Type
n.Bounded = bounded(n.Right, 8*t.Width)
if Debug['m'] != 0 && n.Etype != 0 && !Isconst(n.Right, CTINT) {
Warn("shift bounds check elided")
@@ -576,7 +538,7 @@ func walkexpr(np **Node, init **NodeList) {
// In this case it can happen if we need to generate an ==
// for a struct containing a reflect.Value, which itself has
// an unexported field of type unsafe.Pointer.
- old_safemode = safemode
+ old_safemode := safemode
safemode = 0
walkcompare(&n, init)
@@ -590,7 +552,7 @@ func walkexpr(np **Node, init **NodeList) {
// 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.
- ll = nil
+ ll := (*NodeList)(nil)
walkexpr(&n.Right, &ll)
addinit(&n.Right, ll)
@@ -626,13 +588,13 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
case OCALLINTER:
- t = n.Left.Type
+ t := n.Left.Type
if n.List != nil && n.List.N.Op == OAS {
goto ret
}
walkexpr(&n.Left, init)
walkexprlist(n.List, init)
- ll = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ ll := ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
n.List = reorder1(ll)
goto ret
@@ -652,7 +614,7 @@ func walkexpr(np **Node, init **NodeList) {
// Update type of OCALLFUNC node.
// Output arguments had not changed, but their offsets could.
if n.Left.Type.Outtuple == 1 {
- t = getoutargx(n.Left.Type).Type
+ t := getoutargx(n.Left.Type).Type
if t.Etype == TFIELD {
t = t.Type
}
@@ -662,7 +624,7 @@ func walkexpr(np **Node, init **NodeList) {
}
}
- t = n.Left.Type
+ t := n.Left.Type
if n.List != nil && n.List.N.Op == OAS {
goto ret
}
@@ -670,19 +632,19 @@ func walkexpr(np **Node, init **NodeList) {
walkexpr(&n.Left, init)
walkexprlist(n.List, init)
- ll = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ ll := ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
n.List = reorder1(ll)
goto ret
case OCALLMETH:
- t = n.Left.Type
+ t := n.Left.Type
if n.List != nil && n.List.N.Op == OAS {
goto ret
}
walkexpr(&n.Left, init)
walkexprlist(n.List, init)
- ll = ascompatte(int(n.Op), n, 0, getthis(t), list1(n.Left.Left), 0, init)
- lr = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ ll := ascompatte(int(n.Op), n, 0, getthis(t), list1(n.Left.Left), 0, init)
+ lr := ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
ll = concat(ll, lr)
n.Left.Left = nil
ullmancalc(n.Left)
@@ -713,12 +675,12 @@ func walkexpr(np **Node, init **NodeList) {
case ODOTTYPE:
walkexpr(&n.Right.Left, init)
- n1 = Nod(OADDR, n.Left, nil)
- r = n.Right // i.(T)
+ n1 := Nod(OADDR, n.Left, nil)
+ r := n.Right // i.(T)
- from = "I"
+ from := "I"
- to = "T"
+ to := "T"
if isnilinter(r.Left.Type) {
from = "E"
}
@@ -728,9 +690,9 @@ func walkexpr(np **Node, init **NodeList) {
to = "I"
}
- buf = fmt.Sprintf("assert%s2%s", from, to)
+ buf := fmt.Sprintf("assert%s2%s", from, to)
- fn = syslook(buf, 1)
+ fn := syslook(buf, 1)
argtype(fn, r.Left.Type)
argtype(fn, r.Type)
@@ -743,15 +705,15 @@ func walkexpr(np **Node, init **NodeList) {
case ORECV:
walkexpr(&n.Right.Left, init)
- n1 = Nod(OADDR, n.Left, nil)
- r = n.Right.Left // the channel
+ 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)
goto ret
}
if n.Left != nil && n.Right != nil {
- r = convas(Nod(OAS, n.Left, n.Right), init)
+ r := convas(Nod(OAS, n.Left, n.Right), init)
r.Dodata = n.Dodata
n = r
n = applywritebarrier(n, init)
@@ -764,9 +726,9 @@ func walkexpr(np **Node, init **NodeList) {
n.Ninit = nil
walkexprlistsafe(n.List, init)
walkexprlistsafe(n.Rlist, init)
- ll = ascompatee(OAS, n.List, n.Rlist, init)
+ ll := ascompatee(OAS, n.List, n.Rlist, init)
ll = reorder3(ll)
- for lr = ll; lr != nil; lr = lr.Next {
+ for lr := ll; lr != nil; lr = lr.Next {
lr.N = applywritebarrier(lr.N, init)
}
n = liststmt(ll)
@@ -777,12 +739,12 @@ func walkexpr(np **Node, init **NodeList) {
*init = concat(*init, n.Ninit)
n.Ninit = nil
- r = n.Rlist.N
+ r := n.Rlist.N
walkexprlistsafe(n.List, init)
walkexpr(&r, init)
- ll = ascompatet(int(n.Op), n.List, &r.Type, 0, init)
- for lr = ll; lr != nil; lr = lr.Next {
+ ll := ascompatet(int(n.Op), n.List, &r.Type, 0, init)
+ for lr := ll; lr != nil; lr = lr.Next {
lr.N = applywritebarrier(lr.N, init)
}
n = liststmt(concat(list1(r), ll))
@@ -794,16 +756,17 @@ func walkexpr(np **Node, init **NodeList) {
*init = concat(*init, n.Ninit)
n.Ninit = nil
- r = n.Rlist.N
+ r := n.Rlist.N
walkexprlistsafe(n.List, init)
walkexpr(&r.Left, init)
+ var n1 *Node
if isblank(n.List.N) {
n1 = nodnil()
} else {
n1 = Nod(OADDR, n.List.N, nil)
}
n1.Etype = 1 // addr does not escape
- fn = chanfn("chanrecv2", 2, r.Left.Type)
+ fn := chanfn("chanrecv2", 2, r.Left.Type)
r = mkcall1(fn, n.List.Next.N.Type, init, typename(r.Left.Type), r.Left, n1)
n = Nod(OAS, n.List.Next.N, r)
typecheck(&n, Etop)
@@ -814,12 +777,12 @@ func walkexpr(np **Node, init **NodeList) {
*init = concat(*init, n.Ninit)
n.Ninit = nil
- r = n.Rlist.N
+ r := n.Rlist.N
walkexprlistsafe(n.List, init)
walkexpr(&r.Left, init)
walkexpr(&r.Right, init)
- t = r.Left.Type
- p = ""
+ t := r.Left.Type
+ p := ""
if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
switch Simsimtype(t.Down) {
case TINT32,
@@ -835,6 +798,7 @@ func walkexpr(np **Node, init **NodeList) {
}
}
+ var key *Node
if p != "" {
// fast versions take key by value
key = r.Right
@@ -851,9 +815,9 @@ func walkexpr(np **Node, init **NodeList) {
// to:
// var,b = mapaccess2*(t, m, i)
// a = *var
- a = n.List.N
+ a := n.List.N
- fn = mapfn(p, t)
+ fn := mapfn(p, t)
r = mkcall1(fn, getoutargx(fn.Type), init, typename(t), r.Left, key)
// mapaccess2* returns a typed bool, but due to spec changes,
@@ -867,7 +831,7 @@ func walkexpr(np **Node, init **NodeList) {
// don't generate a = *var if a is _
if !isblank(a) {
- var_ = temp(Ptrto(t.Type))
+ var_ := temp(Ptrto(t.Type))
var_.Typecheck = 1
n.List.N = var_
walkexpr(&n, init)
@@ -889,15 +853,15 @@ func walkexpr(np **Node, init **NodeList) {
case ODELETE:
*init = concat(*init, n.Ninit)
n.Ninit = nil
- map_ = n.List.N
- key = n.List.Next.N
+ map_ := n.List.N
+ key := n.List.Next.N
walkexpr(&map_, init)
walkexpr(&key, init)
// orderstmt made sure key is addressable.
key = Nod(OADDR, key, nil)
- t = map_.Type
+ t := map_.Type
n = mkcall1(mapfndel("mapdelete", t), nil, init, typename(t), map_, key)
goto ret
@@ -907,9 +871,10 @@ func walkexpr(np **Node, init **NodeList) {
*init = concat(*init, n.Ninit)
n.Ninit = nil
- r = n.Rlist.N
+ r := n.Rlist.N
walkexprlistsafe(n.List, init)
walkexpr(&r.Left, init)
+ var n1 *Node
if isblank(n.List.N) {
n1 = nodnil()
} else {
@@ -917,9 +882,9 @@ func walkexpr(np **Node, init **NodeList) {
}
n1.Etype = 1 // addr does not escape
- from = "I"
+ from := "I"
- to = "T"
+ to := "T"
if isnilinter(r.Left.Type) {
from = "E"
}
@@ -928,14 +893,14 @@ func walkexpr(np **Node, init **NodeList) {
} else if Isinter(r.Type) {
to = "I"
}
- buf = fmt.Sprintf("assert%s2%s2", from, to)
+ buf := fmt.Sprintf("assert%s2%s2", from, to)
- fn = syslook(buf, 1)
+ fn := syslook(buf, 1)
argtype(fn, r.Left.Type)
argtype(fn, r.Type)
- t = Types[TBOOL]
- ok = n.List.Next.N
+ t := Types[TBOOL]
+ ok := n.List.Next.N
if !isblank(ok) {
t = ok.Type
}
@@ -953,7 +918,7 @@ func walkexpr(np **Node, init **NodeList) {
// Optimize convT2E as a two-word copy when T is pointer-shaped.
if isnilinter(n.Type) && isdirectiface(n.Left.Type) {
- l = Nod(OEFACE, typename(n.Left.Type), n.Left)
+ l := Nod(OEFACE, typename(n.Left.Type), n.Left)
l.Type = n.Type
l.Typecheck = n.Typecheck
n = l
@@ -963,9 +928,9 @@ func walkexpr(np **Node, init **NodeList) {
// Build name of function: convI2E etc.
// Not all names are possible
// (e.g., we'll never generate convE2E or convE2I).
- from = "T"
+ from := "T"
- to = "I"
+ to := "I"
if isnilinter(n.Left.Type) {
from = "E"
} else if Isinter(n.Left.Type) {
@@ -974,10 +939,10 @@ func walkexpr(np **Node, init **NodeList) {
if isnilinter(n.Type) {
to = "E"
}
- buf = fmt.Sprintf("conv%s2%s", from, to)
+ buf := fmt.Sprintf("conv%s2%s", from, to)
- fn = syslook(buf, 1)
- ll = nil
+ fn := syslook(buf, 1)
+ ll := (*NodeList)(nil)
if !Isinter(n.Left.Type) {
ll = list(ll, typename(n.Left.Type))
}
@@ -985,9 +950,9 @@ func walkexpr(np **Node, init **NodeList) {
ll = list(ll, typename(n.Type))
}
if !Isinter(n.Left.Type) && !isnilinter(n.Type) {
- sym = Pkglookup(fmt.Sprintf("%v.%v", Tconv(n.Left.Type, obj.FmtLeft), Tconv(n.Type, obj.FmtLeft)), itabpkg)
+ sym := Pkglookup(fmt.Sprintf("%v.%v", Tconv(n.Left.Type, obj.FmtLeft), Tconv(n.Type, obj.FmtLeft)), itabpkg)
if sym.Def == nil {
- l = Nod(ONAME, nil, nil)
+ l := Nod(ONAME, nil, nil)
l.Sym = sym
l.Type = Ptrto(Types[TUINT8])
l.Addable = 1
@@ -997,7 +962,7 @@ func walkexpr(np **Node, init **NodeList) {
ggloblsym(sym, int32(Widthptr), obj.DUPOK|obj.NOPTR)
}
- l = Nod(OADDR, sym.Def, nil)
+ l := Nod(OADDR, sym.Def, nil)
l.Addable = 1
ll = list(ll, l)
@@ -1012,19 +977,19 @@ func walkexpr(np **Node, init **NodeList) {
* The CONVIFACE expression is replaced with this:
* OEFACE{tab, ptr};
*/
- l = temp(Ptrto(Types[TUINT8]))
+ l := temp(Ptrto(Types[TUINT8]))
- n1 = Nod(OAS, l, sym.Def)
+ n1 := Nod(OAS, l, sym.Def)
typecheck(&n1, Etop)
*init = list(*init, n1)
- fn = syslook("typ2Itab", 1)
+ fn := syslook("typ2Itab", 1)
n1 = Nod(OCALL, fn, nil)
n1.List = ll
typecheck(&n1, Erv)
walkexpr(&n1, init)
- n2 = Nod(OIF, nil, nil)
+ n2 := Nod(OIF, nil, nil)
n2.Ntest = Nod(OEQ, l, nodnil())
n2.Nbody = list1(Nod(OAS, l, n1))
n2.Likely = -1
@@ -1117,10 +1082,10 @@ func walkexpr(np **Node, init **NodeList) {
/*
* rewrite complex div into function call.
*/
- et = int(n.Left.Type.Etype)
+ et := int(n.Left.Type.Etype)
if Iscomplex[et] != 0 && n.Op == ODIV {
- t = n.Type
+ t := n.Type
n = mkcall("complex128div", Types[TCOMPLEX128], init, conv(n.Left, Types[TCOMPLEX128]), conv(n.Right, Types[TCOMPLEX128]))
n = conv(n, t)
goto ret
@@ -1167,7 +1132,7 @@ func walkexpr(np **Node, init **NodeList) {
// save the original node for bounds checking elision.
// If it was a ODIV/OMOD walk might rewrite it.
- r = n.Right
+ r := n.Right
walkexpr(&n.Right, init)
@@ -1176,7 +1141,7 @@ func walkexpr(np **Node, init **NodeList) {
if n.Bounded {
goto ret
}
- t = n.Left.Type
+ t := n.Left.Type
if t != nil && Isptr[t.Etype] != 0 {
t = t.Type
}
@@ -1200,7 +1165,7 @@ func walkexpr(np **Node, init **NodeList) {
// replace "abc"[1] with 'b'.
// delayed until now because "abc"[1] is not
// an ideal constant.
- v = Mpgetfix(n.Right.Val.U.Xval)
+ v := Mpgetfix(n.Right.Val.U.Xval)
Nodconst(n, n.Type, int64(n.Left.Val.U.Sval.S[v]))
n.Typecheck = 1
@@ -1222,8 +1187,8 @@ func walkexpr(np **Node, init **NodeList) {
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
- t = n.Left.Type
- p = ""
+ t := n.Left.Type
+ p := ""
if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
switch Simsimtype(t.Down) {
case TINT32,
@@ -1239,6 +1204,7 @@ func walkexpr(np **Node, init **NodeList) {
}
}
+ var key *Node
if p != "" {
// fast versions take key by value
key = n.Right
@@ -1325,7 +1291,7 @@ func walkexpr(np **Node, init **NodeList) {
case ONEW:
if n.Esc == EscNone && n.Type.Type.Width < 1<<16 {
- r = temp(n.Type.Type)
+ r := temp(n.Type.Type)
r = Nod(OAS, r, nil) // zero temp
typecheck(&r, Etop)
*init = list(*init, r)
@@ -1343,7 +1309,7 @@ func walkexpr(np **Node, init **NodeList) {
// without the function call.
case OCMPSTR:
if (Isconst(n.Left, CTSTR) && len(n.Left.Val.U.Sval.S) == 0) || (Isconst(n.Right, CTSTR) && len(n.Right.Val.U.Sval.S) == 0) {
- r = Nod(int(n.Etype), Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil))
+ r := Nod(int(n.Etype), Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil))
typecheck(&r, Erv)
walkexpr(&r, init)
r.Type = n.Type
@@ -1353,7 +1319,7 @@ func walkexpr(np **Node, init **NodeList) {
// s + "badgerbadgerbadger" == "badgerbadgerbadger"
if (n.Etype == OEQ || n.Etype == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && count(n.Left.List) == 2 && Isconst(n.Left.List.Next.N, CTSTR) && cmpslit(n.Right, n.Left.List.Next.N) == 0 {
- r = Nod(int(n.Etype), Nod(OLEN, n.Left.List.N, nil), Nodintconst(0))
+ r := Nod(int(n.Etype), Nod(OLEN, n.Left.List.N, nil), Nodintconst(0))
typecheck(&r, Erv)
walkexpr(&r, init)
r.Type = n.Type
@@ -1361,6 +1327,7 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
}
+ var r *Node
if n.Etype == OEQ || n.Etype == ONE {
// prepare for rewrite below
n.Left = cheapexpr(n.Left, init)
@@ -1416,7 +1383,7 @@ func walkexpr(np **Node, init **NodeList) {
// cannot use chanfn - closechan takes any, not chan any
case OCLOSE:
- fn = syslook("closechan", 1)
+ fn := syslook("closechan", 1)
argtype(fn, n.Left.Type)
n = mkcall1(fn, nil, init, n.Left)
@@ -1427,15 +1394,15 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
case OMAKEMAP:
- t = n.Type
+ t := n.Type
- fn = syslook("makemap", 1)
+ fn := syslook("makemap", 1)
- a = nodnil() // hmap buffer
- r = nodnil() // bucket buffer
+ a := nodnil() // hmap buffer
+ r := nodnil() // bucket buffer
if n.Esc == EscNone {
// Allocate hmap buffer on stack.
- var_ = temp(hmap(t))
+ var_ := temp(hmap(t))
a = Nod(OAS, var_, nil) // zero temp
typecheck(&a, Etop)
@@ -1461,29 +1428,29 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
case 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 n.Esc == EscNone && Smallintconst(l) && Smallintconst(r) && (t.Type.Width == 0 || Mpgetfix(r.Val.U.Xval) < (1<<16)/t.Type.Width) {
// var arr [r]T
// n = arr[:l]
t = aindex(r, t.Type) // [r]T
- var_ = temp(t)
- a = Nod(OAS, var_, nil) // zero temp
+ var_ := temp(t)
+ a := Nod(OAS, var_, nil) // zero temp
typecheck(&a, Etop)
*init = list(*init, a)
- r = Nod(OSLICE, var_, Nod(OKEY, nil, l)) // arr[:l]
- r = conv(r, n.Type) // in case n->type is named.
+ 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)
n = r
} else {
// makeslice(t *Type, nel int64, max int64) (ary []any)
- fn = syslook("makeslice", 1)
+ fn := syslook("makeslice", 1)
argtype(fn, t.Type) // any-1
n = mkcall1(fn, n.Type, init, typename(n.Type), conv(l, Types[TINT64]), conv(r, Types[TINT64]))
@@ -1492,10 +1459,10 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
case ORUNESTR:
- a = nodnil()
+ a := nodnil()
if n.Esc == EscNone {
- t = aindex(Nodintconst(4), Types[TUINT8])
- var_ = temp(t)
+ t := aindex(Nodintconst(4), Types[TUINT8])
+ var_ := temp(t)
a = Nod(OADDR, var_, nil)
}
@@ -1505,10 +1472,10 @@ func walkexpr(np **Node, init **NodeList) {
goto ret
case OARRAYBYTESTR:
- a = nodnil()
+ a := nodnil()
if n.Esc == EscNone {
// Create temporary buffer for string on stack.
- t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+ t := aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
a = Nod(OADDR, temp(t), nil)
}
@@ -1526,11 +1493,11 @@ func walkexpr(np **Node, init **NodeList) {
// slicerunetostring(*[32]byte, []rune) string;
case OARRAYRUNESTR:
- a = nodnil()
+ a := nodnil()
if n.Esc == EscNone {
// Create temporary buffer for string on stack.
- t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+ t := aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
a = Nod(OADDR, temp(t), nil)
}
@@ -1540,11 +1507,11 @@ func walkexpr(np **Node, init **NodeList) {
// stringtoslicebyte(*32[byte], string) []byte;
case OSTRARRAYBYTE:
- a = nodnil()
+ a := nodnil()
if n.Esc == EscNone {
// Create temporary buffer for slice on stack.
- t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+ t := aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
a = Nod(OADDR, temp(t), nil)
}
@@ -1560,11 +1527,11 @@ func walkexpr(np **Node, init **NodeList) {
// stringtoslicerune(*[32]rune, string) []rune
case OSTRARRAYRUNE:
- a = nodnil()
+ a := nodnil()
if n.Esc == EscNone {
// Create temporary buffer for slice on stack.
- t = aindex(Nodintconst(tmpstringbufsize), Types[TINT32])
+ t := aindex(Nodintconst(tmpstringbufsize), Types[TINT32])
a = Nod(OADDR, temp(t), nil)
}
@@ -1577,6 +1544,7 @@ func walkexpr(np **Node, init **NodeList) {
if !Eqtype(n.Left.Type, n.Right.Type) {
Fatal("ifaceeq %v %v %v", Oconv(int(n.Op), 0), Tconv(n.Left.Type, 0), Tconv(n.Right.Type, 0))
}
+ var fn *Node
if isnilinter(n.Left.Type) {
fn = syslook("efaceeq", 1)
} else {
@@ -1587,7 +1555,7 @@ func walkexpr(np **Node, init **NodeList) {
n.Left = cheapexpr(n.Left, init)
argtype(fn, n.Right.Type)
argtype(fn, n.Left.Type)
- r = mkcall1(fn, n.Type, init, n.Left, n.Right)
+ r := mkcall1(fn, n.Type, init, n.Left, n.Right)
if n.Etype == ONE {
r = Nod(ONOT, r, nil)
}
@@ -1608,13 +1576,13 @@ func walkexpr(np **Node, init **NodeList) {
OMAPLIT,
OSTRUCTLIT,
OPTRLIT:
- var_ = temp(n.Type)
+ var_ := temp(n.Type)
anylit(0, n, var_, init)
n = var_
goto ret
case OSEND:
- n1 = n.Right
+ n1 := n.Right
n1 = assignconv(n1, n.Left.Type.Type, "chan send")
walkexpr(&n1, init)
n1 = Nod(OADDR, n1, nil)
@@ -1638,7 +1606,7 @@ func walkexpr(np **Node, init **NodeList) {
// walk of y%1 may have replaced it by 0.
// Check whether n with its updated args is itself now a constant.
ret:
- t = n.Type
+ t := n.Type
evconst(n)
n.Type = t
@@ -1657,11 +1625,9 @@ ret:
}
func ascompatee1(op int, l *Node, r *Node, init **NodeList) *Node {
- var n *Node
-
// convas will turn map assigns into function calls,
// making it impossible for reorder3 to work.
- n = Nod(OAS, l, r)
+ n := Nod(OAS, l, r)
if l.Op == OINDEXMAP {
return n
@@ -1673,7 +1639,6 @@ func ascompatee1(op int, l *Node, r *Node, init **NodeList) *Node {
func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
var ll *NodeList
var lr *NodeList
- var nn *NodeList
/*
* check assign expression list to
@@ -1689,7 +1654,7 @@ func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
lr.N = safeexpr(lr.N, init)
}
- nn = nil
+ nn := (*NodeList)(nil)
ll = nl
lr = nr
for ; ll != nil && lr != nil; (func() { ll = ll.Next; lr = lr.Next })() {
@@ -1714,12 +1679,10 @@ func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
* in the conversion of the types
*/
func fncall(l *Node, rt *Type) bool {
- var r Node
-
if l.Ullman >= UINF || l.Op == OINDEXMAP {
return true
}
- r = Node{}
+ r := Node{}
if needwritebarrier(l, &r) {
return true
}
@@ -1734,22 +1697,18 @@ func ascompatet(op int, nl *NodeList, nr **Type, fp int, init **NodeList) *NodeL
var tmp *Node
var a *Node
var ll *NodeList
- var r *Type
var saver Iter
- var ucount int
- var nn *NodeList
- var mm *NodeList
/*
* check assign type list to
* a expression list. called in
* expr-list = func()
*/
- r = Structfirst(&saver, nr)
+ r := Structfirst(&saver, nr)
- nn = nil
- mm = nil
- ucount = 0
+ nn := (*NodeList)(nil)
+ mm := (*NodeList)(nil)
+ ucount := 0
for ll = nl; ll != nil; ll = ll.Next {
if r == nil {
break
@@ -1798,20 +1757,16 @@ func ascompatet(op int, nl *NodeList, nr **Type, fp int, init **NodeList) *NodeL
* package all the arguments that match a ... T parameter into a []T.
*/
func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList, ddd *Node) *NodeList {
- var a *Node
- var n *Node
- var tslice *Type
- var esc int
-
- esc = EscUnknown
+ esc := EscUnknown
if ddd != nil {
esc = int(ddd.Esc)
}
- tslice = typ(TARRAY)
+ tslice := typ(TARRAY)
tslice.Type = l.Type.Type
tslice.Bound = -1
+ var n *Node
if count(lr0) == 0 {
n = nodnil()
n.Type = tslice
@@ -1829,7 +1784,7 @@ func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList
walkexpr(&n, init)
}
- a = Nod(OAS, nodarg(l, fp), n)
+ a := Nod(OAS, nodarg(l, fp), n)
nn = list(nn, convas(a, init))
return nn
}
@@ -1838,15 +1793,12 @@ func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList
* helpers for shape errors
*/
func dumptypes(nl **Type, what string) string {
- var first int
- var l *Type
var savel Iter
- var fmt_ string
- fmt_ = ""
+ fmt_ := ""
fmt_ += fmt.Sprintf("\t")
- first = 1
- for l = Structfirst(&savel, nl); l != nil; l = structnext(&savel) {
+ first := 1
+ for l := Structfirst(&savel, nl); l != nil; l = structnext(&savel) {
if first != 0 {
first = 0
} else {
@@ -1862,13 +1814,11 @@ func dumptypes(nl **Type, what string) string {
}
func dumpnodetypes(l *NodeList, what string) string {
- var first int
var r *Node
- var fmt_ string
- fmt_ = ""
+ fmt_ := ""
fmt_ += fmt.Sprintf("\t")
- first = 1
+ first := 1
for ; l != nil; l = l.Next {
r = l.N
if first != 0 {
@@ -1892,30 +1842,25 @@ func dumpnodetypes(l *NodeList, what string) string {
* func(expr-list)
*/
func ascompatte(op int, call *Node, isddd int, nl **Type, lr *NodeList, fp int, init **NodeList) *NodeList {
- var l *Type
- var ll *Type
- var r *Node
- var a *Node
- var nn *NodeList
- var lr0 *NodeList
- var alist *NodeList
var savel Iter
- var l1 string
- var l2 string
- lr0 = lr
- l = Structfirst(&savel, nl)
- r = nil
+ lr0 := lr
+ l := Structfirst(&savel, nl)
+ r := (*Node)(nil)
if lr != nil {
r = lr.N
}
- nn = nil
+ nn := (*NodeList)(nil)
// f(g()) where g has multiple return values
+ var a *Node
+ var l2 string
+ var ll *Type
+ var l1 string
if r != nil && lr.Next == nil && r.Type.Etype == TSTRUCT && r.Type.Funarg != 0 {
// optimization - can do block copy
if eqtypenoname(r.Type, *nl) {
- a = nodarg(*nl, fp)
+ a := nodarg(*nl, fp)
r = Nod(OCONVNOP, r, nil)
r.Type = a.Type
nn = list1(convas(Nod(OAS, a, r), init))
@@ -1924,9 +1869,9 @@ func ascompatte(op int, call *Node, isddd int, nl **Type, lr *NodeList, fp int,
// conversions involved.
// copy into temporaries.
- alist = nil
+ alist := (*NodeList)(nil)
- for l = Structfirst(&savel, &r.Type); l != nil; l = structnext(&savel) {
+ for l := Structfirst(&savel, &r.Type); l != nil; l = structnext(&savel) {
a = temp(l.Type)
alist = list(alist, a)
}
@@ -2007,26 +1952,21 @@ ret:
func walkprint(nn *Node, init **NodeList) *Node {
var r *Node
var n *Node
- var l *NodeList
- var all *NodeList
var on *Node
var t *Type
- var notfirst bool
var et int
- var op int
- var calls *NodeList
- op = int(nn.Op)
- all = nn.List
- calls = nil
- notfirst = false
+ op := int(nn.Op)
+ all := nn.List
+ calls := (*NodeList)(nil)
+ notfirst := false
// Hoist all the argument evaluation up before the lock.
walkexprlistcheap(all, init)
calls = list(calls, mkcall("printlock", nil, init))
- for l = all; l != nil; l = l.Next {
+ for l := all; l != nil; l = l.Next {
if notfirst {
calls = list(calls, mkcall("printsp", nil, init))
}
@@ -2129,23 +2069,19 @@ func walkprint(nn *Node, init **NodeList) *Node {
}
func callnew(t *Type) *Node {
- var fn *Node
-
dowidth(t)
- fn = syslook("newobject", 1)
+ fn := syslook("newobject", 1)
argtype(fn, t)
return mkcall1(fn, Ptrto(t), nil, typename(t))
}
func isstack(n *Node) bool {
- var defn *Node
-
n = outervalue(n)
// If n is *autotmp and autotmp = &foo, replace n with foo.
// We introduce such temps when initializing struct literals.
if n.Op == OIND && n.Left.Op == ONAME && strings.HasPrefix(n.Left.Sym.Name, "autotmp_") {
- defn = n.Left.Defn
+ defn := n.Left.Defn
if defn != nil && defn.Op == OAS && defn.Right.Op == OADDR {
n = defn.Right.Left
}
@@ -2263,18 +2199,12 @@ func needwritebarrier(l *Node, r *Node) bool {
var applywritebarrier_bv *Bvec
func applywritebarrier(n *Node, init **NodeList) *Node {
- var l *Node
- var r *Node
- var t *Type
- var x int64
- var name string
-
if n.Left != nil && n.Right != nil && needwritebarrier(n.Left, n.Right) {
if Curfn != nil && Curfn.Nowritebarrier {
Yyerror("write barrier prohibited")
}
- t = n.Left.Type
- l = Nod(OADDR, n.Left, nil)
+ t := n.Left.Type
+ l := Nod(OADDR, n.Left, nil)
l.Etype = 1 // addr does not escape
if t.Width == int64(Widthptr) {
n = mkcall1(writebarrierfn("writebarrierptr", t, n.Right.Type), nil, init, l, n.Right)
@@ -2285,7 +2215,7 @@ func applywritebarrier(n *Node, init **NodeList) *Node {
} else if Isinter(t) {
n = mkcall1(writebarrierfn("writebarrieriface", t, n.Right.Type), nil, init, l, n.Right)
} else if t.Width <= int64(4*Widthptr) {
- x = 0
+ x := int64(0)
if applywritebarrier_bv == nil {
applywritebarrier_bv = bvalloc(obj.BitsPerPointer * 4)
}
@@ -2298,6 +2228,7 @@ func applywritebarrier(n *Node, init **NodeList) *Node {
if obj.BitsPointer != 1<<PtrBit {
Fatal("wrong PtrBit")
}
+ var name string
switch t.Width / int64(Widthptr) {
default:
Fatal("found writebarrierfat for %d-byte object of type %v", int(t.Width), Tconv(t, 0))
@@ -2314,7 +2245,7 @@ func applywritebarrier(n *Node, init **NodeList) *Node {
n = mkcall1(writebarrierfn(name, t, n.Right.Type), nil, init, l, nodnil(), n.Right)
} else {
- r = n.Right
+ r := n.Right
for r.Op == OCONVNOP {
r = r.Left
}
@@ -2330,18 +2261,14 @@ func applywritebarrier(n *Node, init **NodeList) *Node {
}
func convas(n *Node, init **NodeList) *Node {
- var lt *Type
- var rt *Type
- var map_ *Node
- var key *Node
- var val *Node
-
if n.Op != OAS {
Fatal("convas: not OAS %v", Oconv(int(n.Op), 0))
}
n.Typecheck = 1
+ var lt *Type
+ var rt *Type
if n.Left == nil || n.Right == nil {
goto out
}
@@ -2358,9 +2285,9 @@ func convas(n *Node, init **NodeList) *Node {
}
if n.Left.Op == OINDEXMAP {
- map_ = n.Left.Left
- key = n.Left.Right
- val = n.Right
+ map_ := n.Left.Left
+ key := n.Left.Right
+ val := n.Right
walkexpr(&map_, init)
walkexpr(&key, init)
walkexpr(&val, init)
@@ -2392,20 +2319,12 @@ out:
* make temp variables
*/
func reorder1(all *NodeList) *NodeList {
- var f *Node
- var a *Node
var n *Node
- var l *NodeList
- var r *NodeList
- var g *NodeList
- var c int
- var d int
- var t int
- c = 0 // function calls
- t = 0 // total parameters
+ c := 0 // function calls
+ t := 0 // total parameters
- for l = all; l != nil; l = l.Next {
+ for l := all; l != nil; l = l.Next {
n = l.N
t++
ullmancalc(n)
@@ -2418,11 +2337,12 @@ func reorder1(all *NodeList) *NodeList {
return all
}
- g = nil // fncalls assigned to tempnames
- f = nil // last fncall assigned to stack
- r = nil // non fncalls and tempnames assigned to stack
- d = 0
- for l = all; l != nil; l = l.Next {
+ g := (*NodeList)(nil) // fncalls assigned to tempnames
+ f := (*Node)(nil) // last fncall assigned to stack
+ r := (*NodeList)(nil) // non fncalls and tempnames assigned to stack
+ d := 0
+ var a *Node
+ for l := all; l != nil; l = l.Next {
n = l.N
if n.Ullman < UINF {
r = list(r, n)
@@ -2463,18 +2383,15 @@ func reorder1(all *NodeList) *NodeList {
* function calls have been removed.
*/
func reorder3(all *NodeList) *NodeList {
- var list *NodeList
- var early *NodeList
- var mapinit *NodeList
var l *Node
// If a needed expression may be affected by an
// earlier assignment, make an early copy of that
// expression and use the copy instead.
- early = nil
+ early := (*NodeList)(nil)
- mapinit = nil
- for list = all; list != nil; list = list.Next {
+ mapinit := (*NodeList)(nil)
+ for list := all; list != nil; list = list.Next {
l = list.N.Left
// Save subexpressions needed on left side.
@@ -2529,15 +2446,12 @@ func reorder3(all *NodeList) *NodeList {
* replace *np with that temp.
*/
func reorder3save(np **Node, all *NodeList, stop *NodeList, early **NodeList) {
- var n *Node
- var q *Node
-
- n = *np
+ n := *np
if !aliased(n, all, stop) {
return
}
- q = temp(n.Type)
+ q := temp(n.Type)
q = Nod(OAS, q, n)
typecheck(&q, Etop)
*early = list(*early, q)
@@ -2574,11 +2488,6 @@ func outervalue(n *Node) *Node {
* affected by writes in as up to but not including stop?
*/
func aliased(n *Node, all *NodeList, stop *NodeList) bool {
- var memwrite int
- var varwrite int
- var a *Node
- var l *NodeList
-
if n == nil {
return false
}
@@ -2588,10 +2497,11 @@ func aliased(n *Node, all *NodeList, stop *NodeList) bool {
// Also record whether there are any writes to main memory.
// Also record whether there are any writes to variables
// whose addresses have been taken.
- memwrite = 0
+ memwrite := 0
- varwrite = 0
- for l = all; l != stop; l = l.Next {
+ varwrite := 0
+ var a *Node
+ for l := all; l != stop; l = l.Next {
a = outervalue(l.N.Left)
if a.Op != ONAME {
memwrite = 1
@@ -2698,8 +2608,6 @@ func varexpr(n *Node) bool {
* is the name l mentioned in r?
*/
func vmatch2(l *Node, r *Node) bool {
- var ll *NodeList
-
if r == nil {
return false
}
@@ -2718,7 +2626,7 @@ func vmatch2(l *Node, r *Node) bool {
if vmatch2(l, r.Right) {
return true
}
- for ll = r.List; ll != nil; ll = ll.Next {
+ for ll := r.List; ll != nil; ll = ll.Next {
if vmatch2(l, ll.N) {
return true
}
@@ -2731,8 +2639,6 @@ func vmatch2(l *Node, r *Node) bool {
* called by sinit.c
*/
func vmatch1(l *Node, r *Node) bool {
- var ll *NodeList
-
/*
* isolate all left sides
*/
@@ -2767,7 +2673,7 @@ func vmatch1(l *Node, r *Node) bool {
if vmatch1(l.Right, r) {
return true
}
- for ll = l.List; ll != nil; ll = ll.Next {
+ for ll := l.List; ll != nil; ll = ll.Next {
if vmatch1(ll.N, r) {
return true
}
@@ -2781,14 +2687,12 @@ func vmatch1(l *Node, r *Node) bool {
* copies of escaped parameters to the heap.
*/
func paramstoheap(argin **Type, out int) *NodeList {
- var t *Type
var savet Iter
var v *Node
var as *Node
- var nn *NodeList
- nn = nil
- for t = Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
+ nn := (*NodeList)(nil)
+ for t := Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
v = t.Nname
if v != nil && v.Sym != nil && v.Sym.Name[0] == '~' && v.Sym.Name[1] == 'r' { // unnamed result
v = nil
@@ -2831,13 +2735,11 @@ func paramstoheap(argin **Type, out int) *NodeList {
* walk through argout parameters copying back to stack
*/
func returnsfromheap(argin **Type) *NodeList {
- var t *Type
var savet Iter
var v *Node
- var nn *NodeList
- nn = nil
- for t = Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
+ nn := (*NodeList)(nil)
+ for t := Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
v = t.Nname
if v == nil || v.Class != PHEAP|PPARAMOUT {
continue
@@ -2854,12 +2756,9 @@ func returnsfromheap(argin **Type) *NodeList {
* curfn's before and after lists.
*/
func heapmoves() {
- var nn *NodeList
- var lno int32
-
- lno = lineno
+ lno := lineno
lineno = Curfn.Lineno
- nn = paramstoheap(getthis(Curfn.Type), 0)
+ nn := paramstoheap(getthis(Curfn.Type), 0)
nn = concat(nn, paramstoheap(getinarg(Curfn.Type), 0))
nn = concat(nn, paramstoheap(Getoutarg(Curfn.Type), 1))
Curfn.Enter = concat(Curfn.Enter, nn)
@@ -2869,22 +2768,17 @@ func heapmoves() {
}
func vmkcall(fn *Node, t *Type, init **NodeList, va []*Node) *Node {
- var i int
- var n int
- var r *Node
- var args *NodeList
-
if fn.Type == nil || fn.Type.Etype != TFUNC {
Fatal("mkcall %v %v", Nconv(fn, 0), Tconv(fn.Type, 0))
}
- args = nil
- n = fn.Type.Intuple
- for i = 0; i < n; i++ {
+ args := (*NodeList)(nil)
+ n := fn.Type.Intuple
+ for i := 0; i < n; i++ {
args = list(args, va[i])
}
- r = Nod(OCALL, fn, nil)
+ r := Nod(OCALL, fn, nil)
r.List = args
if fn.Type.Outtuple > 0 {
typecheck(&r, Erv|Efnstruct)
@@ -2915,26 +2809,21 @@ func conv(n *Node, t *Type) *Node {
}
func chanfn(name string, n int, t *Type) *Node {
- var fn *Node
- var i int
-
if t.Etype != TCHAN {
Fatal("chanfn %v", Tconv(t, 0))
}
- fn = syslook(name, 1)
- for i = 0; i < n; i++ {
+ fn := syslook(name, 1)
+ for i := 0; i < n; i++ {
argtype(fn, t.Type)
}
return fn
}
func mapfn(name string, t *Type) *Node {
- var fn *Node
-
if t.Etype != TMAP {
Fatal("mapfn %v", Tconv(t, 0))
}
- fn = syslook(name, 1)
+ fn := syslook(name, 1)
argtype(fn, t.Down)
argtype(fn, t.Type)
argtype(fn, t.Down)
@@ -2943,12 +2832,10 @@ func mapfn(name string, t *Type) *Node {
}
func mapfndel(name string, t *Type) *Node {
- var fn *Node
-
if t.Etype != TMAP {
Fatal("mapfn %v", Tconv(t, 0))
}
- fn = syslook(name, 1)
+ fn := syslook(name, 1)
argtype(fn, t.Down)
argtype(fn, t.Type)
argtype(fn, t.Down)
@@ -2956,36 +2843,24 @@ func mapfndel(name string, t *Type) *Node {
}
func writebarrierfn(name string, l *Type, r *Type) *Node {
- var fn *Node
-
- fn = syslook(name, 1)
+ fn := syslook(name, 1)
argtype(fn, l)
argtype(fn, r)
return fn
}
func addstr(n *Node, init **NodeList) *Node {
- var r *Node
- var cat *Node
- var slice *Node
- var buf *Node
- var args *NodeList
- var l *NodeList
- var c int
- var sz int64
- var t *Type
-
// orderexpr rewrote OADDSTR to have a list of strings.
- c = count(n.List)
+ c := count(n.List)
if c < 2 {
Yyerror("addstr count %d too small", c)
}
- buf = nodnil()
+ buf := nodnil()
if n.Esc == EscNone {
- sz = 0
- for l = n.List; l != nil; l = l.Next {
+ sz := int64(0)
+ for l := n.List; l != nil; l = l.Next {
if n.Op == OLITERAL {
sz += int64(len(n.Val.U.Sval.S))
}
@@ -2994,16 +2869,16 @@ func addstr(n *Node, init **NodeList) *Node {
// Don't allocate the buffer if the result won't fit.
if sz < tmpstringbufsize {
// Create temporary buffer for result string on stack.
- t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+ t := aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
buf = Nod(OADDR, temp(t), nil)
}
}
// build list of string arguments
- args = list1(buf)
+ args := list1(buf)
- for l = n.List; l != nil; l = l.Next {
+ for l := n.List; l != nil; l = l.Next {
args = list(args, conv(l.N, Types[TSTRING]))
}
@@ -3015,10 +2890,10 @@ func addstr(n *Node, init **NodeList) *Node {
// large numbers of strings are passed to the runtime as a slice.
namebuf = "concatstrings"
- t = typ(TARRAY)
+ t := typ(TARRAY)
t.Type = Types[TSTRING]
t.Bound = -1
- slice = Nod(OCOMPLIT, nil, typenod(t))
+ slice := Nod(OCOMPLIT, nil, typenod(t))
slice.Alloc = n.Alloc
slice.List = args.Next // skip buf arg
args = list1(buf)
@@ -3026,8 +2901,8 @@ func addstr(n *Node, init **NodeList) *Node {
slice.Esc = EscNone
}
- cat = syslook(namebuf, 1)
- r = Nod(OCALL, cat, nil)
+ cat := syslook(namebuf, 1)
+ r := Nod(OCALL, cat, nil)
r.List = args
typecheck(&r, Erv)
walkexpr(&r, init)
@@ -3049,36 +2924,25 @@ func addstr(n *Node, init **NodeList) *Node {
//
// l2 is allowed to be a string.
func appendslice(n *Node, init **NodeList) *Node {
- var l *NodeList
- var l1 *Node
- var l2 *Node
- var nt *Node
- var nif *Node
- var fn *Node
- var nptr1 *Node
- var nptr2 *Node
- var nwid *Node
- var s *Node
-
walkexprlistsafe(n.List, 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.
- for l = n.List; l != nil; l = l.Next {
+ for l := n.List; l != nil; l = l.Next {
l.N = cheapexpr(l.N, init)
}
- l1 = n.List.N
- l2 = n.List.Next.N
+ l1 := n.List.N
+ l2 := n.List.Next.N
- s = temp(l1.Type) // var s []T
- l = nil
+ s := temp(l1.Type) // var s []T
+ l := (*NodeList)(nil)
l = list(l, Nod(OAS, s, l1)) // s = l1
- nt = temp(Types[TINT])
+ nt := temp(Types[TINT])
- nif = Nod(OIF, nil, nil)
+ nif := Nod(OIF, nil, nil)
// n := len(s) + len(l2) - cap(s)
nif.Ninit = list1(Nod(OAS, nt, Nod(OSUB, Nod(OADD, Nod(OLEN, s, nil), Nod(OLEN, l2, nil)), Nod(OCAP, s, nil))))
@@ -3086,7 +2950,7 @@ func appendslice(n *Node, init **NodeList) *Node {
nif.Ntest = Nod(OGT, nt, Nodintconst(0))
// instantiate growslice(Type*, []any, int64) []any
- fn = syslook("growslice", 1)
+ fn := syslook("growslice", 1)
argtype(fn, s.Type.Type)
argtype(fn, s.Type.Type)
@@ -3098,22 +2962,23 @@ func appendslice(n *Node, init **NodeList) *Node {
if haspointers(l1.Type.Type) {
// copy(s[len(l1):len(l1)+len(l2)], l2)
- nptr1 = Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
+ nptr1 := Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
nptr1.Etype = 1
- nptr2 = l2
- fn = syslook("typedslicecopy", 1)
+ nptr2 := l2
+ fn := syslook("typedslicecopy", 1)
argtype(fn, l1.Type)
argtype(fn, l2.Type)
- nt = mkcall1(fn, Types[TINT], &l, typename(l1.Type.Type), nptr1, nptr2)
+ nt := mkcall1(fn, Types[TINT], &l, typename(l1.Type.Type), nptr1, nptr2)
l = list(l, nt)
} else if flag_race != 0 {
// rely on runtime to instrument copy.
// copy(s[len(l1):len(l1)+len(l2)], l2)
- nptr1 = Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
+ nptr1 := Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
nptr1.Etype = 1
- nptr2 = l2
+ nptr2 := l2
+ var fn *Node
if l2.Type.Etype == TSTRING {
fn = syslook("slicestringcopy", 1)
} else {
@@ -3121,25 +2986,25 @@ func appendslice(n *Node, init **NodeList) *Node {
}
argtype(fn, l1.Type)
argtype(fn, l2.Type)
- nt = mkcall1(fn, Types[TINT], &l, nptr1, nptr2, Nodintconst(s.Type.Type.Width))
+ nt := mkcall1(fn, Types[TINT], &l, nptr1, nptr2, Nodintconst(s.Type.Type.Width))
l = list(l, nt)
} else {
// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
- nptr1 = Nod(OINDEX, s, Nod(OLEN, l1, nil))
+ nptr1 := Nod(OINDEX, s, Nod(OLEN, l1, nil))
nptr1.Bounded = true
nptr1 = Nod(OADDR, nptr1, nil)
- nptr2 = Nod(OSPTR, l2, nil)
+ nptr2 := Nod(OSPTR, l2, nil)
- fn = syslook("memmove", 1)
+ fn := syslook("memmove", 1)
argtype(fn, s.Type.Type) // 1 old []any
argtype(fn, s.Type.Type) // 2 ret []any
- nwid = cheapexpr(conv(Nod(OLEN, l2, nil), Types[TUINTPTR]), &l)
+ nwid := cheapexpr(conv(Nod(OLEN, l2, nil), Types[TUINTPTR]), &l)
nwid = Nod(OMUL, nwid, Nodintconst(s.Type.Type.Width))
- nt = mkcall1(fn, nil, &l, nptr1, nptr2, nwid)
+ nt := mkcall1(fn, nil, &l, nptr1, nptr2, nwid)
l = list(l, nt)
}
@@ -3172,61 +3037,51 @@ func appendslice(n *Node, init **NodeList) *Node {
// }
// s
func walkappend(n *Node, init **NodeList) *Node {
- var l *NodeList
- var a *NodeList
- var nsrc *Node
- var ns *Node
- var nn *Node
- var na *Node
- var nx *Node
- var fn *Node
- var argc int
-
walkexprlistsafe(n.List, 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.
- for l = n.List; l != nil; l = l.Next {
+ for l := n.List; l != nil; l = l.Next {
l.N = cheapexpr(l.N, init)
}
- nsrc = n.List.N
+ nsrc := n.List.N
// Resolve slice type of multi-valued return.
if Istype(nsrc.Type, TSTRUCT) {
nsrc.Type = nsrc.Type.Type.Type
}
- argc = count(n.List) - 1
+ argc := count(n.List) - 1
if argc < 1 {
return nsrc
}
- l = nil
+ l := (*NodeList)(nil)
- ns = temp(nsrc.Type)
+ ns := temp(nsrc.Type)
l = list(l, Nod(OAS, ns, nsrc)) // s = src
- na = Nodintconst(int64(argc)) // const argc
- nx = Nod(OIF, nil, nil) // if cap(s) - len(s) < argc
+ na := Nodintconst(int64(argc)) // const argc
+ nx := Nod(OIF, nil, nil) // if cap(s) - len(s) < argc
nx.Ntest = Nod(OLT, Nod(OSUB, Nod(OCAP, ns, nil), Nod(OLEN, ns, nil)), na)
- fn = syslook("growslice", 1) // growslice(<type>, old []T, n int64) (ret []T)
- argtype(fn, ns.Type.Type) // 1 old []any
- argtype(fn, ns.Type.Type) // 2 ret []any
+ fn := syslook("growslice", 1) // growslice(<type>, old []T, n int64) (ret []T)
+ argtype(fn, ns.Type.Type) // 1 old []any
+ argtype(fn, ns.Type.Type) // 2 ret []any
nx.Nbody = list1(Nod(OAS, ns, mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type), ns, conv(na, Types[TINT64]))))
l = list(l, nx)
- nn = temp(Types[TINT])
+ nn := temp(Types[TINT])
l = list(l, Nod(OAS, nn, Nod(OLEN, ns, nil))) // n = len(s)
nx = Nod(OSLICE, ns, Nod(OKEY, nil, Nod(OADD, nn, na))) // ...s[:n+argc]
nx.Etype = 1
l = list(l, Nod(OAS, ns, nx)) // s = s[:n+argc]
- for a = n.List.Next; a != nil; a = a.Next {
+ for a := n.List.Next; a != nil; a = a.Next {
nx = Nod(OINDEX, ns, nn) // s[n] ...
nx.Bounded = true
l = list(l, Nod(OAS, nx, a.N)) // s[n] = arg
@@ -3253,22 +3108,13 @@ func walkappend(n *Node, init **NodeList) *Node {
// Also works if b is a string.
//
func copyany(n *Node, init **NodeList, runtimecall int) *Node {
- var nl *Node
- var nr *Node
- var nfrm *Node
- var nto *Node
- var nif *Node
- var nlen *Node
- var nwid *Node
- var fn *Node
- var l *NodeList
-
if haspointers(n.Left.Type.Type) {
- fn = writebarrierfn("typedslicecopy", n.Left.Type, n.Right.Type)
+ fn := writebarrierfn("typedslicecopy", n.Left.Type, n.Right.Type)
return mkcall1(fn, n.Type, init, typename(n.Left.Type.Type), n.Left, n.Right)
}
if runtimecall != 0 {
+ var fn *Node
if n.Right.Type.Etype == TSTRING {
fn = syslook("slicestringcopy", 1)
} else {
@@ -3281,33 +3127,33 @@ func copyany(n *Node, init **NodeList, runtimecall int) *Node {
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
- nl = temp(n.Left.Type)
- nr = temp(n.Right.Type)
- l = nil
+ nl := temp(n.Left.Type)
+ nr := temp(n.Right.Type)
+ l := (*NodeList)(nil)
l = list(l, Nod(OAS, nl, n.Left))
l = list(l, Nod(OAS, nr, n.Right))
- nfrm = Nod(OSPTR, nr, nil)
- nto = Nod(OSPTR, nl, nil)
+ nfrm := Nod(OSPTR, nr, nil)
+ nto := Nod(OSPTR, nl, nil)
- nlen = temp(Types[TINT])
+ nlen := temp(Types[TINT])
// n = len(to)
l = list(l, Nod(OAS, nlen, Nod(OLEN, nl, nil)))
// if n > len(frm) { n = len(frm) }
- nif = Nod(OIF, nil, nil)
+ nif := Nod(OIF, nil, nil)
nif.Ntest = Nod(OGT, nlen, Nod(OLEN, nr, nil))
nif.Nbody = list(nif.Nbody, Nod(OAS, nlen, Nod(OLEN, nr, nil)))
l = list(l, nif)
// Call memmove.
- fn = syslook("memmove", 1)
+ fn := syslook("memmove", 1)
argtype(fn, nl.Type.Type)
argtype(fn, nl.Type.Type)
- nwid = temp(Types[TUINTPTR])
+ nwid := temp(Types[TUINTPTR])
l = list(l, Nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
nwid = Nod(OMUL, nwid, Nodintconst(nl.Type.Type.Width))
l = list(l, mkcall1(fn, nil, init, nto, nfrm, nwid))
@@ -3321,30 +3167,15 @@ func copyany(n *Node, init **NodeList, runtimecall int) *Node {
// Generate frontend part for OSLICE[3][ARR|STR]
//
func sliceany(n *Node, init **NodeList) *Node {
- var bounded int
- var slice3 bool
- var src *Node
- var lb *Node
var hb *Node
var cb *Node
- var bound *Node
- var chk *Node
- var chk0 *Node
- var chk1 *Node
- var chk2 *Node
- var lbv int64
- var hbv int64
- var cbv int64
- var bv int64
- var w int64
- var bt *Type
// print("before sliceany: %+N\n", n);
- src = n.Left
+ src := n.Left
- lb = n.Right.Left
- slice3 = n.Op == OSLICE3 || n.Op == OSLICE3ARR
+ lb := n.Right.Left
+ slice3 := n.Op == OSLICE3 || n.Op == OSLICE3ARR
if slice3 {
hb = n.Right.Right.Left
cb = n.Right.Right.Right
@@ -3353,8 +3184,9 @@ func sliceany(n *Node, init **NodeList) *Node {
cb = nil
}
- bounded = int(n.Etype)
+ bounded := int(n.Etype)
+ var bound *Node
if n.Op == OSLICESTR {
bound = Nod(OLEN, src, nil)
} else {
@@ -3365,7 +3197,7 @@ func sliceany(n *Node, init **NodeList) *Node {
walkexpr(&bound, init) // if src is an array, bound will be a const now.
// static checks if possible
- bv = 1 << 50
+ bv := int64(1 << 50)
if Isconst(bound, CTINT) {
if !Smallintconst(bound) {
@@ -3376,21 +3208,21 @@ func sliceany(n *Node, init **NodeList) *Node {
}
if Isconst(cb, CTINT) {
- cbv = Mpgetfix(cb.Val.U.Xval)
+ cbv := Mpgetfix(cb.Val.U.Xval)
if cbv < 0 || cbv > bv {
Yyerror("slice index out of bounds")
}
}
if Isconst(hb, CTINT) {
- hbv = Mpgetfix(hb.Val.U.Xval)
+ hbv := Mpgetfix(hb.Val.U.Xval)
if hbv < 0 || hbv > bv {
Yyerror("slice index out of bounds")
}
}
if Isconst(lb, CTINT) {
- lbv = Mpgetfix(lb.Val.U.Xval)
+ lbv := Mpgetfix(lb.Val.U.Xval)
if lbv < 0 || lbv > bv {
Yyerror("slice index out of bounds")
lbv = -1
@@ -3403,14 +3235,12 @@ func sliceany(n *Node, init **NodeList) *Node {
// Checking src[lb:hb:cb] or src[lb:hb].
// if chk0 || chk1 || chk2 { panicslice() }
- chk = nil
-
- chk0 = nil // cap(src) < cb
- chk1 = nil // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
- chk2 = nil // hb < lb
+ chk0 := (*Node)(nil) // cap(src) < cb
+ chk1 := (*Node)(nil) // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
+ chk2 := (*Node)(nil) // hb < lb
// All comparisons are unsigned to avoid testing < 0.
- bt = Types[Simtype[TUINT]]
+ bt := Types[Simtype[TUINT]]
if cb != nil && cb.Type.Width > 4 {
bt = Types[TUINT64]
@@ -3463,7 +3293,7 @@ func sliceany(n *Node, init **NodeList) *Node {
}
if chk0 != nil || chk1 != nil || chk2 != nil {
- chk = Nod(OIF, nil, nil)
+ chk := Nod(OIF, nil, nil)
chk.Nbody = list1(mkcall("panicslice", nil, init))
chk.Likely = -1
if chk0 != nil {
@@ -3521,6 +3351,7 @@ func sliceany(n *Node, init **NodeList) *Node {
// offs = [width *] lo, but omit if zero
if lb != nil {
+ var w int64
if n.Op == OSLICESTR {
w = 1
} else {
@@ -3541,33 +3372,28 @@ func sliceany(n *Node, init **NodeList) *Node {
}
func eqfor(t *Type, needsize *int) *Node {
- var a int
- var n *Node
- var ntype *Node
- var sym *Sym
-
// 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 during type check (OCMPSTR etc).
- a = algtype1(t, nil)
+ a := algtype1(t, nil)
if a != AMEM && a != -1 {
Fatal("eqfor %v", Tconv(t, 0))
}
if a == AMEM {
- n = syslook("memequal", 1)
+ n := syslook("memequal", 1)
argtype(n, t)
argtype(n, t)
*needsize = 1
return n
}
- sym = typesymprefix(".eq", t)
- n = newname(sym)
+ sym := typesymprefix(".eq", t)
+ n := newname(sym)
n.Class = PFUNC
- ntype = Nod(OTFUNC, nil, nil)
+ ntype := Nod(OTFUNC, nil, nil)
ntype.List = list(ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.List = list(ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.Rlist = list(ntype.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
@@ -3578,36 +3404,15 @@ func eqfor(t *Type, needsize *int) *Node {
}
func countfield(t *Type) int {
- var t1 *Type
- var n int
-
- n = 0
- for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ n := 0
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
n++
}
return n
}
func walkcompare(np **Node, init **NodeList) {
- var n *Node
- var l *Node
- var r *Node
- var call *Node
- var a *Node
- var li *Node
- var ri *Node
- var expr *Node
- var cmpl *Node
- var cmpr *Node
- var x *Node
- var ok *Node
- var andor int
- var i int
- var needsize int
- var t *Type
- var t1 *Type
-
- n = *np
+ n := *np
// Given interface value l and concrete value r, rewrite
// l == r
@@ -3616,9 +3421,9 @@ func walkcompare(np **Node, init **NodeList) {
// Handle != similarly.
// This avoids the allocation that would be required
// to convert r to l for comparison.
- l = nil
+ l := (*Node)(nil)
- r = nil
+ r := (*Node)(nil)
if Isinter(n.Left.Type) && !Isinter(n.Right.Type) {
l = n.Left
r = n.Right
@@ -3627,17 +3432,25 @@ func walkcompare(np **Node, init **NodeList) {
r = n.Left
}
+ var call *Node
+ var a *Node
+ var cmpl *Node
+ var cmpr *Node
+ var andor int
+ var expr *Node
+ var needsize int
+ var t *Type
if l != nil {
- x = temp(r.Type)
- ok = temp(Types[TBOOL])
+ x := temp(r.Type)
+ ok := temp(Types[TBOOL])
// l.(type(r))
- a = Nod(ODOTTYPE, l, nil)
+ a := Nod(ODOTTYPE, l, nil)
a.Type = r.Type
// x, ok := l.(type(r))
- expr = Nod(OAS2, nil, nil)
+ expr := Nod(OAS2, nil, nil)
expr.List = list1(x)
expr.List = list(expr.List, ok)
@@ -3705,7 +3518,9 @@ func walkcompare(np **Node, init **NodeList) {
if t.Etype == TARRAY && t.Bound <= 4 && issimple[t.Type.Etype] != 0 {
// Four or fewer elements of a basic type.
// Unroll comparisons.
- for i = 0; int64(i) < t.Bound; i++ {
+ var li *Node
+ var ri *Node
+ for i := 0; int64(i) < t.Bound; i++ {
li = Nod(OINDEX, l, Nodintconst(int64(i)))
ri = Nod(OINDEX, r, Nodintconst(int64(i)))
a = Nod(int(n.Op), li, ri)
@@ -3726,7 +3541,9 @@ func walkcompare(np **Node, init **NodeList) {
if t.Etype == TSTRUCT && countfield(t) <= 4 {
// Struct of four or fewer fields.
// Inline comparisons.
- for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ var li *Node
+ var ri *Node
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
if isblanksym(t1.Sym) {
continue
}
@@ -3809,24 +3626,16 @@ func samecheap(a *Node, b *Node) bool {
}
func walkrotate(np **Node) {
- var w int
- var sl int
- var sr int
- var s int
- var l *Node
- var r *Node
- var n *Node
-
if Thearch.Thechar == '9' {
return
}
- n = *np
+ n := *np
// Want << | >> or >> | << or << ^ >> or >> ^ << on unsigned value.
- l = n.Left
+ l := n.Left
- r = n.Right
+ 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] != 0 || l.Op == r.Op {
return
}
@@ -3837,12 +3646,12 @@ func walkrotate(np **Node) {
}
// Constants adding to width?
- w = int(l.Type.Width * 8)
+ w := int(l.Type.Width * 8)
if Smallintconst(l.Right) && Smallintconst(r.Right) {
- sl = int(Mpgetfix(l.Right.Val.U.Xval))
+ sl := int(Mpgetfix(l.Right.Val.U.Xval))
if sl >= 0 {
- sr = int(Mpgetfix(r.Right.Val.U.Xval))
+ sr := int(Mpgetfix(r.Right.Val.U.Xval))
if sr >= 0 && sl+sr == w {
goto yes
}
@@ -3863,7 +3672,7 @@ yes:
n.Op = OLROT
// Remove rotate 0 and rotate w.
- s = int(Mpgetfix(n.Right.Val.U.Xval))
+ s := int(Mpgetfix(n.Right.Val.U.Xval))
if s == 0 || s == w {
n = n.Left
@@ -3877,18 +3686,13 @@ yes:
* walkmul rewrites integer multiplication by powers of two as shifts.
*/
func walkmul(np **Node, init **NodeList) {
- var n *Node
- var nl *Node
- var nr *Node
- var pow int
- var neg int
- var w int
-
- n = *np
+ n := *np
if Isint[n.Type.Etype] == 0 {
return
}
+ var nr *Node
+ var nl *Node
if n.Right.Op == OLITERAL {
nl = n.Left
nr = n.Right
@@ -3899,9 +3703,11 @@ func walkmul(np **Node, init **NodeList) {
return
}
- neg = 0
+ neg := 0
// x*0 is 0 (and side effects of x).
+ var pow int
+ var w int
if Mpgetfix(nr.Val.U.Xval) == 0 {
cheapexpr(nl, init)
Nodconst(n, n.Type, 0)
@@ -3952,42 +3758,29 @@ ret:
* operations.
*/
func walkdiv(np **Node, init **NodeList) {
- var n *Node
- var nl *Node
- var nr *Node
// if >= 0, nr is 1<<pow // 1 if nr is negative.
- var nc *Node
- var n1 *Node
- var n2 *Node
- var n3 *Node
- var n4 *Node
- var pow int
- var s int
- var w int
- var twide *Type
- var m Magic
// TODO(minux)
if Thearch.Thechar == '9' {
return
}
- n = *np
+ n := *np
if n.Right.Op != OLITERAL {
return
}
// nr is a constant.
- nl = cheapexpr(n.Left, init)
+ nl := cheapexpr(n.Left, init)
- nr = n.Right
+ nr := n.Right
// special cases of mod/div
// by a constant
- w = int(nl.Type.Width * 8)
+ w := int(nl.Type.Width * 8)
- s = 0
- pow = powtwo(nr)
+ s := 0
+ pow := powtwo(nr)
if pow >= 1000 {
// negative power of 2
s = 1
@@ -4000,6 +3793,9 @@ func walkdiv(np **Node, init **NodeList) {
return
}
+ var n1 *Node
+ var m Magic
+ var n2 *Node
if pow < 0 {
goto divbymul
}
@@ -4025,32 +3821,32 @@ func walkdiv(np **Node, init **NodeList) {
// signed modulo 2^pow is like ANDing
// with the last pow bits, but if nl < 0,
// nl & (2^pow-1) is (nl+1)%2^pow - 1.
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
- n1 = Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
+ n1 := Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
if pow == 1 {
typecheck(&n1, Erv)
n1 = cheapexpr(n1, init)
// n = (nl+ε)&1 -ε where ε=1 iff nl<0.
- n2 = Nod(OSUB, nl, n1)
+ n2 := Nod(OSUB, nl, n1)
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, nl.Type, 1)
- n3 = Nod(OAND, n2, nc)
+ n3 := Nod(OAND, n2, nc)
n = Nod(OADD, n3, n1)
} else {
// n = (nl+ε)&(nr-1) - ε where ε=2^pow-1 iff nl<0.
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, nl.Type, (1<<uint(pow))-1)
- n2 = Nod(OAND, n1, nc) // n2 = 2^pow-1 iff nl<0.
+ n2 := Nod(OAND, n1, nc) // n2 = 2^pow-1 iff nl<0.
typecheck(&n2, Erv)
n2 = cheapexpr(n2, init)
- n3 = Nod(OADD, nl, n2)
- n4 = Nod(OAND, n3, nc)
+ n3 := Nod(OADD, nl, n2)
+ n4 := Nod(OAND, n3, nc)
n = Nod(OSUB, n4, n2)
}
@@ -4059,19 +3855,19 @@ func walkdiv(np **Node, init **NodeList) {
// arithmetic right shift does not give the correct rounding.
// if nl >= 0, nl >> n == nl / nr
// if nl < 0, we want to add 2^n-1 first.
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
- n1 = Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
+ n1 := Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
if pow == 1 {
// nl+1 is nl-(-1)
n.Left = Nod(OSUB, nl, n1)
} else {
// Do a logical right right on -1 to keep pow bits.
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, Types[Simtype[TUINT]], int64(w)-int64(pow))
- n2 = Nod(ORSH, conv(n1, tounsigned(nl.Type)), nc)
+ n2 := Nod(ORSH, conv(n1, tounsigned(nl.Type)), nc)
n.Left = Nod(OADD, nl, conv(n2, nl.Type))
}
@@ -4090,7 +3886,7 @@ func walkdiv(np **Node, init **NodeList) {
break
}
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
if n.Op == OMOD {
// n = nl & (nr-1)
n.Op = OAND
@@ -4141,14 +3937,15 @@ divbymul:
case TUINT8,
TUINT16,
TUINT32:
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, nl.Type, int64(m.Um))
- n1 = Nod(OMUL, nl, nc)
+ n1 := Nod(OMUL, nl, nc)
typecheck(&n1, Erv)
n1.Op = OHMUL
if m.Ua != 0 {
// Select a Go type with (at least) twice the width.
+ var twide *Type
switch Simtype[nl.Type.Etype] {
default:
return
@@ -4170,16 +3967,16 @@ divbymul:
// add numerator (might overflow).
// n2 = (n1 + nl)
- n2 = Nod(OADD, conv(n1, twide), conv(nl, twide))
+ n2 := Nod(OADD, conv(n1, twide), conv(nl, twide))
// shift by m.s
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, Types[TUINT], int64(m.S))
n = conv(Nod(ORSH, n2, nc), nl.Type)
} else {
// n = n1 >> m.s
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, Types[TUINT], int64(m.S))
n = Nod(ORSH, n1, nc)
@@ -4189,10 +3986,10 @@ divbymul:
case TINT8,
TINT16,
TINT32:
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
Nodconst(nc, nl.Type, m.Sm)
- n1 = Nod(OMUL, nl, nc)
+ n1 := Nod(OMUL, nl, nc)
typecheck(&n1, Erv)
n1.Op = OHMUL
if m.Sm < 0 {
@@ -4204,13 +4001,13 @@ divbymul:
nc = Nod(OXXX, nil, nil)
Nodconst(nc, Types[TUINT], int64(m.S))
- n2 = conv(Nod(ORSH, n1, nc), nl.Type)
+ n2 := conv(Nod(ORSH, n1, nc), nl.Type)
// add 1 iff n1 is negative.
nc = Nod(OXXX, nil, nil)
Nodconst(nc, Types[TUINT], int64(w)-1)
- n3 = Nod(ORSH, nl, nc) // n4 = -1 iff n1 is negative.
+ n3 := Nod(ORSH, nl, nc) // n4 = -1 iff n1 is negative.
n = Nod(OSUB, n2, n3)
// apply sign.
@@ -4237,25 +4034,21 @@ ret:
// return 1 if integer n must be in range [0, max), 0 otherwise
func bounded(n *Node, max int64) bool {
- var v int64
- var bits int32
- var sign int
-
if n.Type == nil || Isint[n.Type.Etype] == 0 {
return false
}
- sign = int(Issigned[n.Type.Etype])
- bits = int32(8 * n.Type.Width)
+ sign := int(Issigned[n.Type.Etype])
+ bits := int32(8 * n.Type.Width)
if Smallintconst(n) {
- v = Mpgetfix(n.Val.U.Xval)
+ v := Mpgetfix(n.Val.U.Xval)
return 0 <= v && v < max
}
switch n.Op {
case OAND:
- v = -1
+ v := int64(-1)
if Smallintconst(n.Left) {
v = Mpgetfix(n.Left.Val.U.Xval)
} else if Smallintconst(n.Right) {
@@ -4268,7 +4061,7 @@ func bounded(n *Node, max int64) bool {
case OMOD:
if sign == 0 && Smallintconst(n.Right) {
- v = Mpgetfix(n.Right.Val.U.Xval)
+ v := Mpgetfix(n.Right.Val.U.Xval)
if 0 <= v && v <= max {
return true
}
@@ -4276,7 +4069,7 @@ func bounded(n *Node, max int64) bool {
case ODIV:
if sign == 0 && Smallintconst(n.Right) {
- v = Mpgetfix(n.Right.Val.U.Xval)
+ v := Mpgetfix(n.Right.Val.U.Xval)
for bits > 0 && v >= 2 {
bits--
v >>= 1
@@ -4285,7 +4078,7 @@ func bounded(n *Node, max int64) bool {
case ORSH:
if sign == 0 && Smallintconst(n.Right) {
- v = Mpgetfix(n.Right.Val.U.Xval)
+ v := Mpgetfix(n.Right.Val.U.Xval)
if v > int64(bits) {
return true
}
@@ -4301,9 +4094,6 @@ func bounded(n *Node, max int64) bool {
}
func usefield(n *Node) {
- var field *Type
- var l *Type
-
if obj.Fieldtrack_enabled == 0 {
return
}
@@ -4317,7 +4107,7 @@ func usefield(n *Node) {
break
}
- field = n.Paramfld
+ field := n.Paramfld
if field == nil {
Fatal("usefield %v %v without paramfld", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, 0))
}
@@ -4341,7 +4131,7 @@ func usefield(n *Node) {
Yyerror("tracked field must be exported (upper case)")
}
- l = typ(0)
+ l := typ(0)
l.Type = field
l.Down = Curfn.Paramfld
Curfn.Paramfld = l
@@ -4462,17 +4252,7 @@ func candiscard(n *Node) bool {
var walkprintfunc_prgen int
func walkprintfunc(np **Node, init **NodeList) {
- var n *Node
- var a *Node
- var fn *Node
- var t *Node
- var oldfn *Node
- var l *NodeList
- var printargs *NodeList
- var num int
- var buf string
-
- n = *np
+ n := *np
if n.Ninit != nil {
walkstmtlist(n.Ninit)
@@ -4480,10 +4260,12 @@ func walkprintfunc(np **Node, init **NodeList) {
n.Ninit = nil
}
- t = Nod(OTFUNC, nil, nil)
- num = 0
- printargs = nil
- for l = n.List; l != nil; l = l.Next {
+ t := Nod(OTFUNC, nil, nil)
+ num := 0
+ printargs := (*NodeList)(nil)
+ var a *Node
+ var buf string
+ for l := n.List; l != nil; l = l.Next {
buf = fmt.Sprintf("a%d", num)
num++
a = Nod(ODCLFIELD, newname(Lookup(buf)), typenod(l.N.Type))
@@ -4491,7 +4273,7 @@ func walkprintfunc(np **Node, init **NodeList) {
printargs = list(printargs, a.Left)
}
- fn = Nod(ODCLFUNC, nil, nil)
+ fn := Nod(ODCLFUNC, nil, nil)
walkprintfunc_prgen++
buf = fmt.Sprintf("print·%d", walkprintfunc_prgen)
fn.Nname = newname(Lookup(buf))
@@ -4499,7 +4281,7 @@ func walkprintfunc(np **Node, init **NodeList) {
fn.Nname.Ntype = t
declare(fn.Nname, PFUNC)
- oldfn = Curfn
+ oldfn := Curfn
Curfn = nil
funchdr(fn)
7apu2bq3rhoylwmucxizk54afw5jyda7pho4j5zdcqpwkufke7zdzwad.onion