[dev.cc] cmd/5g etc: code cleanup: delay var decls and eliminate dead code Ran rsc.io/grind rev 6f0e601 on the source files. The cleanups move var declarations as close to the use as possible, splitting disjoint uses of the var into separate variables. They also remove dead code (especially in func sudoaddable), which helps with the var moving. There's more cleanup to come, but this alone cuts the time spent compiling html/template on my 2013 MacBook Pro from 3.1 seconds to 2.3 seconds. Change-Id: I4de499f47b1dd47a560c310bbcde6b08d425cfd6 Reviewed-on: https://go-review.googlesource.com/5637 Reviewed-by: Rob Pike <r@golang.org>
diff --git a/src/cmd/5g/cgen.go b/src/cmd/5g/cgen.go index bdee52a..638c5a6 100644 --- a/src/cmd/5g/cgen.go +++ b/src/cmd/5g/cgen.go
@@ -20,26 +20,18 @@ * simplifies and calls gmove. */ func cgen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var f0 gc.Node - var f1 gc.Node - var a int - var w int - var rg int - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var addr obj.Addr - if gc.Debug['g'] != 0 { gc.Dump("\ncgen-n", n) gc.Dump("cgen-res", res) } + var n1 gc.Node + var nr *gc.Node + var nl *gc.Node + var a int + var f1 gc.Node + var f0 gc.Node + var n2 gc.Node if n == nil || n.Type == nil { goto ret } @@ -55,6 +47,7 @@ gc.OSLICE3, gc.OSLICE3ARR: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) cgen(&n1, res) @@ -65,6 +58,7 @@ case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) cgen(&n1, res) @@ -83,6 +77,7 @@ gc.Fatal("cgen: this is going to misscompile") } if res.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) @@ -122,6 +117,7 @@ if gc.Is64(n.Type) || gc.Is64(res.Type) || n.Op == gc.OREGISTER || res.Op == gc.OREGISTER || gc.Iscomplex[n.Type.Etype] != 0 || gc.Iscomplex[res.Type.Etype] != 0 { gmove(n, res) } else { + var n1 gc.Node regalloc(&n1, n.Type, nil) gmove(n, &n1) cgen(&n1, res) @@ -135,6 +131,7 @@ if n.Addable == 0 && res.Addable == 0 { // could use regalloc here sometimes, // but have to check for ullman >= UINF. + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) @@ -145,6 +142,7 @@ // if result is not addressable directly but n is, // compute its address and then store via the address. if res.Addable == 0 { + var n1 gc.Node igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) @@ -158,11 +156,14 @@ // if n is sudoaddable generate addr and move if !gc.Is64(n.Type) && !gc.Is64(res.Type) && gc.Iscomplex[n.Type.Etype] == 0 && gc.Iscomplex[res.Type.Etype] == 0 { - a = optoas(gc.OAS, n.Type) + a := optoas(gc.OAS, n.Type) + var w int + var addr obj.Addr if sudoaddable(a, n, &addr, &w) { if res.Op != gc.OREGISTER { + var n2 gc.Node regalloc(&n2, res.Type, nil) - p1 = gins(a, nil, &n2) + p1 := gins(a, nil, &n2) p1.From = addr if gc.Debug['g'] != 0 { fmt.Printf("%v [ignore previous line]\n", p1) @@ -170,7 +171,7 @@ gmove(&n2, res) regfree(&n2) } else { - p1 = gins(a, nil, res) + p1 := gins(a, nil, res) p1.From = addr if gc.Debug['g'] != 0 { fmt.Printf("%v [ignore previous line]\n", p1) @@ -191,9 +192,10 @@ if nl != nil && nl.Ullman >= gc.UINF { if nr != nil && nr.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) - n2 = *n + n2 := *n n2.Left = &n1 cgen(&n2, res) goto ret @@ -244,11 +246,11 @@ gc.OGE, gc.OGT, gc.ONOT: - p1 = gc.Gbranch(arm.AB, nil, 0) + p1 := gc.Gbranch(arm.AB, nil, 0) - p2 = gc.Pc + p2 := gc.Pc gmove(gc.Nodbool(true), res) - p3 = gc.Gbranch(arm.AB, nil, 0) + p3 := gc.Gbranch(arm.AB, nil, 0) gc.Patch(p1, gc.Pc) bgen(n, true, 0, p2) gmove(gc.Nodbool(false), res) @@ -261,7 +263,7 @@ // unary case gc.OCOM: - a = optoas(gc.OXOR, nl.Type) + a := optoas(gc.OXOR, nl.Type) regalloc(&n1, nl.Type, nil) cgen(nl, &n1) @@ -306,6 +308,7 @@ break } + var n1 gc.Node if nl.Addable != 0 && !gc.Is64(nl.Type) { regalloc(&n1, nl.Type, res) gmove(nl, &n1) @@ -318,6 +321,7 @@ cgen(nl, &n1) } + var n2 gc.Node if n.Type.Width > int64(gc.Widthptr) || gc.Is64(n.Type) || gc.Isfloat[n.Type.Etype] != 0 { gc.Tempname(&n2, n.Type) } else { @@ -337,6 +341,7 @@ gc.OINDEX, gc.OIND, gc.ONAME: // PHEAP or PPARAMREF var + var n1 gc.Node igen(n, &n1, res) gmove(&n1, res) @@ -344,6 +349,7 @@ // interface table is first word of interface value case gc.OITAB: + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type @@ -353,14 +359,16 @@ // pointer is the first word of string or slice. case gc.OSPTR: if gc.Isconst(nl, gc.CTSTR) { + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) - p1 = gins(arm.AMOVW, nil, &n1) + p1 := gins(arm.AMOVW, nil, &n1) gc.Datastring(nl.Val.U.Sval.S, &p1.From) gmove(&n1, res) regfree(&n1) break } + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type gmove(&n1, res) @@ -370,13 +378,15 @@ if gc.Istype(nl.Type, gc.TMAP) || gc.Istype(nl.Type, gc.TCHAN) { // map has len in the first 32-bit word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gcmp(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) n2 = n1 n2.Op = gc.OINDREG @@ -392,6 +402,7 @@ if gc.Istype(nl.Type, gc.TSTRING) || gc.Isslice(nl.Type) { // both slice and string have len one pointer into the struct. + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.TUINT32] @@ -407,13 +418,15 @@ if gc.Istype(nl.Type, gc.TCHAN) { // chan has cap in the second 32-bit word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gcmp(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) n2 = n1 n2.Op = gc.OINDREG @@ -429,6 +442,7 @@ } if gc.Isslice(nl.Type) { + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.TUINT32] n1.Xoffset += int64(gc.Array_cap) @@ -446,7 +460,7 @@ // Pick it up again after the call. case gc.OCALLMETH, gc.OCALLFUNC: - rg = -1 + rg := -1 if n.Ullman >= gc.UINF { if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) { @@ -479,7 +493,7 @@ sbop: // symmetric binary if nl.Ullman < nr.Ullman { - r = nl + r := nl nl = nr nr = r } @@ -601,20 +615,16 @@ * returns Prog* to patch to panic call. */ func cgenindex(n *gc.Node, res *gc.Node, bounded bool) *obj.Prog { - var tmp gc.Node - var lo gc.Node - var hi gc.Node - var zero gc.Node - var n1 gc.Node - var n2 gc.Node - if !gc.Is64(n.Type) { cgen(n, res) return nil } + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT64]) cgen(n, &tmp) + var lo gc.Node + var hi gc.Node split64(&tmp, &lo, &hi) gmove(&lo, res) if bounded { @@ -622,8 +632,11 @@ return nil } + var n1 gc.Node regalloc(&n1, gc.Types[gc.TINT32], nil) + var n2 gc.Node regalloc(&n2, gc.Types[gc.TINT32], nil) + var zero gc.Node gc.Nodconst(&zero, gc.Types[gc.TINT32], 0) gmove(&hi, &n1) gmove(&zero, &n2) @@ -640,12 +653,6 @@ * The generated code checks that the result is not nil. */ func agen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var r int - if gc.Debug['g'] != 0 { gc.Dump("\nagen-res", res) gc.Dump("agen-r", n) @@ -659,15 +666,18 @@ n = n.Left } + var nl *gc.Node if gc.Isconst(n, gc.CTNIL) && n.Type.Width > int64(gc.Widthptr) { // Use of a nil interface or nil slice. // Create a temporary we can take the address of and read. // The generated code is just going to panic, so it need not // be terribly efficient. See issue 3670. + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Gvardef(&n1) clearfat(&n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) gins(arm.AMOVW, &n1, &n2) gmove(&n2, res) @@ -676,9 +686,10 @@ } if n.Addable != 0 { - n1 = gc.Node{} + n1 := gc.Node{} n1.Op = gc.OADDR n1.Left = n + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) gins(arm.AMOVW, &n1, &n2) gmove(&n2, res) @@ -696,7 +707,7 @@ // Pick it up again after the call. case gc.OCALLMETH, gc.OCALLFUNC: - r = -1 + r := -1 if n.Ullman >= gc.UINF { if res.Op == gc.OREGISTER || res.Op == gc.OINDREG { @@ -724,16 +735,19 @@ gc.OSLICESTR, gc.OSLICE3, gc.OSLICE3ARR: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) agen(&n1, res) case gc.OEFACE: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) agen(&n1, res) case gc.OINDEX: + var n1 gc.Node agenr(n, &n1, res) gmove(&n1, res) regfree(&n1) @@ -753,8 +767,11 @@ cgen(n.Heapaddr, res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset) + var n2 gc.Node regalloc(&n2, n1.Type, nil) + var n3 gc.Node regalloc(&n3, gc.Types[gc.TINT32], nil) gmove(&n1, &n2) gmove(res, &n3) @@ -771,8 +788,11 @@ case gc.ODOT: agen(nl, res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset) + var n2 gc.Node regalloc(&n2, n1.Type, nil) + var n3 gc.Node regalloc(&n3, gc.Types[gc.TINT32], nil) gmove(&n1, &n2) gmove(res, &n3) @@ -786,8 +806,11 @@ cgen(nl, res) gc.Cgen_checknil(res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset) + var n2 gc.Node regalloc(&n2, n1.Type, nil) + var n3 gc.Node regalloc(&n3, gc.Types[gc.Tptr], nil) gmove(&n1, &n2) gmove(res, &n3) @@ -811,9 +834,6 @@ * The generated code checks that the result is not *nil. */ func igen(n *gc.Node, a *gc.Node, res *gc.Node) { - var n1 gc.Node - var r int - if gc.Debug['g'] != 0 { gc.Dump("\nigen-n", n) } @@ -844,6 +864,7 @@ case gc.ODOTPTR: if n.Left.Addable != 0 || n.Left.Op == gc.OCALLFUNC || n.Left.Op == gc.OCALLMETH || n.Left.Op == gc.OCALLINTER { // igen-able nodes. + var n1 gc.Node igen(n.Left, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) @@ -865,7 +886,7 @@ case gc.OCALLMETH, gc.OCALLFUNC, gc.OCALLINTER: - r = -1 + r := -1 if n.Ullman >= gc.UINF { if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) { @@ -906,8 +927,6 @@ * The caller must call regfree(a). */ func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("cgenr-n", n) } @@ -930,6 +949,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) gmove(&n1, a) @@ -949,25 +969,12 @@ * The generated code checks that the result is not nil. */ func agenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var n4 gc.Node - var tmp gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var w uint32 - var v uint64 - var bounded bool - if gc.Debug['g'] != 0 { gc.Dump("agenr-n", n) } - nl = n.Left - nr = n.Right + nl := n.Left + nr := n.Right switch n.Op { case gc.ODOT, @@ -975,6 +982,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) agen(&n1, a) @@ -985,10 +993,13 @@ gc.Cgen_checknil(a) case gc.OINDEX: - p2 = nil // to be patched to panicindex. - w = uint32(n.Type.Width) - bounded = gc.Debug['B'] != 0 || n.Bounded + p2 := (*obj.Prog)(nil) // to be patched to panicindex. + w := uint32(n.Type.Width) + bounded := gc.Debug['B'] != 0 || n.Bounded + var n1 gc.Node + var n3 gc.Node if nr.Addable != 0 { + var tmp gc.Node if !gc.Isconst(nr, gc.CTINT) { gc.Tempname(&tmp, gc.Types[gc.TINT32]) } @@ -1002,6 +1013,7 @@ } } else if nl.Addable != 0 { if !gc.Isconst(nr, gc.CTINT) { + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT32]) p2 = cgenindex(nr, &tmp, bounded) regalloc(&n1, tmp.Type, nil) @@ -1012,6 +1024,7 @@ agenr(nl, &n3, res) } } else { + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT32]) p2 = cgenindex(nr, &tmp, bounded) nr = &tmp @@ -1031,19 +1044,21 @@ if gc.Isconst(nl, gc.CTSTR) { gc.Fatal("constant string constant index") } - v = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + v := uint64(gc.Mpgetfix(nr.Val.U.Xval)) + var n2 gc.Node if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { if gc.Debug['B'] == 0 && !n.Bounded { n1 = n3 n1.Op = gc.OINDREG n1.Type = gc.Types[gc.Tptr] n1.Xoffset = int64(gc.Array_nel) + var n4 gc.Node regalloc(&n4, n1.Type, nil) gmove(&n1, &n4) gc.Nodconst(&n2, gc.Types[gc.TUINT32], int64(v)) gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n4, &n2) regfree(&n4) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1) ginscall(gc.Panicindex, 0) gc.Patch(p1, gc.Pc) } @@ -1061,10 +1076,12 @@ break } + var n2 gc.Node regalloc(&n2, gc.Types[gc.TINT32], &n1) // i gmove(&n1, &n2) regfree(&n1) + var n4 gc.Node if gc.Debug['B'] == 0 && !n.Bounded { // check bounds if gc.Isconst(nl, gc.CTSTR) { @@ -1084,7 +1101,7 @@ if n4.Op == gc.OREGISTER { regfree(&n4) } - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) if p2 != nil { gc.Patch(p2, gc.Pc) } @@ -1094,7 +1111,7 @@ if gc.Isconst(nl, gc.CTSTR) { regalloc(&n3, gc.Types[gc.Tptr], res) - p1 = gins(arm.AMOVW, nil, &n3) + p1 := gins(arm.AMOVW, nil, &n3) gc.Datastring(nl.Val.U.Sval.S, &p1.From) p1.From.Type = obj.TYPE_ADDR } else if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { @@ -1141,15 +1158,14 @@ func gencmp0(n *gc.Node, t *gc.Type, o int, likely int, to *obj.Prog) { var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var a int regalloc(&n1, t, nil) cgen(n, &n1) - a = optoas(gc.OCMP, t) + a := optoas(gc.OCMP, t) if a != arm.ACMP { + var n2 gc.Node gc.Nodconst(&n2, t, 0) + var n3 gc.Node regalloc(&n3, t, nil) gmove(&n2, &n3) gcmp(a, &n1, &n3) @@ -1167,19 +1183,6 @@ * if(n == true) goto to; */ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { - var et int - var a int - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var tmp gc.Node - var ll *gc.NodeList - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['g'] != 0 { gc.Dump("\nbgen", n) } @@ -1192,6 +1195,9 @@ gc.Genlist(n.Ninit) } + var et int + var nl *gc.Node + var nr *gc.Node if n.Type == nil { gc.Convlit(&n, gc.Types[gc.TBOOL]) if n.Type == nil { @@ -1210,7 +1216,7 @@ switch n.Op { default: - a = gc.ONE + a := gc.ONE if !true_ { a = gc.OEQ } @@ -1227,8 +1233,8 @@ case gc.OANDAND, gc.OOROR: if (n.Op == gc.OANDAND) == true_ { - p1 = gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n.Left, !true_, -likely, p2) bgen(n.Right, !true_, -likely, p2) @@ -1273,15 +1279,15 @@ gc.OGT, gc.OLE, gc.OGE: - a = int(n.Op) + a := int(n.Op) if !true_ { if gc.Isfloat[nl.Type.Etype] != 0 { // brcom is not valid on floats when NaN is involved. - p1 = gc.Gbranch(arm.AB, nil, 0) + p1 := gc.Gbranch(arm.AB, nil, 0) - p2 = gc.Gbranch(arm.AB, nil, 0) + p2 := gc.Gbranch(arm.AB, nil, 0) gc.Patch(p1, gc.Pc) - ll = n.Ninit + ll := n.Ninit n.Ninit = nil bgen(n, true, -likely, p2) n.Ninit = ll @@ -1297,7 +1303,7 @@ // make simplest on right if nl.Op == gc.OLITERAL || (nl.Ullman < gc.UINF && nl.Ullman < nr.Ullman) { a = gc.Brrev(a) - r = nl + r := nl nl = nr nr = r } @@ -1309,6 +1315,7 @@ break } + var n1 gc.Node igen(nl, &n1, nil) n1.Xoffset += int64(gc.Array_array) n1.Type = gc.Types[gc.Tptr] @@ -1324,6 +1331,7 @@ break } + var n1 gc.Node igen(nl, &n1, nil) n1.Type = gc.Types[gc.Tptr] n1.Xoffset += 0 @@ -1339,12 +1347,14 @@ if gc.Is64(nr.Type) { if nl.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) nl = &n1 } if nr.Addable == 0 { + var n2 gc.Node gc.Tempname(&n2, nr.Type) cgen(nr, &n2) nr = &n2 @@ -1369,13 +1379,16 @@ a = optoas(a, nr.Type) if nr.Ullman >= gc.UINF { + var n1 gc.Node regalloc(&n1, nl.Type, nil) cgen(nl, &n1) + var tmp gc.Node gc.Tempname(&tmp, nl.Type) gmove(&n1, &tmp) regfree(&n1) + var n2 gc.Node regalloc(&n2, nr.Type, nil) cgen(nr, &n2) @@ -1390,26 +1403,30 @@ break } + var n3 gc.Node gc.Tempname(&n3, nl.Type) cgen(nl, &n3) + var tmp gc.Node gc.Tempname(&tmp, nr.Type) cgen(nr, &tmp) + var n1 gc.Node regalloc(&n1, nl.Type, nil) gmove(&n3, &n1) + var n2 gc.Node regalloc(&n2, nr.Type, nil) gmove(&tmp, &n2) gcmp(optoas(gc.OCMP, nr.Type), &n1, &n2) if gc.Isfloat[nl.Type.Etype] != 0 { if n.Op == gc.ONE { - p1 = gc.Gbranch(arm.ABVS, nr.Type, likely) + p1 := gc.Gbranch(arm.ABVS, nr.Type, likely) gc.Patch(gc.Gbranch(a, nr.Type, likely), to) gc.Patch(p1, to) } else { - p1 = gc.Gbranch(arm.ABVS, nr.Type, -likely) + p1 := gc.Gbranch(arm.ABVS, nr.Type, -likely) gc.Patch(gc.Gbranch(a, nr.Type, likely), to) gc.Patch(p1, gc.Pc) } @@ -1432,31 +1449,27 @@ * return n's offset from SP. */ func stkof(n *gc.Node) int32 { - var t *gc.Type - var flist gc.Iter - var off int32 - switch n.Op { case gc.OINDREG: return int32(n.Xoffset) case gc.ODOT: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } return int32(int64(off) + n.Xoffset) case gc.OINDEX: - t = n.Left.Type + t := n.Left.Type if !gc.Isfixedarray(t) { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } @@ -1468,11 +1481,12 @@ case gc.OCALLMETH, gc.OCALLINTER, gc.OCALLFUNC: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } + var flist gc.Iter t = gc.Structfirst(&flist, gc.Getoutarg(t)) if t != nil { return int32(t.Width + 4) // correct for LR @@ -1490,24 +1504,6 @@ * NB: character copy assumed little endian architecture */ func sgen(n *gc.Node, res *gc.Node, w int64) { - var dst gc.Node - var src gc.Node - var tmp gc.Node - var nend gc.Node - var r0 gc.Node - var r1 gc.Node - var r2 gc.Node - var f *gc.Node - var c int32 - var odst int32 - var osrc int32 - var dir int - var align int - var op int - var p *obj.Prog - var ploop *obj.Prog - var l *gc.NodeList - if gc.Debug['g'] != 0 { fmt.Printf("\nsgen w=%d\n", w) gc.Dump("r", n) @@ -1528,6 +1524,7 @@ if w == 0 { // evaluate side effects only. + var dst gc.Node regalloc(&dst, gc.Types[gc.Tptr], nil) agen(res, &dst) @@ -1539,7 +1536,7 @@ // If copying .args, that's all the results, so record definition sites // for them for the liveness analysis. if res.Op == gc.ONAME && res.Sym.Name == ".args" { - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { if l.N.Class == gc.PPARAMOUT { gc.Gvardef(l.N) } @@ -1555,8 +1552,9 @@ // want to avoid unaligned access, so have to use // smaller operations for less aligned types. // for example moving [4]byte must use 4 MOVB not 1 MOVW. - align = int(n.Type.Align) + align := int(n.Type.Align) + var op int switch align { default: gc.Fatal("sgen: invalid alignment %d for %v", align, gc.Tconv(n.Type, 0)) @@ -1574,17 +1572,18 @@ if w%int64(align) != 0 { gc.Fatal("sgen: unaligned size %d (align=%d) for %v", w, align, gc.Tconv(n.Type, 0)) } - c = int32(w / int64(align)) + c := int32(w / int64(align)) // offset on the stack - osrc = stkof(n) + osrc := stkof(n) - odst = stkof(res) + odst := stkof(res) if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) { // osrc and odst both on stack, and at least one is in // an unknown position. Could generate code to test // for forward/backward copy, but instead just copy // to a temporary location first. + var tmp gc.Node gc.Tempname(&tmp, n.Type) sgen(n, &tmp, w) @@ -1598,21 +1597,26 @@ // if we are copying forward on the stack and // the src and dst overlap, then reverse direction - dir = align + dir := align if osrc < odst && int64(odst) < int64(osrc)+w { dir = -dir } if op == arm.AMOVW && !gc.Nacl && dir > 0 && c >= 4 && c <= 128 { + var r0 gc.Node r0.Op = gc.OREGISTER r0.Val.U.Reg = REGALLOC_R0 + var r1 gc.Node r1.Op = gc.OREGISTER r1.Val.U.Reg = REGALLOC_R0 + 1 + var r2 gc.Node r2.Op = gc.OREGISTER r2.Val.U.Reg = REGALLOC_R0 + 2 + var src gc.Node regalloc(&src, gc.Types[gc.Tptr], &r1) + var dst gc.Node regalloc(&dst, gc.Types[gc.Tptr], &r2) if n.Ullman >= res.Ullman { // eval n first @@ -1631,9 +1635,10 @@ agen(n, &src) } + var tmp gc.Node regalloc(&tmp, gc.Types[gc.Tptr], &r0) - f = gc.Sysfunc("duffcopy") - p = gins(obj.ADUFFCOPY, nil, f) + f := gc.Sysfunc("duffcopy") + p := gins(obj.ADUFFCOPY, nil, f) gc.Afunclit(&p.To, f) // 8 and 128 = magic constants: see ../../runtime/asm_arm.s @@ -1645,6 +1650,8 @@ return } + var dst gc.Node + var src gc.Node if n.Ullman >= res.Ullman { agenr(n, &dst, res) // temporarily use dst regalloc(&src, gc.Types[gc.Tptr], nil) @@ -1661,15 +1668,16 @@ agenr(n, &src, nil) } + var tmp gc.Node regalloc(&tmp, gc.Types[gc.TUINT32], nil) // set up end marker - nend = gc.Node{} + nend := gc.Node{} if c >= 4 { regalloc(&nend, gc.Types[gc.TUINT32], nil) - p = gins(arm.AMOVW, &src, &nend) + p := gins(arm.AMOVW, &src, &nend) p.From.Type = obj.TYPE_ADDR if dir < 0 { p.From.Offset = int64(dir) @@ -1680,7 +1688,7 @@ // move src and dest to the end of block if necessary if dir < 0 { - p = gins(arm.AMOVW, &src, &src) + p := gins(arm.AMOVW, &src, &src) p.From.Type = obj.TYPE_ADDR p.From.Offset = w + int64(dir) @@ -1691,11 +1699,11 @@ // move if c >= 4 { - p = gins(op, &src, &tmp) + p := gins(op, &src, &tmp) p.From.Type = obj.TYPE_MEM p.From.Offset = int64(dir) p.Scond |= arm.C_PBIT - ploop = p + ploop := p p = gins(op, &tmp, &dst) p.To.Type = obj.TYPE_MEM @@ -1708,6 +1716,7 @@ gc.Patch(gc.Gbranch(arm.ABNE, nil, 0), ploop) regfree(&nend) } else { + var p *obj.Prog for { tmp14 := c c-- @@ -1757,23 +1766,16 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool { var nodl gc.Node var nodr gc.Node - var tmp gc.Node - var t *gc.Type - var freel int - var freer int - var fldcount int64 - var loffset int64 - var roffset int64 - freel = 0 - freer = 0 + freel := 0 + freer := 0 switch nl.Type.Etype { default: goto no case gc.TARRAY: - t = nl.Type + t := nl.Type // Slices are ok. if gc.Isslice(t) { @@ -1790,9 +1792,9 @@ // Small structs with non-fat types are ok. // Zero-sized structs are treated separately elsewhere. case gc.TSTRUCT: - fldcount = 0 + fldcount := int64(0) - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { if gc.Isfat(t.Type) { goto no } @@ -1828,6 +1830,7 @@ } } else { // When zeroing, prepare a register containing zero. + var tmp gc.Node gc.Nodconst(&tmp, nl.Type, 0) regalloc(&nodr, gc.Types[gc.TUINT], nil) @@ -1849,11 +1852,11 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - t = nl.Type + t := nl.Type if !gc.Isslice(t) { nodl.Type = t.Type nodr.Type = nodl.Type - for fldcount = 0; fldcount < t.Bound; fldcount++ { + for fldcount := int64(0); fldcount < t.Bound; fldcount++ { if nr == nil { gc.Clearslim(&nodl) } else { @@ -1956,8 +1959,8 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - loffset = nodl.Xoffset - roffset = nodr.Xoffset + loffset := nodl.Xoffset + roffset := nodr.Xoffset // funarg structs may not begin at offset zero. if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil { @@ -1967,7 +1970,7 @@ roffset -= nr.Type.Type.Width } - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { nodl.Xoffset = loffset + t.Width nodl.Type = t.Type
diff --git a/src/cmd/5g/cgen64.go b/src/cmd/5g/cgen64.go index f89c21c..b9e5b7c 100644 --- a/src/cmd/5g/cgen64.go +++ b/src/cmd/5g/cgen64.go
@@ -16,61 +16,43 @@ * return 1 on success, 0 if op not handled. */ func cgen64(n *gc.Node, res *gc.Node) { - var t1 gc.Node - var t2 gc.Node - var l *gc.Node - var r *gc.Node - var lo1 gc.Node - var lo2 gc.Node - var hi1 gc.Node - var hi2 gc.Node - var al gc.Node - var ah gc.Node - var bl gc.Node - var bh gc.Node - var cl gc.Node - var ch gc.Node - var s gc.Node - var n1 gc.Node - var creg gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var p4 *obj.Prog - var p5 *obj.Prog - var p6 *obj.Prog - var v uint64 - if res.Op != gc.OINDREG && res.Op != gc.ONAME { gc.Dump("n", n) gc.Dump("res", res) gc.Fatal("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0)) } - l = n.Left + l := n.Left + var t1 gc.Node if l.Addable == 0 { gc.Tempname(&t1, l.Type) cgen(l, &t1) l = &t1 } + var hi1 gc.Node + var lo1 gc.Node split64(l, &lo1, &hi1) switch n.Op { default: gc.Fatal("cgen64 %v", gc.Oconv(int(n.Op), 0)) case gc.OMINUS: + var lo2 gc.Node + var hi2 gc.Node split64(res, &lo2, &hi2) regalloc(&t1, lo1.Type, nil) + var al gc.Node regalloc(&al, lo1.Type, nil) + var ah gc.Node regalloc(&ah, hi1.Type, nil) gins(arm.AMOVW, &lo1, &al) gins(arm.AMOVW, &hi1, &ah) gmove(ncon(0), &t1) - p1 = gins(arm.ASUB, &al, &t1) + p1 := gins(arm.ASUB, &al, &t1) p1.Scond |= arm.C_SBIT gins(arm.AMOVW, &t1, &lo2) @@ -89,7 +71,10 @@ regalloc(&t1, lo1.Type, nil) gmove(ncon(^uint32(0)), &t1) + var lo2 gc.Node + var hi2 gc.Node split64(res, &lo2, &hi2) + var n1 gc.Node regalloc(&n1, lo1.Type, nil) gins(arm.AMOVW, &lo1, &n1) @@ -121,19 +106,24 @@ } // setup for binary operators - r = n.Right + r := n.Right if r != nil && r.Addable == 0 { + var t2 gc.Node gc.Tempname(&t2, r.Type) cgen(r, &t2) r = &t2 } + var hi2 gc.Node + var lo2 gc.Node if gc.Is64(r.Type) { split64(r, &lo2, &hi2) } + var al gc.Node regalloc(&al, lo1.Type, nil) + var ah gc.Node regalloc(&ah, hi1.Type, nil) // Do op. Leave result in ah:al. @@ -143,14 +133,16 @@ // TODO: Constants case gc.OADD: + var bl gc.Node regalloc(&bl, gc.Types[gc.TPTR32], nil) + var bh gc.Node regalloc(&bh, gc.Types[gc.TPTR32], nil) gins(arm.AMOVW, &hi1, &ah) gins(arm.AMOVW, &lo1, &al) gins(arm.AMOVW, &hi2, &bh) gins(arm.AMOVW, &lo2, &bl) - p1 = gins(arm.AADD, &bl, &al) + p1 := gins(arm.AADD, &bl, &al) p1.Scond |= arm.C_SBIT gins(arm.AADC, &bh, &ah) regfree(&bl) @@ -158,14 +150,16 @@ // TODO: Constants. case gc.OSUB: + var bl gc.Node regalloc(&bl, gc.Types[gc.TPTR32], nil) + var bh gc.Node regalloc(&bh, gc.Types[gc.TPTR32], nil) gins(arm.AMOVW, &lo1, &al) gins(arm.AMOVW, &hi1, &ah) gins(arm.AMOVW, &lo2, &bl) gins(arm.AMOVW, &hi2, &bh) - p1 = gins(arm.ASUB, &bl, &al) + p1 := gins(arm.ASUB, &bl, &al) p1.Scond |= arm.C_SBIT gins(arm.ASBC, &bh, &ah) regfree(&bl) @@ -173,10 +167,14 @@ // TODO(kaib): this can be done with 4 regs and does not need 6 case gc.OMUL: + var bl gc.Node regalloc(&bl, gc.Types[gc.TPTR32], nil) + var bh gc.Node regalloc(&bh, gc.Types[gc.TPTR32], nil) + var cl gc.Node regalloc(&cl, gc.Types[gc.TPTR32], nil) + var ch gc.Node regalloc(&ch, gc.Types[gc.TPTR32], nil) // load args into bh:bl and bh:bl. @@ -187,7 +185,7 @@ gins(arm.AMOVW, &lo2, &cl) // bl * cl -> ah al - p1 = gins(arm.AMULLU, nil, nil) + p1 := gins(arm.AMULLU, nil, nil) p1.From.Type = obj.TYPE_REG p1.From.Reg = bl.Val.U.Reg @@ -239,9 +237,11 @@ // shld hi:lo, c // shld lo:t, c case gc.OLROT: - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) + var bl gc.Node regalloc(&bl, lo1.Type, nil) + var bh gc.Node regalloc(&bh, hi1.Type, nil) if v >= 32 { // reverse during load to do the first 32 bits of rotate @@ -274,13 +274,24 @@ regfree(&bh) case gc.OLSH: + var bl gc.Node regalloc(&bl, lo1.Type, nil) + var bh gc.Node regalloc(&bh, hi1.Type, nil) gins(arm.AMOVW, &hi1, &bh) gins(arm.AMOVW, &lo1, &bl) + var p6 *obj.Prog + var s gc.Node + var n1 gc.Node + var creg gc.Node + var p1 *obj.Prog + var p2 *obj.Prog + var p3 *obj.Prog + var p4 *obj.Prog + var p5 *obj.Prog if r.Op == gc.OLITERAL { - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) if v >= 64 { // TODO(kaib): replace with gins(AMOVW, nodintconst(0), &al) // here and below (verify it optimizes to EOR) @@ -316,6 +327,8 @@ regalloc(&creg, gc.Types[gc.TUINT32], nil) if gc.Is64(r.Type) { // shift is >= 1<<32 + var cl gc.Node + var ch gc.Node split64(r, &cl, &ch) gmove(&ch, &s) @@ -422,13 +435,24 @@ regfree(&bh) case gc.ORSH: + var bl gc.Node regalloc(&bl, lo1.Type, nil) + var bh gc.Node regalloc(&bh, hi1.Type, nil) gins(arm.AMOVW, &hi1, &bh) gins(arm.AMOVW, &lo1, &bl) + var p4 *obj.Prog + var p5 *obj.Prog + var n1 gc.Node + var p6 *obj.Prog + var s gc.Node + var p1 *obj.Prog + var p2 *obj.Prog + var creg gc.Node + var p3 *obj.Prog if r.Op == gc.OLITERAL { - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) if v >= 64 { if bh.Type.Etype == gc.TINT32 { // MOVW bh->31, al @@ -487,10 +511,13 @@ regalloc(&creg, gc.Types[gc.TUINT32], nil) if gc.Is64(r.Type) { // shift is >= 1<<32 + var ch gc.Node + var cl gc.Node split64(r, &cl, &ch) gmove(&ch, &s) gins(arm.ATST, &s, nil) + var p1 *obj.Prog if bh.Type.Etype == gc.TINT32 { p1 = gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah) } else { @@ -578,12 +605,12 @@ if bh.Type.Etype == gc.TINT32 { // MOVW bh->(s-32), al - p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &al) + p1 := gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &al) p1.Scond = arm.C_SCOND_LO } else { // MOVW bh>>(v-32), al - p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &al) + p1 := gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &al) p1.Scond = arm.C_SCOND_LO } @@ -708,6 +735,7 @@ case gc.OXOR, gc.OAND, gc.OOR: + var n1 gc.Node regalloc(&n1, lo1.Type, nil) gins(arm.AMOVW, &lo1, &al) @@ -746,15 +774,13 @@ var hi2 gc.Node var r1 gc.Node var r2 gc.Node - var br *obj.Prog - var t *gc.Type split64(nl, &lo1, &hi1) split64(nr, &lo2, &hi2) // compare most significant word; // if they differ, we're done. - t = hi1.Type + t := hi1.Type regalloc(&r1, gc.Types[gc.TINT32], nil) regalloc(&r2, gc.Types[gc.TINT32], nil) @@ -764,7 +790,7 @@ regfree(&r1) regfree(&r2) - br = nil + br := (*obj.Prog)(nil) switch op { default: gc.Fatal("cmp64 %v %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
diff --git a/src/cmd/5g/ggen.go b/src/cmd/5g/ggen.go index 3b007d8..8b7010f 100644 --- a/src/cmd/5g/ggen.go +++ b/src/cmd/5g/ggen.go
@@ -11,30 +11,24 @@ import "cmd/internal/gc" func defframe(ptxt *obj.Prog) { - var frame uint32 - var r0 uint32 - var p *obj.Prog - var hi int64 - var lo int64 - var l *gc.NodeList var n *gc.Node // fill in argument size, stack size ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr))) - frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) + frame := uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) ptxt.To.Offset = int64(frame) // insert code to contain ambiguously live variables // so that garbage collector only sees initialized values // when it looks for pointers. - p = ptxt + p := ptxt - hi = 0 - lo = hi - r0 = 0 - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + hi := int64(0) + lo := hi + r0 := uint32(0) + for l := gc.Curfn.Dcl; l != nil; l = l.Next { n = l.N if n.Needzero == 0 { continue @@ -66,12 +60,7 @@ } func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, r0 *uint32) *obj.Prog { - var cnt int64 - var i int64 - var p1 *obj.Prog - var f *gc.Node - - cnt = hi - lo + cnt := hi - lo if cnt == 0 { return p } @@ -81,14 +70,14 @@ } if cnt < int64(4*gc.Widthptr) { - for i = 0; i < cnt; i += int64(gc.Widthptr) { + for i := int64(0); i < cnt; i += int64(gc.Widthptr) { p = appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, int32(4+frame+lo+i)) } } else if !gc.Nacl && (cnt <= int64(128*gc.Widthptr)) { p = appendpp(p, arm.AADD, obj.TYPE_CONST, 0, int32(4+frame+lo), obj.TYPE_REG, arm.REG_R1, 0) p.Reg = arm.REGSP p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0) - f = gc.Sysfunc("duffzero") + f := gc.Sysfunc("duffzero") gc.Naddr(f, &p.To, 1) gc.Afunclit(&p.To, f) p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr)) @@ -98,7 +87,7 @@ p = appendpp(p, arm.AADD, obj.TYPE_CONST, 0, int32(cnt), obj.TYPE_REG, arm.REG_R2, 0) p.Reg = arm.REG_R1 p = appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4) - p1 = p + p1 := p p.Scond |= arm.C_PBIT p = appendpp(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0) p.Reg = arm.REG_R2 @@ -110,9 +99,7 @@ } func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int32, ttype int, treg int, toffset int32) *obj.Prog { - var q *obj.Prog - - q = gc.Ctxt.NewProg() + q := gc.Ctxt.NewProg() gc.Clearp(q) q.As = int16(as) q.Lineno = p.Lineno @@ -137,14 +124,8 @@ * proc=3 normal call to C pointer (not Go func value) */ func ginscall(f *gc.Node, proc int) { - var p *obj.Prog - var r gc.Node - var r1 gc.Node - var con gc.Node - var extra int32 - if f.Type != nil { - extra = 0 + extra := int32(0) if proc == 1 || proc == 2 { extra = 2 * int32(gc.Widthptr) } @@ -168,13 +149,14 @@ // ARM NOP 0x00000000 is really AND.EQ R0, R0, R0. // Use the latter form because the NOP pseudo-instruction // would be removed by the linker. + var r gc.Node gc.Nodreg(&r, gc.Types[gc.TINT], arm.REG_R0) - p = gins(arm.AAND, &r, &r) + p := gins(arm.AAND, &r, &r) p.Scond = arm.C_SCOND_EQ } - p = gins(arm.ABL, nil, f) + p := gins(arm.ABL, nil, f) gc.Afunclit(&p.To, f) if proc == -1 || gc.Noreturn(p) { gins(obj.AUNDEF, nil, nil) @@ -182,7 +164,9 @@ break } + var r gc.Node gc.Nodreg(&r, gc.Types[gc.Tptr], arm.REG_R7) + var r1 gc.Node gc.Nodreg(&r1, gc.Types[gc.Tptr], arm.REG_R1) gmove(f, &r) r.Op = gc.OINDREG @@ -196,11 +180,13 @@ case 1, // call in new proc (go) 2: // deferred call (defer) + var r gc.Node regalloc(&r, gc.Types[gc.Tptr], nil) + var con gc.Node gc.Nodconst(&con, gc.Types[gc.TINT32], int64(gc.Argsize(f.Type))) gins(arm.AMOVW, &con, &r) - p = gins(arm.AMOVW, &r, nil) + p := gins(arm.AMOVW, &r, nil) p.To.Type = obj.TYPE_MEM p.To.Reg = arm.REGSP p.To.Offset = 4 @@ -221,7 +207,7 @@ if proc == 2 { gc.Nodconst(&con, gc.Types[gc.TINT32], 0) - p = gins(arm.ACMP, &con, nil) + p := gins(arm.ACMP, &con, nil) p.Reg = arm.REG_R0 p = gc.Gbranch(arm.ABEQ, nil, +1) cgen_ret(nil) @@ -235,21 +221,12 @@ * generate res = n. */ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) { - var r int - var i *gc.Node - var f *gc.Node - var tmpi gc.Node - var nodo gc.Node - var nodr gc.Node - var nodsp gc.Node - var p *obj.Prog - - i = n.Left + i := n.Left if i.Op != gc.ODOTINTER { gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0)) } - f = i.Right // field + f := i.Right // field if f.Op != gc.ONAME { gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0)) } @@ -258,7 +235,7 @@ // Release res register during genlist and cgen, // which might have their own function calls. - r = -1 + r := -1 if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) { r = int(res.Val.U.Reg) @@ -266,6 +243,7 @@ } if i.Addable == 0 { + var tmpi gc.Node gc.Tempname(&tmpi, i.Type) cgen(i, &tmpi) i = &tmpi @@ -276,12 +254,15 @@ reg[r]++ } + var nodr gc.Node regalloc(&nodr, gc.Types[gc.Tptr], res) + var nodo gc.Node regalloc(&nodo, gc.Types[gc.Tptr], &nodr) nodo.Op = gc.OINDREG agen(i, &nodr) // REG = &inter + var nodsp gc.Node gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], arm.REGSP) nodsp.Xoffset = int64(gc.Widthptr) @@ -305,7 +286,7 @@ proc = 3 } else { // go/defer. generate go func value. - p = gins(arm.AMOVW, &nodo, &nodr) + p := gins(arm.AMOVW, &nodo, &nodr) p.From.Type = obj.TYPE_ADDR // REG = &(20+offset(REG)) -- i.tab->fun[f] } @@ -324,14 +305,11 @@ * proc=2 defer call save away stack */ func cgen_call(n *gc.Node, proc int) { - var t *gc.Type - var nod gc.Node - var afun gc.Node - if n == nil { return } + var afun gc.Node if n.Left.Ullman >= gc.UINF { // if name involves a fn call // precompute the address of the fn @@ -341,10 +319,11 @@ } gc.Genlist(n.List) // assign the args - t = n.Left.Type + t := n.Left.Type // call tempname pointer if n.Left.Ullman >= gc.UINF { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, &afun) nod.Type = t @@ -355,6 +334,7 @@ // call pointer if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, n.Left) nod.Type = t @@ -377,22 +357,18 @@ * res = return value from call. */ func cgen_callret(n *gc.Node, res *gc.Node) { - var nod gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_callret: nil") } - nod = gc.Node{} + nod := gc.Node{} nod.Op = gc.OINDREG nod.Val.U.Reg = arm.REGSP nod.Addable = 1 @@ -408,23 +384,18 @@ * res = &return value from call. */ func cgen_aret(n *gc.Node, res *gc.Node) { - var nod1 gc.Node - var nod2 gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_aret: nil") } - nod1 = gc.Node{} + nod1 := gc.Node{} nod1.Op = gc.OINDREG nod1.Val.U.Reg = arm.REGSP nod1.Addable = 1 @@ -433,6 +404,7 @@ nod1.Type = fp.Type if res.Op != gc.OREGISTER { + var nod2 gc.Node regalloc(&nod2, gc.Types[gc.Tptr], res) agen(&nod1, &nod2) gins(arm.AMOVW, &nod2, res) @@ -447,8 +419,6 @@ * n->left is assignments to return values. */ func cgen_ret(n *gc.Node) { - var p *obj.Prog - if n != nil { gc.Genlist(n.List) // copy out args } @@ -456,7 +426,7 @@ ginscall(gc.Deferreturn, 0) } gc.Genlist(gc.Curfn.Exit) - p = gins(obj.ARET, nil, nil) + p := gins(obj.ARET, nil, nil) if n != nil && n.Op == gc.ORETJMP { p.To.Name = obj.NAME_EXTERN p.To.Type = obj.TYPE_ADDR @@ -469,23 +439,18 @@ * res = (nl * nr) >> wordsize */ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { - var w int - var n1 gc.Node - var n2 gc.Node - var tmp *gc.Node - var t *gc.Type - var p *obj.Prog - if nl.Ullman < nr.Ullman { - tmp = nl + tmp := nl nl = nr nr = tmp } - t = nl.Type - w = int(t.Width * 8) + t := nl.Type + w := int(t.Width * 8) + var n1 gc.Node regalloc(&n1, t, res) cgen(nl, &n1) + var n2 gc.Node regalloc(&n2, t, nil) cgen(nr, &n2) switch gc.Simtype[t.Etype] { @@ -502,6 +467,7 @@ // perform a long multiplication. case gc.TINT32, gc.TUINT32: + var p *obj.Prog if gc.Issigned[t.Etype] != 0 { p = gins(arm.AMULL, &n2, nil) } else { @@ -530,34 +496,21 @@ * res = nl >> nr */ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var nt gc.Node - var t gc.Node - var lo gc.Node - var hi gc.Node - var w int - var v int - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var tr *gc.Type - var sc uint64 - if nl.Type.Width > 4 { gc.Fatal("cgen_shift %v", gc.Tconv(nl.Type, 0)) } - w = int(nl.Type.Width * 8) + w := int(nl.Type.Width * 8) if op == gc.OLROT { - v = int(gc.Mpgetfix(nr.Val.U.Xval)) + v := int(gc.Mpgetfix(nr.Val.U.Xval)) + var n1 gc.Node regalloc(&n1, nl.Type, res) if w == 32 { cgen(nl, &n1) gshift(arm.AMOVW, &n1, arm.SHIFT_RR, int32(w)-int32(v), &n1) } else { + var n2 gc.Node regalloc(&n2, nl.Type, nil) cgen(nl, &n2) gshift(arm.AMOVW, &n2, arm.SHIFT_LL, int32(v), &n1) @@ -574,9 +527,10 @@ } if nr.Op == gc.OLITERAL { + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) - sc = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + sc := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if sc == 0 { } else // nothing to do if sc >= uint64(nl.Type.Width*8) { @@ -603,8 +557,13 @@ return } - tr = nr.Type + tr := nr.Type + var t gc.Node + var n1 gc.Node + var n2 gc.Node + var n3 gc.Node if tr.Width > 4 { + var nt gc.Node gc.Tempname(&nt, nr.Type) if nl.Ullman >= nr.Ullman { regalloc(&n2, nl.Type, res) @@ -617,6 +576,8 @@ cgen(nl, &n2) } + var hi gc.Node + var lo gc.Node split64(&nt, &lo, &hi) regalloc(&n1, gc.Types[gc.TUINT32], nil) regalloc(&n3, gc.Types[gc.TUINT32], nil) @@ -625,7 +586,7 @@ splitclean() gins(arm.ATST, &n3, nil) gc.Nodconst(&t, gc.Types[gc.TUINT32], int64(w)) - p1 = gins(arm.AMOVW, &t, &n1) + p1 := gins(arm.AMOVW, &t, &n1) p1.Scond = arm.C_SCOND_NE tr = gc.Types[gc.TUINT32] regfree(&n3) @@ -646,7 +607,7 @@ // test for shift being 0 gins(arm.ATST, &n1, nil) - p3 = gc.Gbranch(arm.ABEQ, nil, -1) + p3 := gc.Gbranch(arm.ABEQ, nil, -1) // test and fix up large shifts // TODO: if(!bounded), don't emit some of this. @@ -656,6 +617,8 @@ gmove(&t, &n3) gcmp(arm.ACMP, &n1, &n3) if op == gc.ORSH { + var p1 *obj.Prog + var p2 *obj.Prog if gc.Issigned[nl.Type.Etype] != 0 { p1 = gshift(arm.AMOVW, &n2, arm.SHIFT_AR, int32(w)-1, &n2) p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_AR, &n1, &n2) @@ -667,8 +630,8 @@ p1.Scond = arm.C_SCOND_HS p2.Scond = arm.C_SCOND_LO } else { - p1 = gins(arm.AEOR, &n2, &n2) - p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_LL, &n1, &n2) + p1 := gins(arm.AEOR, &n2, &n2) + p2 := gregshift(arm.AMOVW, &n2, arm.SHIFT_LL, &n1, &n2) p1.Scond = arm.C_SCOND_HS p2.Scond = arm.C_SCOND_LO } @@ -688,48 +651,41 @@ } func clearfat(nl *gc.Node) { - var w uint32 - var c uint32 - var q uint32 - var dst gc.Node - var nc gc.Node - var nz gc.Node - var end gc.Node - var r0 gc.Node - var r1 gc.Node - var f *gc.Node - var p *obj.Prog - var pl *obj.Prog - /* clear a fat object */ if gc.Debug['g'] != 0 { gc.Dump("\nclearfat", nl) } - w = uint32(nl.Type.Width) + w := uint32(nl.Type.Width) // Avoid taking the address for simple enough types. if componentgen(nil, nl) { return } - c = w % 4 // bytes - q = w / 4 // quads + c := w % 4 // bytes + q := w / 4 // quads + var r0 gc.Node r0.Op = gc.OREGISTER r0.Val.U.Reg = REGALLOC_R0 + var r1 gc.Node r1.Op = gc.OREGISTER r1.Val.U.Reg = REGALLOC_R0 + 1 + var dst gc.Node regalloc(&dst, gc.Types[gc.Tptr], &r1) agen(nl, &dst) + var nc gc.Node gc.Nodconst(&nc, gc.Types[gc.TUINT32], 0) + var nz gc.Node regalloc(&nz, gc.Types[gc.TUINT32], &r0) cgen(&nc, &nz) if q > 128 { + var end gc.Node regalloc(&end, gc.Types[gc.Tptr], nil) - p = gins(arm.AMOVW, &dst, &end) + p := gins(arm.AMOVW, &dst, &end) p.From.Type = obj.TYPE_ADDR p.From.Offset = int64(q) * 4 @@ -737,7 +693,7 @@ p.To.Type = obj.TYPE_MEM p.To.Offset = 4 p.Scond |= arm.C_PBIT - pl = p + pl := p p = gins(arm.ACMP, &dst, nil) raddr(&end, p) @@ -745,13 +701,14 @@ regfree(&end) } else if q >= 4 && !gc.Nacl { - f = gc.Sysfunc("duffzero") - p = gins(obj.ADUFFZERO, nil, f) + f := gc.Sysfunc("duffzero") + p := gins(obj.ADUFFZERO, nil, f) gc.Afunclit(&p.To, f) // 4 and 128 = magic constants: see ../../runtime/asm_arm.s p.To.Offset = 4 * (128 - int64(q)) } else { + var p *obj.Prog for q > 0 { p = gins(arm.AMOVW, &nz, &dst) p.To.Type = obj.TYPE_MEM @@ -763,6 +720,7 @@ } } + var p *obj.Prog for c > 0 { p = gins(arm.AMOVB, &nz, &dst) p.To.Type = obj.TYPE_MEM @@ -781,10 +739,9 @@ // Expand CHECKNIL pseudo-op into actual nil pointer check. func expandchecks(firstp *obj.Prog) { var reg int - var p *obj.Prog var p1 *obj.Prog - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.As != obj.ACHECKNIL { continue }
diff --git a/src/cmd/5g/gsubr.go b/src/cmd/5g/gsubr.go index 857bafa..a8b8ed5 100644 --- a/src/cmd/5g/gsubr.go +++ b/src/cmd/5g/gsubr.go
@@ -49,24 +49,20 @@ } func ginit() { - var i int - - for i = 0; i < len(reg); i++ { + for i := 0; i < len(reg); i++ { reg[i] = 0 } - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]++ } } func gclean() { - var i int - - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]-- } - for i = 0; i < len(reg); i++ { + for i := 0; i < len(reg); i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i)) } @@ -74,10 +70,9 @@ } func anyregalloc() bool { - var i int var j int - for i = 0; i < len(reg); i++ { + for i := 0; i < len(reg); i++ { if reg[i] == 0 { goto ok } @@ -101,20 +96,15 @@ * caller must regfree(n). */ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) { - var i int - var et int - var fixfree int - var floatfree int - if false && gc.Debug['r'] != 0 { - fixfree = 0 - for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ { + fixfree := 0 + for i := REGALLOC_R0; i <= REGALLOC_RMAX; i++ { if reg[i] == 0 { fixfree++ } } - floatfree = 0 - for i = REGALLOC_F0; i <= REGALLOC_FMAX; i++ { + floatfree := 0 + for i := REGALLOC_F0; i <= REGALLOC_FMAX; i++ { if reg[i] == 0 { floatfree++ } @@ -125,11 +115,12 @@ if t == nil { gc.Fatal("regalloc: t nil") } - et = int(gc.Simtype[t.Etype]) + et := int(gc.Simtype[t.Etype]) if gc.Is64(t) { gc.Fatal("regalloc: 64 bit type %v") } + var i int switch et { case gc.TINT8, gc.TUINT8, @@ -154,7 +145,7 @@ } fmt.Printf("registers allocated at\n") - for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ { + for i := REGALLOC_R0; i <= REGALLOC_RMAX; i++ { fmt.Printf("%d %p\n", i, regpc[i]) } gc.Fatal("out of fixed registers") @@ -195,19 +186,15 @@ } func regfree(n *gc.Node) { - var i int - var fixfree int - var floatfree int - if false && gc.Debug['r'] != 0 { - fixfree = 0 - for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ { + fixfree := 0 + for i := REGALLOC_R0; i <= REGALLOC_RMAX; i++ { if reg[i] == 0 { fixfree++ } } - floatfree = 0 - for i = REGALLOC_F0; i <= REGALLOC_FMAX; i++ { + floatfree := 0 + for i := REGALLOC_F0; i <= REGALLOC_FMAX; i++ { if reg[i] == 0 { floatfree++ } @@ -221,7 +208,7 @@ if n.Op != gc.OREGISTER && n.Op != gc.OINDREG { gc.Fatal("regfree: not a register") } - i = int(n.Val.U.Reg) + i := int(n.Val.U.Reg) if i == arm.REGSP { return } @@ -260,9 +247,6 @@ * n is a 64-bit value. fill in lo and hi to refer to its 32-bit halves. */ func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) { - var n1 gc.Node - var i int64 - if !gc.Is64(n.Type) { gc.Fatal("split64 %v", gc.Tconv(n.Type, 0)) } @@ -276,6 +260,7 @@ default: switch n.Op { default: + var n1 gc.Node if !dotaddable(n, &n1) { igen(n, &n1, nil) sclean[nsclean-1] = n1 @@ -285,6 +270,7 @@ case gc.ONAME: if n.Class == gc.PPARAMREF { + var n1 gc.Node cgen(n.Heapaddr, &n1) sclean[nsclean-1] = n1 n = &n1 @@ -306,8 +292,9 @@ hi.Xoffset += 4 case gc.OLITERAL: + var n1 gc.Node gc.Convconst(&n1, n.Type, &n.Val) - i = gc.Mpgetfix(n1.Val.U.Xval) + i := gc.Mpgetfix(n1.Val.U.Xval) gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i))) i >>= 32 if n.Type.Etype == gc.TINT64 { @@ -329,28 +316,13 @@ } func gmove(f *gc.Node, t *gc.Node) { - var a int - var ft int - var tt int - var fa int - var ta int - var cvt *gc.Type - var r1 gc.Node - var r2 gc.Node - var flo gc.Node - var fhi gc.Node - var tlo gc.Node - var thi gc.Node - var con gc.Node - var p1 *obj.Prog - if gc.Debug['M'] != 0 { fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, 0), gc.Nconv(t, 0)) } - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) + cvt := t.Type if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 { gc.Complexmove(f, t) @@ -359,19 +331,26 @@ // cannot have two memory operands; // except 64-bit, which always copies via registers anyway. + var flo gc.Node + var a int + var r1 gc.Node + var fhi gc.Node if !gc.Is64(f.Type) && !gc.Is64(t.Type) && gc.Ismem(f) && gc.Ismem(t) { goto hard } // convert constant to desired type if f.Op == gc.OLITERAL { + var con gc.Node switch tt { default: gc.Convconst(&con, t.Type, &f.Val) case gc.TINT16, gc.TINT8: + var con gc.Node gc.Convconst(&con, gc.Types[gc.TINT32], &f.Val) + var r1 gc.Node regalloc(&r1, con.Type, t) gins(arm.AMOVW, &con, &r1) gmove(&r1, t) @@ -380,7 +359,9 @@ case gc.TUINT16, gc.TUINT8: + var con gc.Node gc.Convconst(&con, gc.Types[gc.TUINT32], &f.Val) + var r1 gc.Node regalloc(&r1, con.Type, t) gins(arm.AMOVW, &con, &r1) gmove(&r1, t) @@ -495,8 +476,11 @@ gc.TUINT64<<16 | gc.TINT32, gc.TINT64<<16 | gc.TUINT32, gc.TUINT64<<16 | gc.TUINT32: + var flo gc.Node + var fhi gc.Node split64(f, &flo, &fhi) + var r1 gc.Node regalloc(&r1, t.Type, nil) gins(arm.AMOVW, &flo, &r1) gins(arm.AMOVW, &r1, t) @@ -508,10 +492,16 @@ gc.TINT64<<16 | gc.TUINT64, gc.TUINT64<<16 | gc.TINT64, gc.TUINT64<<16 | gc.TUINT64: + var fhi gc.Node + var flo gc.Node split64(f, &flo, &fhi) + var tlo gc.Node + var thi gc.Node split64(t, &tlo, &thi) + var r1 gc.Node regalloc(&r1, flo.Type, nil) + var r2 gc.Node regalloc(&r2, fhi.Type, nil) gins(arm.AMOVW, &flo, &r1) gins(arm.AMOVW, &fhi, &r2) @@ -580,12 +570,16 @@ case gc.TINT32<<16 | gc.TINT64, // sign extend int32 gc.TINT32<<16 | gc.TUINT64: + var tlo gc.Node + var thi gc.Node split64(t, &tlo, &thi) + var r1 gc.Node regalloc(&r1, tlo.Type, nil) + var r2 gc.Node regalloc(&r2, thi.Type, nil) gmove(f, &r1) - p1 = gins(arm.AMOVW, &r1, &r2) + p1 := gins(arm.AMOVW, &r1, &r2) p1.From.Type = obj.TYPE_SHIFT p1.From.Offset = 2<<5 | 31<<7 | int64(r1.Val.U.Reg)&15 // r1->31 p1.From.Reg = 0 @@ -601,9 +595,12 @@ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32 gc.TUINT32<<16 | gc.TUINT64: + var thi gc.Node + var tlo gc.Node split64(t, &tlo, &thi) gmove(f, &tlo) + var r1 gc.Node regalloc(&r1, thi.Type, nil) gins(arm.AMOVW, ncon(0), &r1) gins(arm.AMOVW, &r1, &thi) @@ -630,15 +627,15 @@ gc.TFLOAT64<<16 | gc.TUINT16, gc.TFLOAT64<<16 | gc.TINT32, gc.TFLOAT64<<16 | gc.TUINT32: - fa = arm.AMOVF + fa := arm.AMOVF - a = arm.AMOVFW + a := arm.AMOVFW if ft == gc.TFLOAT64 { fa = arm.AMOVD a = arm.AMOVDW } - ta = arm.AMOVW + ta := arm.AMOVW switch tt { case gc.TINT8: ta = arm.AMOVBS @@ -653,10 +650,12 @@ ta = arm.AMOVHU } + var r1 gc.Node regalloc(&r1, gc.Types[ft], f) + var r2 gc.Node regalloc(&r2, gc.Types[tt], t) - gins(fa, f, &r1) // load to fpu - p1 = gins(a, &r1, &r1) // convert to w + gins(fa, f, &r1) // load to fpu + p1 := gins(a, &r1, &r1) // convert to w switch tt { case gc.TUINT8, gc.TUINT16, @@ -685,7 +684,7 @@ gc.TUINT16<<16 | gc.TFLOAT64, gc.TINT32<<16 | gc.TFLOAT64, gc.TUINT32<<16 | gc.TFLOAT64: - fa = arm.AMOVW + fa := arm.AMOVW switch ft { case gc.TINT8: @@ -701,18 +700,20 @@ fa = arm.AMOVHU } - a = arm.AMOVWF - ta = arm.AMOVF + a := arm.AMOVWF + ta := arm.AMOVF if tt == gc.TFLOAT64 { a = arm.AMOVWD ta = arm.AMOVD } + var r1 gc.Node regalloc(&r1, gc.Types[ft], f) + var r2 gc.Node regalloc(&r2, gc.Types[tt], t) gins(fa, f, &r1) // load to cpu gins(arm.AMOVW, &r1, &r2) // copy to fpu - p1 = gins(a, &r2, &r2) // convert + p1 := gins(a, &r2, &r2) // convert switch ft { case gc.TUINT8, gc.TUINT16, @@ -740,6 +741,7 @@ a = arm.AMOVD case gc.TFLOAT32<<16 | gc.TFLOAT64: + var r1 gc.Node regalloc(&r1, gc.Types[gc.TFLOAT64], t) gins(arm.AMOVF, f, &r1) gins(arm.AMOVFD, &r1, &r1) @@ -748,6 +750,7 @@ return case gc.TFLOAT64<<16 | gc.TFLOAT32: + var r1 gc.Node regalloc(&r1, gc.Types[gc.TFLOAT64], t) gins(arm.AMOVD, f, &r1) gins(arm.AMOVDF, &r1, &r1) @@ -816,13 +819,9 @@ * as f, t */ func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog { - var p *obj.Prog - var af obj.Addr // Node nod; // int32 v; - var at obj.Addr - if f != nil && f.Op == gc.OINDEX { gc.Fatal("gins OINDEX not implemented") } @@ -843,16 +842,16 @@ // constnode.vconst = v; // idx.reg = nod.reg; // regfree(&nod); - af = obj.Addr{} + af := obj.Addr{} - at = obj.Addr{} + at := obj.Addr{} if f != nil { gc.Naddr(f, &af, 1) } if t != nil { gc.Naddr(t, &at, 1) } - p = gc.Prog(as) + p := gc.Prog(as) if f != nil { p.From = af } @@ -888,13 +887,11 @@ TODO(kaib): one of the args can actually be a small constant. relax the constraint and fix call sites. */ func gcmp(as int, lhs *gc.Node, rhs *gc.Node) *obj.Prog { - var p *obj.Prog - if lhs.Op != gc.OREGISTER { gc.Fatal("bad operands to gcmp: %v %v", gc.Oconv(int(lhs.Op), 0), gc.Oconv(int(rhs.Op), 0)) } - p = gins(as, rhs, nil) + p := gins(as, rhs, nil) raddr(lhs, p) return p } @@ -903,15 +900,13 @@ * arm encodes a shift by 32 as 0, thus asking for 0 shift is illegal. */ func gshift(as int, lhs *gc.Node, stype int32, sval int32, rhs *gc.Node) *obj.Prog { - var p *obj.Prog - if sval <= 0 || sval > 32 { gc.Fatal("bad shift value: %d", sval) } sval = sval & 0x1f - p = gins(as, nil, rhs) + p := gins(as, nil, rhs) p.From.Type = obj.TYPE_SHIFT p.From.Offset = int64(stype) | int64(sval)<<7 | int64(lhs.Val.U.Reg)&15 return p @@ -920,8 +915,7 @@ /* generate a register shift */ func gregshift(as int, lhs *gc.Node, stype int32, reg *gc.Node, rhs *gc.Node) *obj.Prog { - var p *obj.Prog - p = gins(as, nil, rhs) + p := gins(as, nil, rhs) p.From.Type = obj.TYPE_SHIFT p.From.Offset = int64(stype) | (int64(reg.Val.U.Reg)&15)<<8 | 1<<4 | int64(lhs.Val.U.Reg)&15 return p @@ -931,13 +925,11 @@ * return Axxx for Oxxx on type t. */ func optoas(op int, t *gc.Type) int { - var a int - if t == nil { gc.Fatal("optoas: t is nil") } - a = obj.AXXX + a := obj.AXXX switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) { default: gc.Fatal("optoas: no entry %v-%v etype %v simtype %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0), gc.Tconv(gc.Types[t.Etype], 0), gc.Tconv(gc.Types[gc.Simtype[t.Etype]], 0)) @@ -1246,15 +1238,13 @@ } func dotaddable(n *gc.Node, n1 *gc.Node) bool { - var o int - var oary [10]int64 - var nn *gc.Node - if n.Op != gc.ODOT { return false } - o = gc.Dotoffset(n, oary[:], &nn) + var oary [10]int64 + var nn *gc.Node + o := gc.Dotoffset(n, oary[:], &nn) if nn != nil && nn.Addable != 0 && o == 1 && oary[0] >= 0 { *n1 = *nn n1.Type = n.Type @@ -1277,35 +1267,24 @@ * to release the register used for a. */ func sudoaddable(as int, n *gc.Node, a *obj.Addr, w *int) bool { - var o int - var i int - var oary [10]int64 - var v int64 - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var n4 gc.Node - var nn *gc.Node - var l *gc.Node - var r *gc.Node - var reg *gc.Node - var reg1 *gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var t *gc.Type - if n.Type == nil { return false } *a = obj.Addr{} + var oary [10]int64 + var nn *gc.Node + var reg *gc.Node + var n1 gc.Node + var reg1 *gc.Node + var o int switch n.Op { case gc.OLITERAL: if !gc.Isconst(n, gc.CTINT) { break } - v = gc.Mpgetfix(n.Val.U.Xval) + v := gc.Mpgetfix(n.Val.U.Xval) if v >= 32000 || v <= -32000 { break } @@ -1315,25 +1294,13 @@ gc.ODOTPTR: cleani += 2 reg = &clean[cleani-1] - reg1 = &clean[cleani-2] + reg1 := &clean[cleani-2] reg.Op = gc.OEMPTY reg1.Op = gc.OEMPTY goto odot case gc.OINDEX: return false - - // disabled: OINDEX case is now covered by agenr - // for a more suitable register allocation pattern. - if n.Left.Type.Etype == gc.TSTRING { - return false - } - cleani += 2 - reg = &clean[cleani-1] - reg1 = &clean[cleani-2] - reg.Op = gc.OEMPTY - reg1.Op = gc.OEMPTY - goto oindex } return false @@ -1374,7 +1341,7 @@ if nn.Addable != 0 && o == 1 && oary[0] >= 0 { // directly addressable set of DOTs - n1 = *nn + n1 := *nn n1.Type = n.Type n1.Xoffset += oary[0] @@ -1394,7 +1361,7 @@ n1.Xoffset = -(oary[0] + 1) } - for i = 1; i < o; i++ { + for i := 1; i < o; i++ { if oary[i] >= 0 { gc.Fatal("can't happen") } @@ -1409,187 +1376,6 @@ gc.Naddr(&n1, a, 1) goto yes -oindex: - l = n.Left - r = n.Right - if l.Ullman >= gc.UINF && r.Ullman >= gc.UINF { - goto no - } - - // set o to type of array - o = 0 - - if gc.Isptr[l.Type.Etype] != 0 { - o += OPtrto - if l.Type.Type.Etype != gc.TARRAY { - gc.Fatal("not ptr ary") - } - if l.Type.Type.Bound < 0 { - o += ODynam - } - } else { - if l.Type.Etype != gc.TARRAY { - gc.Fatal("not ary") - } - if l.Type.Bound < 0 { - o += ODynam - } - } - - *w = int(n.Type.Width) - if gc.Isconst(r, gc.CTINT) { - goto oindex_const - } - - switch *w { - default: - goto no - - case 1, - 2, - 4, - 8: - break - } - - // load the array (reg) - if l.Ullman > r.Ullman { - regalloc(reg, gc.Types[gc.Tptr], nil) - if o&OPtrto != 0 { - cgen(l, reg) - gc.Cgen_checknil(reg) - } else { - agen(l, reg) - } - } - - // load the index (reg1) - t = gc.Types[gc.TUINT32] - - if gc.Issigned[r.Type.Etype] != 0 { - t = gc.Types[gc.TINT32] - } - regalloc(reg1, t, nil) - regalloc(&n3, gc.Types[gc.TINT32], reg1) - p2 = cgenindex(r, &n3, gc.Debug['B'] != 0 || n.Bounded) - gmove(&n3, reg1) - regfree(&n3) - - // load the array (reg) - if l.Ullman <= r.Ullman { - regalloc(reg, gc.Types[gc.Tptr], nil) - if o&OPtrto != 0 { - cgen(l, reg) - gc.Cgen_checknil(reg) - } else { - agen(l, reg) - } - } - - // check bounds - if gc.Debug['B'] == 0 { - if o&ODynam != 0 { - n2 = *reg - n2.Op = gc.OINDREG - n2.Type = gc.Types[gc.Tptr] - n2.Xoffset = int64(gc.Array_nel) - } else { - if o&OPtrto != 0 { - gc.Nodconst(&n2, gc.Types[gc.TUINT32], l.Type.Type.Bound) - } else { - gc.Nodconst(&n2, gc.Types[gc.TUINT32], l.Type.Bound) - } - } - - regalloc(&n3, n2.Type, nil) - cgen(&n2, &n3) - gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), reg1, &n3) - regfree(&n3) - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) - if p2 != nil { - gc.Patch(p2, gc.Pc) - } - ginscall(gc.Panicindex, 0) - gc.Patch(p1, gc.Pc) - } - - if o&ODynam != 0 { - n2 = *reg - n2.Op = gc.OINDREG - n2.Type = gc.Types[gc.Tptr] - n2.Xoffset = int64(gc.Array_array) - gmove(&n2, reg) - } - - switch *w { - case 1: - gins(arm.AADD, reg1, reg) - - case 2: - gshift(arm.AADD, reg1, arm.SHIFT_LL, 1, reg) - - case 4: - gshift(arm.AADD, reg1, arm.SHIFT_LL, 2, reg) - - case 8: - gshift(arm.AADD, reg1, arm.SHIFT_LL, 3, reg) - } - - gc.Naddr(reg1, a, 1) - a.Type = obj.TYPE_MEM - a.Reg = reg.Val.U.Reg - a.Offset = 0 - goto yes - - // index is constant - // can check statically and - // can multiply by width statically - -oindex_const: - regalloc(reg, gc.Types[gc.Tptr], nil) - - if o&OPtrto != 0 { - cgen(l, reg) - gc.Cgen_checknil(reg) - } else { - agen(l, reg) - } - - v = gc.Mpgetfix(r.Val.U.Xval) - if o&ODynam != 0 { - if gc.Debug['B'] == 0 && !n.Bounded { - n1 = *reg - n1.Op = gc.OINDREG - n1.Type = gc.Types[gc.Tptr] - n1.Xoffset = int64(gc.Array_nel) - gc.Nodconst(&n2, gc.Types[gc.TUINT32], v) - regalloc(&n3, gc.Types[gc.TUINT32], nil) - cgen(&n2, &n3) - regalloc(&n4, n1.Type, nil) - cgen(&n1, &n4) - gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n4, &n3) - regfree(&n4) - regfree(&n3) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1) - ginscall(gc.Panicindex, 0) - gc.Patch(p1, gc.Pc) - } - - n1 = *reg - n1.Op = gc.OINDREG - n1.Type = gc.Types[gc.Tptr] - n1.Xoffset = int64(gc.Array_array) - gmove(&n1, reg) - } - - n2 = *reg - n2.Op = gc.OINDREG - n2.Xoffset = v * int64(*w) - a.Type = obj.TYPE_NONE - a.Name = obj.NAME_NONE - gc.Naddr(&n2, a, 1) - goto yes - yes: return true
diff --git a/src/cmd/5g/peep.go b/src/cmd/5g/peep.go index 2fbb1e5..e28ec02 100644 --- a/src/cmd/5g/peep.go +++ b/src/cmd/5g/peep.go
@@ -41,17 +41,15 @@ // UNUSED func peep(firstp *obj.Prog) { - var r *gc.Flow - var g *gc.Graph - var p *obj.Prog - var t int - - g = gc.Flowstart(firstp, nil) + g := (*gc.Graph)(gc.Flowstart(firstp, nil)) if g == nil { return } gactive = 0 + var r *gc.Flow + var p *obj.Prog + var t int loop1: if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { gc.Dumpit("loop1", g.Start, 0) @@ -121,7 +119,7 @@ goto loop1 } - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { /* @@ -141,7 +139,7 @@ } } - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { case arm.AMOVW, @@ -250,22 +248,17 @@ * will be eliminated by copy propagation. */ func subprop(r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - var r *gc.Flow - var t int - var info gc.ProgInfo - - p = r0.Prog - v1 = &p.From + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) if !regtyp(v1) { return false } - v2 = &p.To + v2 := (*obj.Addr)(&p.To) if !regtyp(v2) { return false } + var r *gc.Flow + var info gc.ProgInfo for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) { if gc.Uniqs(r) == nil { break @@ -332,7 +325,7 @@ } } - t = int(v1.Reg) + t := int(int(v1.Reg)) v1.Reg = v2.Reg v2.Reg = int16(t) if gc.Debug['P'] != 0 { @@ -354,13 +347,9 @@ * set v2 return success */ func copyprop(g *gc.Graph, r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - - p = r0.Prog - v1 = &p.From - v2 = &p.To + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) + v2 := (*obj.Addr)(&p.To) if copyas(v1, v2) { return true } @@ -369,9 +358,6 @@ } func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) bool { - var t int - var p *obj.Prog - if uint32(r.Active) == gactive { if gc.Debug['P'] != 0 { fmt.Printf("act set; return 1\n") @@ -383,6 +369,8 @@ if gc.Debug['P'] != 0 { fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f) } + var t int + var p *obj.Prog for ; r != nil; r = r.S1 { p = r.Prog if gc.Debug['P'] != 0 { @@ -473,11 +461,10 @@ * The v1->v2 should be eliminated by copy propagation. */ func constprop(c1 *obj.Addr, v1 *obj.Addr, r *gc.Flow) { - var p *obj.Prog - if gc.Debug['P'] != 0 { fmt.Printf("constprop %v->%v\n", gc.Ctxt.Dconv(c1), gc.Ctxt.Dconv(v1)) } + var p *obj.Prog for ; r != nil; r = r.S1 { p = r.Prog if gc.Debug['P'] != 0 { @@ -527,17 +514,13 @@ * MOVBS above can be a MOVBS, MOVBU, MOVHS or MOVHU. */ func shortprop(r *gc.Flow) bool { - var p *obj.Prog - var p1 *obj.Prog - var r1 *gc.Flow - - p = r.Prog - r1 = findpre(r, &p.From) + p := (*obj.Prog)(r.Prog) + r1 := (*gc.Flow)(findpre(r, &p.From)) if r1 == nil { return false } - p1 = r1.Prog + p1 := (*obj.Prog)(r1.Prog) if p1.As == p.As { // Two consecutive extensions. goto gotit @@ -583,15 +566,7 @@ * .. */ func shiftprop(r *gc.Flow) bool { - var r1 *gc.Flow - var p *obj.Prog - var p1 *obj.Prog - var p2 *obj.Prog - var n int - var o int - var a obj.Addr - - p = r.Prog + p := (*obj.Prog)(r.Prog) if p.To.Type != obj.TYPE_REG { if gc.Debug['P'] != 0 { fmt.Printf("\tBOTCH: result not reg; FAILURE\n") @@ -599,8 +574,8 @@ return false } - n = int(p.To.Reg) - a = obj.Addr{} + n := int(int(p.To.Reg)) + a := obj.Addr(obj.Addr{}) if p.Reg != 0 && p.Reg != p.To.Reg { a.Type = obj.TYPE_REG a.Reg = p.Reg @@ -609,7 +584,8 @@ if gc.Debug['P'] != 0 { fmt.Printf("shiftprop\n%v", p) } - r1 = r + r1 := (*gc.Flow)(r) + var p1 *obj.Prog for { /* find first use of shift result; abort if shift operands or result are changed */ r1 = gc.Uniqs(r1) @@ -736,9 +712,10 @@ } /* check whether shift result is used subsequently */ - p2 = p1 + p2 := (*obj.Prog)(p1) if int(p1.To.Reg) != n { + var p1 *obj.Prog for { r1 = gc.Uniqs(r1) if r1 == nil { @@ -773,7 +750,7 @@ /* make the substitution */ p2.From.Reg = 0 - o = int(p.Reg) + o := int(int(p.Reg)) if o == 0 { o = int(p.To.Reg) } @@ -870,14 +847,11 @@ } func nochange(r *gc.Flow, r2 *gc.Flow, p *obj.Prog) bool { - var a [3]obj.Addr - var i int - var n int - if r == r2 { return true } - n = 0 + n := int(0) + var a [3]obj.Addr if p.Reg != 0 && p.Reg != p.To.Reg { a[n].Type = obj.TYPE_REG a[n].Reg = p.Reg @@ -900,6 +874,7 @@ if n == 0 { return true } + var i int for ; r != nil && r != r2; r = gc.Uniqs(r) { p = r.Prog for i = 0; i < n; i++ { @@ -939,9 +914,7 @@ } func finduse(g *gc.Graph, r *gc.Flow, v *obj.Addr) bool { - var r1 *gc.Flow - - for r1 = g.Start; r1 != nil; r1 = r1.Link { + for r1 := (*gc.Flow)(g.Start); r1 != nil; r1 = r1.Link { r1.Active = 0 } return findu1(r, v) @@ -961,19 +934,12 @@ * MOVBU R0<<0(R1),R0 */ func xtramodes(g *gc.Graph, r *gc.Flow, a *obj.Addr) bool { - var r1 *gc.Flow - var r2 *gc.Flow - var r3 *gc.Flow - var p *obj.Prog - var p1 *obj.Prog - var v obj.Addr - - p = r.Prog - v = *a + p := (*obj.Prog)(r.Prog) + v := obj.Addr(*a) v.Type = obj.TYPE_REG - r1 = findpre(r, &v) + r1 := (*gc.Flow)(findpre(r, &v)) if r1 != nil { - p1 = r1.Prog + p1 := r1.Prog if p1.To.Type == obj.TYPE_REG && p1.To.Reg == v.Reg { switch p1.As { case arm.AADD: @@ -1030,13 +996,14 @@ case arm.AMOVW: if p1.From.Type == obj.TYPE_REG { - r2 = findinc(r1, r, &p1.From) + r2 := (*gc.Flow)(findinc(r1, r, &p1.From)) if r2 != nil { + var r3 *gc.Flow for r3 = gc.Uniqs(r2); r3.Prog.As == obj.ANOP; r3 = gc.Uniqs(r3) { } if r3 == r { /* post-indexing */ - p1 = r2.Prog + p1 := r2.Prog a.Reg = p1.To.Reg a.Offset = p1.From.Offset @@ -1054,10 +1021,10 @@ } if a != &p.From || a.Reg != p.To.Reg { - r1 = findinc(r, nil, &v) + r1 := (*gc.Flow)(findinc(r, nil, &v)) if r1 != nil { /* post-indexing */ - p1 = r1.Prog + p1 := r1.Prog a.Offset = p1.From.Offset p.Scond |= arm.C_PBIT @@ -1775,19 +1742,17 @@ } func applypred(rstart *gc.Flow, j *Joininfo, cond int, branch int) { - var pred int - var r *gc.Flow - if j.len == 0 { return } + var pred int if cond == Truecond { pred = predinfo[rstart.Prog.As-arm.ABEQ].scond } else { pred = predinfo[rstart.Prog.As-arm.ABEQ].notscond } - for r = j.start; ; r = successor(r) { + for r := (*gc.Flow)(j.start); ; r = successor(r) { if r.Prog.As == arm.AB { if r != j.last || branch == Delbranch { excise(r) @@ -1813,13 +1778,12 @@ } func predicate(g *gc.Graph) { - var r *gc.Flow var t1 int var t2 int var j1 Joininfo var j2 Joininfo - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { if isbranch(r.Prog) { t1 = joinsplit(r.S1, &j1) t2 = joinsplit(r.S2, &j2) @@ -1861,8 +1825,6 @@ } func excise(r *gc.Flow) { - var p *obj.Prog - - p = r.Prog + p := (*obj.Prog)(r.Prog) obj.Nopout(p) }
diff --git a/src/cmd/6g/cgen.go b/src/cmd/6g/cgen.go index 36fa62c..58deffa 100644 --- a/src/cmd/6g/cgen.go +++ b/src/cmd/6g/cgen.go
@@ -24,23 +24,16 @@ * simplifies and calls gmove. */ func cgen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var a int - var f int - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var addr obj.Addr - if gc.Debug['g'] != 0 { gc.Dump("\ncgen-n", n) gc.Dump("cgen-res", res) } + var nl *gc.Node + var n1 gc.Node + var nr *gc.Node + var n2 gc.Node + var a int if n == nil || n.Type == nil { goto ret } @@ -60,6 +53,7 @@ gc.OSLICE3, gc.OSLICE3ARR: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) cgen(&n1, res) @@ -70,6 +64,7 @@ case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) cgen(&n1, res) @@ -84,6 +79,7 @@ gc.Fatal("cgen: this is going to misscompile") } if res.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) @@ -101,6 +97,7 @@ if res.Addable == 0 { if n.Ullman > res.Ullman { + var n1 gc.Node regalloc(&n1, n.Type, res) cgen(n, &n1) if n1.Ullman > res.Ullman { @@ -114,6 +111,7 @@ goto ret } + var f int if res.Ullman >= gc.UINF { goto gen } @@ -135,9 +133,12 @@ } if gc.Iscomplex[n.Type.Etype] == 0 { - a = optoas(gc.OAS, res.Type) + a := optoas(gc.OAS, res.Type) + var addr obj.Addr if sudoaddable(a, res, &addr) { + var p1 *obj.Prog if f != 0 { + var n2 gc.Node regalloc(&n2, res.Type, nil) cgen(n, &n2) p1 = gins(a, &n2, nil) @@ -155,6 +156,7 @@ } gen: + var n1 gc.Node igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) @@ -195,9 +197,10 @@ if nl != nil && nl.Ullman >= gc.UINF { if nr != nil && nr.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) - n2 = *n + n2 := *n n2.Left = &n1 cgen(&n2, res) goto ret @@ -205,14 +208,16 @@ } if gc.Iscomplex[n.Type.Etype] == 0 { - a = optoas(gc.OAS, n.Type) + a := optoas(gc.OAS, n.Type) + var addr obj.Addr if sudoaddable(a, n, &addr) { if res.Op == gc.OREGISTER { - p1 = gins(a, nil, res) + p1 := gins(a, nil, res) p1.From = addr } else { + var n2 gc.Node regalloc(&n2, n.Type, nil) - p1 = gins(a, nil, &n2) + p1 := gins(a, nil, &n2) p1.From = addr gins(a, &n2, res) regfree(&n2) @@ -238,11 +243,11 @@ gc.OGE, gc.OGT, gc.ONOT: - p1 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Pc + p2 := gc.Pc gmove(gc.Nodbool(true), res) - p3 = gc.Gbranch(obj.AJMP, nil, 0) + p3 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n, true, 0, p2) gmove(gc.Nodbool(false), res) @@ -255,10 +260,12 @@ // unary case gc.OCOM: - a = optoas(gc.OXOR, nl.Type) + a := optoas(gc.OXOR, nl.Type) + var n1 gc.Node regalloc(&n1, nl.Type, nil) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, nl.Type, -1) gins(a, &n2, &n1) gmove(&n1, res) @@ -310,7 +317,9 @@ gc.OINDEX, gc.OIND, gc.ONAME: + var n1 gc.Node igen(nl, &n1, res) + var n2 gc.Node regalloc(&n2, n.Type, res) gmove(&n1, &n2) gmove(&n2, res) @@ -320,7 +329,9 @@ } } + var n1 gc.Node regalloc(&n1, nl.Type, res) + var n2 gc.Node regalloc(&n2, n.Type, &n1) cgen(nl, &n1) @@ -338,6 +349,7 @@ gc.OINDEX, gc.OIND, gc.ONAME: // PHEAP or PPARAMREF var + var n1 gc.Node igen(n, &n1, res) gmove(&n1, res) @@ -345,6 +357,7 @@ // interface table is first word of interface value case gc.OITAB: + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type @@ -354,14 +367,16 @@ // pointer is the first word of string or slice. case gc.OSPTR: if gc.Isconst(nl, gc.CTSTR) { + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) - p1 = gins(x86.ALEAQ, nil, &n1) + p1 := gins(x86.ALEAQ, nil, &n1) gc.Datastring(nl.Val.U.Sval.S, &p1.From) gmove(&n1, res) regfree(&n1) break } + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type gmove(&n1, res) @@ -371,13 +386,15 @@ if gc.Istype(nl.Type, gc.TMAP) || gc.Istype(nl.Type, gc.TCHAN) { // map and chan have len in the first int-sized word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) n2 = n1 n2.Op = gc.OINDREG @@ -394,6 +411,7 @@ if gc.Istype(nl.Type, gc.TSTRING) || gc.Isslice(nl.Type) { // both slice and string have len one pointer into the struct. // a zero pointer means zero length + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.Simtype[gc.TUINT]] @@ -409,13 +427,15 @@ if gc.Istype(nl.Type, gc.TCHAN) { // chan has cap in the second int-sized word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) n2 = n1 n2.Op = gc.OINDREG @@ -431,6 +451,7 @@ } if gc.Isslice(nl.Type) { + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.Simtype[gc.TUINT]] n1.Xoffset += int64(gc.Array_cap) @@ -470,11 +491,13 @@ } if nl.Ullman >= nr.Ullman { + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) cgen_div(int(n.Op), &n1, nr, res) regfree(&n1) } else { + var n2 gc.Node if !gc.Smallintconst(nr) { regalloc(&n2, nr.Type, res) cgen(nr, &n2) @@ -514,7 +537,7 @@ */ sbop: // symmetric binary if nl.Ullman < nr.Ullman || (nl.Ullman == nr.Ullman && (gc.Smallintconst(nl) || (nr.Op == gc.OLITERAL && !gc.Smallintconst(nr)))) { - r = nl + r := nl nl = nr nr = r } @@ -585,8 +608,6 @@ * The caller must call regfree(a). */ func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("cgenr-n", n) } @@ -609,6 +630,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) gmove(&n1, a) @@ -627,27 +649,12 @@ * The generated code checks that the result is not nil. */ func agenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var n5 gc.Node - var tmp gc.Node - var tmp2 gc.Node - var nlen gc.Node - var p1 *obj.Prog - var t *gc.Type - var w uint64 - var v uint64 - var freelen int - if gc.Debug['g'] != 0 { gc.Dump("\nagenr-n", n) } - nl = n.Left - nr = n.Right + nl := n.Left + nr := n.Right switch n.Op { case gc.ODOT, @@ -655,6 +662,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) agen(&n1, a) @@ -665,10 +673,14 @@ gc.Cgen_checknil(a) case gc.OINDEX: - freelen = 0 - w = uint64(n.Type.Width) + freelen := 0 + w := uint64(n.Type.Width) // Generate the non-addressable child first. + var n3 gc.Node + var nlen gc.Node + var tmp gc.Node + var n1 gc.Node if nr.Addable != 0 { goto irad } @@ -703,6 +715,7 @@ } else { if nl.Addable == 0 { // igen will need an addressable node. + var tmp2 gc.Node gc.Tempname(&tmp2, nl.Type) cgen(nl, &tmp2) @@ -737,9 +750,10 @@ if gc.Isconst(nl, gc.CTSTR) { gc.Fatal("constant string constant index") // front end should handle } - v = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + v := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { if gc.Debug['B'] == 0 && !n.Bounded { + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Simtype[gc.TUINT]], int64(v)) if gc.Smallintconst(nr) { gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), &nlen, &n2) @@ -750,7 +764,7 @@ regfree(&tmp) } - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1) ginscall(gc.Panicindex, -1) gc.Patch(p1, gc.Pc) } @@ -766,12 +780,13 @@ } // type of the index - t = gc.Types[gc.TUINT64] + t := gc.Types[gc.TUINT64] if gc.Issigned[n1.Type.Etype] != 0 { t = gc.Types[gc.TINT64] } + var n2 gc.Node regalloc(&n2, t, &n1) // i gmove(&n1, &n2) regfree(&n1) @@ -787,6 +802,7 @@ gc.Nodconst(&nlen, t, int64(len(nl.Val.U.Sval.S))) } else if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { if gc.Is64(nr.Type) { + var n5 gc.Node regalloc(&n5, t, nil) gmove(&nlen, &n5) regfree(&nlen) @@ -795,6 +811,7 @@ } else { gc.Nodconst(&nlen, t, nl.Type.Bound) if !gc.Smallintconst(&nlen) { + var n5 gc.Node regalloc(&n5, t, nil) gmove(&nlen, &n5) nlen = n5 @@ -803,14 +820,14 @@ } gins(optoas(gc.OCMP, t), &n2, &nlen) - p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLT, t), nil, +1) ginscall(gc.Panicindex, -1) gc.Patch(p1, gc.Pc) } if gc.Isconst(nl, gc.CTSTR) { regalloc(&n3, gc.Types[gc.Tptr], res) - p1 = gins(x86.ALEAQ, nil, &n3) + p1 := gins(x86.ALEAQ, nil, &n3) gc.Datastring(nl.Val.U.Sval.S, &p1.From) gins(x86.AADDQ, &n2, &n3) goto indexdone @@ -819,7 +836,7 @@ if w == 0 { } else // nothing to do if w == 1 || w == 2 || w == 4 || w == 8 { - p1 = gins(x86.ALEAQ, &n2, &n3) + p1 := gins(x86.ALEAQ, &n2, &n3) p1.From.Type = obj.TYPE_MEM p1.From.Scale = int8(w) p1.From.Index = p1.From.Reg @@ -848,10 +865,6 @@ * The generated code checks that the result is not nil. */ func agen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var n1 gc.Node - var n2 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("\nagen-res", res) gc.Dump("agen-r", n) @@ -865,15 +878,18 @@ n = n.Left } + var nl *gc.Node if gc.Isconst(n, gc.CTNIL) && n.Type.Width > int64(gc.Widthptr) { // Use of a nil interface or nil slice. // Create a temporary we can take the address of and read. // The generated code is just going to panic, so it need not // be terribly efficient. See issue 3670. + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Gvardef(&n1) clearfat(&n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) gins(x86.ALEAQ, &n1, &n2) gmove(&n2, res) @@ -882,6 +898,7 @@ } if n.Addable != 0 { + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) gins(x86.ALEAQ, n, &n1) gmove(&n1, res) @@ -912,16 +929,19 @@ gc.OSLICESTR, gc.OSLICE3, gc.OSLICE3ARR: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) agen(&n1, res) case gc.OEFACE: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) agen(&n1, res) case gc.OINDEX: + var n1 gc.Node agenr(n, &n1, res) gmove(&n1, res) regfree(&n1) @@ -975,10 +995,6 @@ * The generated code checks that the result is not *nil. */ func igen(n *gc.Node, a *gc.Node, res *gc.Node) { - var fp *gc.Type - var flist gc.Iter - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("\nigen-n", n) } @@ -1030,7 +1046,8 @@ cgen_callinter(n, nil, 0) } - fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) *a = gc.Node{} a.Op = gc.OINDREG a.Val.U.Reg = x86.REG_SP @@ -1050,6 +1067,7 @@ if gc.Isptr[n.Left.Type.Etype] == 0 { igen(n.Left, a, res) } else { + var n1 gc.Node igen(n.Left, &n1, res) gc.Cgen_checknil(&n1) regalloc(a, gc.Types[gc.Tptr], res) @@ -1078,19 +1096,6 @@ * if(n == true) goto to; */ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { - var et int - var a int - var nl *gc.Node - var nr *gc.Node - var l *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var tmp gc.Node - var ll *gc.NodeList - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['g'] != 0 { gc.Dump("\nbgen", n) } @@ -1103,6 +1108,12 @@ gc.Genlist(n.Ninit) } + var a int + var et int + var nl *gc.Node + var n1 gc.Node + var nr *gc.Node + var n2 gc.Node if n.Type == nil { gc.Convlit(&n, gc.Types[gc.TBOOL]) if n.Type == nil { @@ -1141,9 +1152,10 @@ if n.Addable == 0 { goto def } + var n1 gc.Node gc.Nodconst(&n1, n.Type, 0) gins(optoas(gc.OCMP, n.Type), n, &n1) - a = x86.AJNE + a := x86.AJNE if !true_ { a = x86.AJEQ } @@ -1153,8 +1165,8 @@ case gc.OANDAND, gc.OOROR: if (n.Op == gc.OANDAND) == true_ { - p1 = gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n.Left, !true_, -likely, p2) bgen(n.Right, !true_, -likely, p2) @@ -1199,15 +1211,15 @@ gc.OGT, gc.OLE, gc.OGE: - a = int(n.Op) + a := int(n.Op) if !true_ { if gc.Isfloat[nr.Type.Etype] != 0 { // brcom is not valid on floats when NaN is involved. - p1 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) - ll = n.Ninit // avoid re-genning ninit + ll := n.Ninit // avoid re-genning ninit n.Ninit = nil bgen(n, true, -likely, p2) n.Ninit = ll @@ -1223,7 +1235,7 @@ // make simplest on right if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) { a = gc.Brrev(a) - r = nl + r := nl nl = nr nr = r } @@ -1236,9 +1248,11 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Xoffset += int64(gc.Array_array) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp) gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to) @@ -1254,8 +1268,10 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp) gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to) @@ -1268,10 +1284,13 @@ break } + var n2 gc.Node + var n1 gc.Node if nr.Ullman >= gc.UINF { regalloc(&n1, nl.Type, nil) cgen(nl, &n1) + var tmp gc.Node gc.Tempname(&tmp, nl.Type) gmove(&n1, &tmp) regfree(&n1) @@ -1300,9 +1319,9 @@ // only < and <= work right with NaN; reverse if needed cmp: - l = &n1 + l := &n1 - r = &n2 + r := &n2 if gc.Isfloat[nl.Type.Etype] != 0 && (a == gc.OGT || a == gc.OGE) { l = &n2 r = &n1 @@ -1314,9 +1333,9 @@ if gc.Isfloat[nr.Type.Etype] != 0 && (n.Op == gc.OEQ || n.Op == gc.ONE) { if n.Op == gc.OEQ { // neither NE nor P - p1 = gc.Gbranch(x86.AJNE, nil, -likely) + p1 := gc.Gbranch(x86.AJNE, nil, -likely) - p2 = gc.Gbranch(x86.AJPS, nil, -likely) + p2 := gc.Gbranch(x86.AJPS, nil, -likely) gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to) gc.Patch(p1, gc.Pc) gc.Patch(p2, gc.Pc) @@ -1357,31 +1376,27 @@ * return n's offset from SP. */ func stkof(n *gc.Node) int64 { - var t *gc.Type - var flist gc.Iter - var off int64 - switch n.Op { case gc.OINDREG: return n.Xoffset case gc.ODOT: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } return off + n.Xoffset case gc.OINDEX: - t = n.Left.Type + t := n.Left.Type if !gc.Isfixedarray(t) { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } @@ -1393,11 +1408,12 @@ case gc.OCALLMETH, gc.OCALLINTER, gc.OCALLFUNC: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } + var flist gc.Iter t = gc.Structfirst(&flist, gc.Getoutarg(t)) if t != nil { return t.Width @@ -1414,20 +1430,6 @@ * memmove(&ns, &n, w); */ func sgen(n *gc.Node, ns *gc.Node, w int64) { - var nodl gc.Node - var nodr gc.Node - var nodsi gc.Node - var noddi gc.Node - var cx gc.Node - var oldcx gc.Node - var tmp gc.Node - var c int64 - var q int64 - var odst int64 - var osrc int64 - var l *gc.NodeList - var p *obj.Prog - if gc.Debug['g'] != 0 { fmt.Printf("\nsgen w=%d\n", w) gc.Dump("r", n) @@ -1445,7 +1447,7 @@ // If copying .args, that's all the results, so record definition sites // for them for the liveness analysis. if ns.Op == gc.ONAME && ns.Sym.Name == ".args" { - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { if l.N.Class == gc.PPARAMOUT { gc.Gvardef(l.N) } @@ -1459,6 +1461,7 @@ if w == 0 { // evaluate side effects only + var nodr gc.Node regalloc(&nodr, gc.Types[gc.Tptr], nil) agen(ns, &nodr) @@ -1468,15 +1471,16 @@ } // offset on the stack - osrc = stkof(n) + osrc := stkof(n) - odst = stkof(ns) + odst := stkof(ns) if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) { // osrc and odst both on stack, and at least one is in // an unknown position. Could generate code to test // for forward/backward copy, but instead just copy // to a temporary location first. + var tmp gc.Node gc.Tempname(&tmp, n.Type) sgen(n, &tmp, w) @@ -1484,9 +1488,13 @@ return } + var noddi gc.Node gc.Nodreg(&noddi, gc.Types[gc.Tptr], x86.REG_DI) + var nodsi gc.Node gc.Nodreg(&nodsi, gc.Types[gc.Tptr], x86.REG_SI) + var nodl gc.Node + var nodr gc.Node if n.Ullman >= ns.Ullman { agenr(n, &nodr, &nodsi) if ns.Op == gc.ONAME { @@ -1510,9 +1518,11 @@ regfree(&nodl) regfree(&nodr) - c = w % 8 // bytes - q = w / 8 // quads + c := w % 8 // bytes + q := w / 8 // quads + var oldcx gc.Node + var cx gc.Node savex(x86.REG_CX, &cx, &oldcx, nil, gc.Types[gc.TINT64]) // if we are copying forward on the stack and @@ -1552,7 +1562,7 @@ gins(x86.AREP, nil, nil) // repeat gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)+,*(DI)+ } else if q >= 4 { - p = gins(obj.ADUFFCOPY, nil, nil) + p := gins(obj.ADUFFCOPY, nil, nil) p.To.Type = obj.TYPE_ADDR p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg)) @@ -1643,23 +1653,16 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool { var nodl gc.Node var nodr gc.Node - var tmp gc.Node - var t *gc.Type - var freel int - var freer int - var fldcount int64 - var loffset int64 - var roffset int64 - freel = 0 - freer = 0 + freel := 0 + freer := 0 switch nl.Type.Etype { default: goto no case gc.TARRAY: - t = nl.Type + t := nl.Type // Slices are ok. if gc.Isslice(t) { @@ -1676,9 +1679,9 @@ // Small structs with non-fat types are ok. // Zero-sized structs are treated separately elsewhere. case gc.TSTRUCT: - fldcount = 0 + fldcount := int64(0) - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { if gc.Isfat(t.Type) { goto no } @@ -1714,6 +1717,7 @@ } } else { // When zeroing, prepare a register containing zero. + var tmp gc.Node gc.Nodconst(&tmp, nl.Type, 0) regalloc(&nodr, gc.Types[gc.TUINT], nil) @@ -1735,11 +1739,11 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - t = nl.Type + t := nl.Type if !gc.Isslice(t) { nodl.Type = t.Type nodr.Type = nodl.Type - for fldcount = 0; fldcount < t.Bound; fldcount++ { + for fldcount := int64(0); fldcount < t.Bound; fldcount++ { if nr == nil { gc.Clearslim(&nodl) } else { @@ -1842,8 +1846,8 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - loffset = nodl.Xoffset - roffset = nodr.Xoffset + loffset := nodl.Xoffset + roffset := nodr.Xoffset // funarg structs may not begin at offset zero. if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil { @@ -1853,7 +1857,7 @@ roffset -= nr.Type.Type.Width } - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { nodl.Xoffset = loffset + t.Width nodl.Type = t.Type
diff --git a/src/cmd/6g/ggen.go b/src/cmd/6g/ggen.go index be6ff21..d0c43d6 100644 --- a/src/cmd/6g/ggen.go +++ b/src/cmd/6g/ggen.go
@@ -11,32 +11,26 @@ import "cmd/internal/gc" func defframe(ptxt *obj.Prog) { - var frame uint32 - var ax uint32 - var p *obj.Prog - var hi int64 - var lo int64 - var l *gc.NodeList var n *gc.Node // fill in argument size, stack size ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr))) - frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) + frame := uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) ptxt.To.Offset = int64(frame) // insert code to zero ambiguously live variables // so that the garbage collector only sees initialized values // when it looks for pointers. - p = ptxt + p := ptxt - hi = 0 - lo = hi - ax = 0 + hi := int64(0) + lo := hi + ax := uint32(0) // iterate through declarations - they are sorted in decreasing xoffset order. - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { n = l.N if n.Needzero == 0 { continue @@ -69,10 +63,7 @@ } func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Prog { - var cnt int64 - var i int64 - - cnt = hi - lo + cnt := hi - lo if cnt == 0 { return p } @@ -92,7 +83,7 @@ } if cnt <= int64(4*gc.Widthreg) { - for i = 0; i < cnt; i += int64(gc.Widthreg) { + for i := int64(0); i < cnt; i += int64(gc.Widthreg) { p = appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo+i) } } else if !gc.Nacl && (cnt <= int64(128*gc.Widthreg)) { @@ -110,8 +101,7 @@ } func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog { - var q *obj.Prog - q = gc.Ctxt.NewProg() + q := gc.Ctxt.NewProg() gc.Clearp(q) q.As = int16(as) q.Lineno = p.Lineno @@ -136,14 +126,8 @@ * proc=3 normal call to C pointer (not Go func value) */ func ginscall(f *gc.Node, proc int) { - var p *obj.Prog - var reg gc.Node - var stk gc.Node - var r1 gc.Node - var extra int32 - if f.Type != nil { - extra = 0 + extra := int32(0) if proc == 1 || proc == 2 { extra = 2 * int32(gc.Widthptr) } @@ -167,12 +151,13 @@ // x86 NOP 0x90 is really XCHG AX, AX; use that description // because the NOP pseudo-instruction would be removed by // the linker. + var reg gc.Node gc.Nodreg(®, gc.Types[gc.TINT], x86.REG_AX) gins(x86.AXCHGL, ®, ®) } - p = gins(obj.ACALL, nil, f) + p := gins(obj.ACALL, nil, f) gc.Afunclit(&p.To, f) if proc == -1 || gc.Noreturn(p) { gins(obj.AUNDEF, nil, nil) @@ -180,7 +165,9 @@ break } + var reg gc.Node gc.Nodreg(®, gc.Types[gc.Tptr], x86.REG_DX) + var r1 gc.Node gc.Nodreg(&r1, gc.Types[gc.Tptr], x86.REG_BX) gmove(f, ®) reg.Op = gc.OINDREG @@ -193,12 +180,13 @@ case 1, // call in new proc (go) 2: // deferred call (defer) - stk = gc.Node{} + stk := gc.Node{} stk.Op = gc.OINDREG stk.Val.U.Reg = x86.REG_SP stk.Xoffset = 0 + var reg gc.Node if gc.Widthptr == 8 { // size of arguments at 0(SP) ginscon(x86.AMOVQ, int64(gc.Argsize(f.Type)), &stk) @@ -233,7 +221,7 @@ if proc == 2 { gc.Nodreg(®, gc.Types[gc.TINT32], x86.REG_AX) gins(x86.ATESTL, ®, ®) - p = gc.Gbranch(x86.AJEQ, nil, +1) + p := gc.Gbranch(x86.AJEQ, nil, +1) cgen_ret(nil) gc.Patch(p, gc.Pc) } @@ -245,20 +233,12 @@ * generate res = n. */ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) { - var i *gc.Node - var f *gc.Node - var tmpi gc.Node - var nodi gc.Node - var nodo gc.Node - var nodr gc.Node - var nodsp gc.Node - - i = n.Left + i := n.Left if i.Op != gc.ODOTINTER { gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0)) } - f = i.Right // field + f := i.Right // field if f.Op != gc.ONAME { gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0)) } @@ -266,6 +246,7 @@ i = i.Left // interface if i.Addable == 0 { + var tmpi gc.Node gc.Tempname(&tmpi, i.Type) cgen(i, &tmpi) i = &tmpi @@ -275,8 +256,10 @@ // i is now addable, prepare an indirected // register to hold its address. + var nodi gc.Node igen(i, &nodi, res) // REG = &inter + var nodsp gc.Node gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], x86.REG_SP) nodsp.Xoffset = 0 @@ -287,6 +270,7 @@ nodi.Xoffset += int64(gc.Widthptr) cgen(&nodi, &nodsp) // {0, 8(nacl), or 16}(SP) = 8(REG) -- i.data + var nodo gc.Node regalloc(&nodo, gc.Types[gc.Tptr], res) nodi.Type = gc.Types[gc.Tptr] @@ -294,6 +278,7 @@ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab regfree(&nodi) + var nodr gc.Node regalloc(&nodr, gc.Types[gc.Tptr], &nodo) if n.Left.Xoffset == gc.BADWIDTH { gc.Fatal("cgen_callinter: badwidth") @@ -324,14 +309,11 @@ * proc=2 defer call save away stack */ func cgen_call(n *gc.Node, proc int) { - var t *gc.Type - var nod gc.Node - var afun gc.Node - if n == nil { return } + var afun gc.Node if n.Left.Ullman >= gc.UINF { // if name involves a fn call // precompute the address of the fn @@ -341,10 +323,11 @@ } gc.Genlist(n.List) // assign the args - t = n.Left.Type + t := n.Left.Type // call tempname pointer if n.Left.Ullman >= gc.UINF { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, &afun) nod.Type = t @@ -355,6 +338,7 @@ // call pointer if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, n.Left) nod.Type = t @@ -375,22 +359,18 @@ * res = return value from call. */ func cgen_callret(n *gc.Node, res *gc.Node) { - var nod gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_callret: nil") } - nod = gc.Node{} + nod := gc.Node{} nod.Op = gc.OINDREG nod.Val.U.Reg = x86.REG_SP nod.Addable = 1 @@ -406,23 +386,18 @@ * res = &return value from call. */ func cgen_aret(n *gc.Node, res *gc.Node) { - var nod1 gc.Node - var nod2 gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_aret: nil") } - nod1 = gc.Node{} + nod1 := gc.Node{} nod1.Op = gc.OINDREG nod1.Val.U.Reg = x86.REG_SP nod1.Addable = 1 @@ -431,6 +406,7 @@ nod1.Type = fp.Type if res.Op != gc.OREGISTER { + var nod2 gc.Node regalloc(&nod2, gc.Types[gc.Tptr], res) gins(leaptr, &nod1, &nod2) gins(movptr, &nod2, res) @@ -445,8 +421,6 @@ * n->left is assignments to return values. */ func cgen_ret(n *gc.Node) { - var p *obj.Prog - if n != nil { gc.Genlist(n.List) // copy out args } @@ -454,7 +428,7 @@ ginscall(gc.Deferreturn, 0) } gc.Genlist(gc.Curfn.Exit) - p = gins(obj.ARET, nil, nil) + p := gins(obj.ARET, nil, nil) if n != nil && n.Op == gc.ORETJMP { p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN @@ -470,21 +444,6 @@ * according to op. */ func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var a int - var check int - var n3 gc.Node - var n4 gc.Node - var t *gc.Type - var t0 *gc.Type - var ax gc.Node - var dx gc.Node - var ax1 gc.Node - var n31 gc.Node - var oldax gc.Node - var olddx gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - // Have to be careful about handling // most negative int divided by -1 correctly. // The hardware will trap. @@ -493,10 +452,10 @@ // Easiest way to avoid for int8, int16: use int32. // For int32 and int64, use explicit test. // Could use int64 hw for int32. - t = nl.Type + t := nl.Type - t0 = t - check = 0 + t0 := t + check := 0 if gc.Issigned[t.Etype] != 0 { check = 1 if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) { @@ -515,9 +474,12 @@ check = 0 } - a = optoas(op, t) + a := optoas(op, t) + var n3 gc.Node regalloc(&n3, t0, nil) + var ax gc.Node + var oldax gc.Node if nl.Ullman >= nr.Ullman { savex(x86.REG_AX, &ax, &oldax, res, t0) cgen(nl, &ax) @@ -532,16 +494,17 @@ if t != t0 { // Convert - ax1 = ax + ax1 := ax - n31 = n3 + n31 := n3 ax.Type = t n3.Type = t gmove(&ax1, &ax) gmove(&n31, &n3) } - p2 = nil + p2 := (*obj.Prog)(nil) + var n4 gc.Node if gc.Nacl { // Native Client does not relay the divide-by-zero trap // to the executing program, so we must insert a check @@ -549,7 +512,7 @@ gc.Nodconst(&n4, t, 0) gins(optoas(gc.OCMP, t), &n3, &n4) - p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.ONE, t), nil, +1) if panicdiv == nil { panicdiv = gc.Sysfunc("panicdivide") } @@ -560,7 +523,7 @@ if check != 0 { gc.Nodconst(&n4, t, -1) gins(optoas(gc.OCMP, t), &n3, &n4) - p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.ONE, t), nil, +1) if op == gc.ODIV { // a / (-1) is -a. gins(optoas(gc.OMINUS, t), nil, &ax) @@ -577,6 +540,8 @@ gc.Patch(p1, gc.Pc) } + var olddx gc.Node + var dx gc.Node savex(x86.REG_DX, &dx, &olddx, res, t) if gc.Issigned[t.Etype] == 0 { gc.Nodconst(&n4, t, 0) @@ -609,9 +574,7 @@ * known to be dead. */ func savex(dr int, x *gc.Node, oldx *gc.Node, res *gc.Node, t *gc.Type) { - var r int - - r = int(reg[dr]) + r := int(reg[dr]) // save current ax and dx if they are live // and not the destination @@ -643,12 +606,7 @@ * res = nl % nr */ func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node var w int - var a int - var m gc.Magic if nr.Op != gc.OLITERAL { goto longdiv @@ -663,6 +621,7 @@ goto longdiv case gc.TUINT64: + var m gc.Magic m.W = w m.Ud = uint64(gc.Mpgetfix(nr.Val.U.Xval)) gc.Umagic(&m) @@ -673,8 +632,11 @@ goto longmod } + var n1 gc.Node cgenr(nl, &n1, nil) + var n2 gc.Node gc.Nodconst(&n2, nl.Type, int64(m.Um)) + var n3 gc.Node regalloc(&n3, nl.Type, res) cgen_hmul(&n1, &n2, &n3) @@ -697,6 +659,7 @@ return case gc.TINT64: + var m gc.Magic m.W = w m.Sd = gc.Mpgetfix(nr.Val.U.Xval) gc.Smagic(&m) @@ -707,8 +670,11 @@ goto longmod } + var n1 gc.Node cgenr(nl, &n1, res) + var n2 gc.Node gc.Nodconst(&n2, nl.Type, m.Sm) + var n3 gc.Node regalloc(&n3, nl.Type, nil) cgen_hmul(&n1, &n2, &n3) @@ -748,12 +714,14 @@ // mod using formula A%B = A-(A/B*B) but // we know that there is a fast algorithm for A/B longmod: + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) + var n2 gc.Node regalloc(&n2, nl.Type, nil) cgen_div(gc.ODIV, &n1, nr, &n2) - a = optoas(gc.OMUL, nl.Type) + a := optoas(gc.OMUL, nl.Type) if w == 8 { // use 2-operand 16-bit multiply // because there is no 2-operand 8-bit multiply @@ -761,6 +729,7 @@ } if !gc.Smallintconst(nr) { + var n3 gc.Node regalloc(&n3, nl.Type, nil) cgen(nr, &n3) gins(a, &n3, &n2) @@ -779,30 +748,26 @@ * res = (nl*nr) >> width */ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { - var t *gc.Type - var a int - var n1 gc.Node - var n2 gc.Node - var ax gc.Node - var dx gc.Node - var tmp *gc.Node - - t = nl.Type - a = optoas(gc.OHMUL, t) + t := nl.Type + a := optoas(gc.OHMUL, t) if nl.Ullman < nr.Ullman { - tmp = nl + tmp := nl nl = nr nr = tmp } + var n1 gc.Node cgenr(nl, &n1, res) + var n2 gc.Node cgenr(nr, &n2, nil) + var ax gc.Node gc.Nodreg(&ax, t, x86.REG_AX) gmove(&n1, &ax) gins(a, &n2, nil) regfree(&n2) regfree(&n1) + var dx gc.Node if t.Width == 1 { // byte multiply behaves differently. gc.Nodreg(&ax, t, x86.REG_AH) @@ -824,24 +789,21 @@ var n1 gc.Node var n2 gc.Node var n3 gc.Node - var n4 gc.Node - var n5 gc.Node var cx gc.Node var oldcx gc.Node - var a int var rcx int - var p1 *obj.Prog - var sc uint64 var tcount *gc.Type - a = optoas(op, nl.Type) + a := optoas(op, nl.Type) if nr.Op == gc.OLITERAL { + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) - sc = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + sc := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if sc >= uint64(nl.Type.Width*8) { // large shift gets 2 shifts by width-1 + var n3 gc.Node gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1) gins(a, &n3, &n1) @@ -855,12 +817,14 @@ } if nl.Ullman >= gc.UINF { + var n4 gc.Node gc.Tempname(&n4, nl.Type) cgen(nl, &n4) nl = &n4 } if nr.Ullman >= gc.UINF { + var n5 gc.Node gc.Tempname(&n5, nr.Type) cgen(nr, &n5) nr = &n5 @@ -912,7 +876,7 @@ if !bounded { gc.Nodconst(&n3, tcount, nl.Type.Width*8) gins(optoas(gc.OCMP, tcount), &n1, &n3) - p1 = gc.Gbranch(optoas(gc.OLT, tcount), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLT, tcount), nil, +1) if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 { gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1) gins(a, &n3, &n2) @@ -947,37 +911,33 @@ * we do a full-width multiplication and truncate afterwards. */ func cgen_bmul(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var n1b gc.Node - var n2b gc.Node - var tmp *gc.Node - var t *gc.Type - var a int - // largest ullman on left. if nl.Ullman < nr.Ullman { - tmp = nl + tmp := nl nl = nr nr = tmp } // generate operands in "8-bit" registers. + var n1b gc.Node regalloc(&n1b, nl.Type, res) cgen(nl, &n1b) + var n2b gc.Node regalloc(&n2b, nr.Type, nil) cgen(nr, &n2b) // perform full-width multiplication. - t = gc.Types[gc.TUINT64] + t := gc.Types[gc.TUINT64] if gc.Issigned[nl.Type.Etype] != 0 { t = gc.Types[gc.TINT64] } + var n1 gc.Node gc.Nodreg(&n1, t, int(n1b.Val.U.Reg)) + var n2 gc.Node gc.Nodreg(&n2, t, int(n2b.Val.U.Reg)) - a = optoas(op, t) + a := optoas(op, t) gins(a, &n2, &n1) // truncate. @@ -988,31 +948,20 @@ } func clearfat(nl *gc.Node) { - var w int64 - var c int64 - var q int64 - var n1 gc.Node - var oldn1 gc.Node - var ax gc.Node - var oldax gc.Node - var di gc.Node - var z gc.Node - var p *obj.Prog - /* clear a fat object */ if gc.Debug['g'] != 0 { gc.Dump("\nclearfat", nl) } - w = nl.Type.Width + w := nl.Type.Width // Avoid taking the address for simple enough types. if componentgen(nil, nl) { return } - c = w % 8 // bytes - q = w / 8 // quads + c := w % 8 // bytes + q := w / 8 // quads if q < 4 { // Write sequence of MOV 0, off(base) instead of using STOSQ. @@ -1021,9 +970,11 @@ // than the unrolled STOSQ loop. // NOTE: Must use agen, not igen, so that optimizer sees address // being taken. We are not writing on field boundaries. + var n1 gc.Node agenr(nl, &n1, nil) n1.Op = gc.OINDREG + var z gc.Node gc.Nodconst(&z, gc.Types[gc.TUINT64], 0) for { tmp14 := q @@ -1060,9 +1011,13 @@ return } + var oldn1 gc.Node + var n1 gc.Node savex(x86.REG_DI, &n1, &oldn1, nil, gc.Types[gc.Tptr]) agen(nl, &n1) + var ax gc.Node + var oldax gc.Node savex(x86.REG_AX, &ax, &oldax, nil, gc.Types[gc.Tptr]) gconreg(x86.AMOVL, 0, x86.REG_AX) @@ -1071,7 +1026,7 @@ gins(x86.AREP, nil, nil) // repeat gins(x86.ASTOSQ, nil, nil) // STOQ AL,*(DI)+ } else { - p = gins(obj.ADUFFZERO, nil, nil) + p := gins(obj.ADUFFZERO, nil, nil) p.To.Type = obj.TYPE_ADDR p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg)) @@ -1079,22 +1034,22 @@ p.To.Offset = 2 * (128 - q) } - z = ax - di = n1 + z := ax + di := n1 if w >= 8 && c >= 4 { di.Op = gc.OINDREG z.Type = gc.Types[gc.TINT64] di.Type = z.Type - p = gins(x86.AMOVQ, &z, &di) + p := gins(x86.AMOVQ, &z, &di) p.To.Scale = 1 p.To.Offset = c - 8 } else if c >= 4 { di.Op = gc.OINDREG z.Type = gc.Types[gc.TINT32] di.Type = z.Type - p = gins(x86.AMOVL, &z, &di) + gins(x86.AMOVL, &z, &di) if c > 4 { - p = gins(x86.AMOVL, &z, &di) + p := gins(x86.AMOVL, &z, &di) p.To.Scale = 1 p.To.Offset = c - 4 } @@ -1112,11 +1067,10 @@ // Called after regopt and peep have run. // Expand CHECKNIL pseudo-op into actual nil pointer check. func expandchecks(firstp *obj.Prog) { - var p *obj.Prog var p1 *obj.Prog var p2 *obj.Prog - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.As != obj.ACHECKNIL { continue }
diff --git a/src/cmd/6g/gsubr.go b/src/cmd/6g/gsubr.go index c440f8c..a8e47d3 100644 --- a/src/cmd/6g/gsubr.go +++ b/src/cmd/6g/gsubr.go
@@ -53,19 +53,17 @@ } func ginit() { - var i int - - for i = 0; i < len(reg); i++ { + for i := 0; i < len(reg); i++ { reg[i] = 1 } - for i = x86.REG_AX; i <= x86.REG_R15; i++ { + for i := x86.REG_AX; i <= x86.REG_R15; i++ { reg[i] = 0 } - for i = x86.REG_X0; i <= x86.REG_X15; i++ { + for i := x86.REG_X0; i <= x86.REG_X15; i++ { reg[i] = 0 } - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]++ } @@ -79,9 +77,7 @@ } func gclean() { - var i int - - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]-- } if gc.Nacl { @@ -91,12 +87,12 @@ reg[x86.REG_BP]-- } - for i = x86.REG_AX; i <= x86.REG_R15; i++ { + for i := x86.REG_AX; i <= x86.REG_R15; i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i)) } } - for i = x86.REG_X0; i <= x86.REG_X15; i++ { + for i := x86.REG_X0; i <= x86.REG_X15; i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i)) } @@ -104,10 +100,9 @@ } func anyregalloc() bool { - var i int var j int - for i = x86.REG_AX; i <= x86.REG_R15; i++ { + for i := x86.REG_AX; i <= x86.REG_R15; i++ { if reg[i] == 0 { goto ok } @@ -131,14 +126,12 @@ * caller must regfree(n). */ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) { - var i int - var et int - if t == nil { gc.Fatal("regalloc: t nil") } - et = int(gc.Simtype[t.Etype]) + et := int(gc.Simtype[t.Etype]) + var i int switch et { case gc.TINT8, gc.TUINT8, @@ -166,7 +159,7 @@ } gc.Flusherrors() - for i = 0; i+x86.REG_AX <= x86.REG_R15; i++ { + for i := 0; i+x86.REG_AX <= x86.REG_R15; i++ { fmt.Printf("%d %p\n", i, regpc[i]) } gc.Fatal("out of fixed registers") @@ -202,15 +195,13 @@ } func regfree(n *gc.Node) { - var i int - if n.Op == gc.ONAME { return } if n.Op != gc.OREGISTER && n.Op != gc.OINDREG { gc.Fatal("regfree: not a register") } - i = int(n.Val.U.Reg) + i := int(n.Val.U.Reg) if i == x86.REG_SP { return } @@ -252,7 +243,6 @@ */ func ginscon(as int, c int64, n2 *gc.Node) { var n1 gc.Node - var ntmp gc.Node switch as { case x86.AADDL, @@ -267,6 +257,7 @@ if as != x86.AMOVQ && (c < -(1<<31) || c >= 1<<31) { // cannot have 64-bit immediate in ADD, etc. // instead, MOV into register first. + var ntmp gc.Node regalloc(&ntmp, gc.Types[gc.TINT64], nil) gins(x86.AMOVQ, &n1, &ntmp) @@ -309,27 +300,13 @@ * hard part is conversions. */ func gmove(f *gc.Node, t *gc.Node) { - var a int - var ft int - var tt int - var cvt *gc.Type - var r1 gc.Node - var r2 gc.Node - var r3 gc.Node - var r4 gc.Node - var zero gc.Node - var one gc.Node - var con gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['M'] != 0 { fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, obj.FmtLong), gc.Nconv(t, obj.FmtLong)) } - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) + cvt := t.Type if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 { gc.Complexmove(f, t) @@ -337,12 +314,15 @@ } // cannot have two memory operands + var r1 gc.Node + var a int if gc.Ismem(f) && gc.Ismem(t) { goto hard } // convert constant to desired type if f.Op == gc.OLITERAL { + var con gc.Node gc.Convconst(&con, t.Type, &f.Val) f = &con ft = tt // so big switch will choose a simple mov @@ -550,21 +530,25 @@ // otherwise, subtract 2^63, convert, and add it back. case gc.TFLOAT32<<16 | gc.TUINT64, gc.TFLOAT64<<16 | gc.TUINT64: - a = x86.ACVTTSS2SQ + a := x86.ACVTTSS2SQ if ft == gc.TFLOAT64 { a = x86.ACVTTSD2SQ } bignodes() + var r1 gc.Node regalloc(&r1, gc.Types[ft], nil) + var r2 gc.Node regalloc(&r2, gc.Types[tt], t) + var r3 gc.Node regalloc(&r3, gc.Types[ft], nil) + var r4 gc.Node regalloc(&r4, gc.Types[tt], nil) gins(optoas(gc.OAS, f.Type), f, &r1) gins(optoas(gc.OCMP, f.Type), &bigf, &r1) - p1 = gc.Gbranch(optoas(gc.OLE, f.Type), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLE, f.Type), nil, +1) gins(a, &r1, &r2) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) gins(optoas(gc.OAS, f.Type), &bigf, &r3) gins(optoas(gc.OSUB, f.Type), &r3, &r1) @@ -624,22 +608,28 @@ // otherwise, halve (rounding to odd?), convert, and double. case gc.TUINT64<<16 | gc.TFLOAT32, gc.TUINT64<<16 | gc.TFLOAT64: - a = x86.ACVTSQ2SS + a := x86.ACVTSQ2SS if tt == gc.TFLOAT64 { a = x86.ACVTSQ2SD } + var zero gc.Node gc.Nodconst(&zero, gc.Types[gc.TUINT64], 0) + var one gc.Node gc.Nodconst(&one, gc.Types[gc.TUINT64], 1) + var r1 gc.Node regalloc(&r1, f.Type, f) + var r2 gc.Node regalloc(&r2, t.Type, t) + var r3 gc.Node regalloc(&r3, f.Type, nil) + var r4 gc.Node regalloc(&r4, f.Type, nil) gmove(f, &r1) gins(x86.ACMPQ, &r1, &zero) - p1 = gc.Gbranch(x86.AJLT, nil, +1) + p1 := gc.Gbranch(x86.AJLT, nil, +1) gins(a, &r1, &r2) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) gmove(&r1, &r3) gins(x86.ASHRQ, &one, &r3) @@ -717,13 +707,8 @@ * as f, t */ func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog { - var w int32 - var p *obj.Prog // Node nod; - var af obj.Addr - var at obj.Addr - // if(f != N && f->op == OINDEX) { // regalloc(&nod, ®node, Z); // v = constnode.vconst; @@ -758,15 +743,15 @@ } } - af = obj.Addr{} - at = obj.Addr{} + af := obj.Addr{} + at := obj.Addr{} if f != nil { gc.Naddr(f, &af, 1) } if t != nil { gc.Naddr(t, &at, 1) } - p = gc.Prog(as) + p := gc.Prog(as) if f != nil { p.From = af } @@ -777,7 +762,7 @@ fmt.Printf("%v\n", p) } - w = 0 + w := int32(0) switch as { case x86.AMOVB: w = 1 @@ -806,8 +791,6 @@ } func fixlargeoffset(n *gc.Node) { - var a gc.Node - if n == nil { return } @@ -819,7 +802,7 @@ } if n.Xoffset != int64(int32(n.Xoffset)) { // offset too large, add to register instead. - a = *n + a := *n a.Op = gc.OREGISTER a.Type = gc.Types[gc.Tptr] @@ -834,13 +817,11 @@ * return Axxx for Oxxx on type t. */ func optoas(op int, t *gc.Type) int { - var a int - if t == nil { gc.Fatal("optoas: t is nil") } - a = obj.AXXX + a := obj.AXXX switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) { default: gc.Fatal("optoas: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0)) @@ -1362,35 +1343,24 @@ * to release the register used for a. */ func sudoaddable(as int, n *gc.Node, a *obj.Addr) bool { - var o int - var i int - var oary [10]int64 - var v int64 - var w int64 - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var n4 gc.Node - var nn *gc.Node - var l *gc.Node - var r *gc.Node - var reg *gc.Node - var reg1 *gc.Node - var p1 *obj.Prog - var t *gc.Type - if n.Type == nil { return false } *a = obj.Addr{} + var o int + var n1 gc.Node + var oary [10]int64 + var nn *gc.Node + var reg *gc.Node + var reg1 *gc.Node switch n.Op { case gc.OLITERAL: if !gc.Isconst(n, gc.CTINT) { break } - v = gc.Mpgetfix(n.Val.U.Xval) + v := gc.Mpgetfix(n.Val.U.Xval) if v >= 32000 || v <= -32000 { break } @@ -1400,20 +1370,13 @@ gc.ODOTPTR: cleani += 2 reg = &clean[cleani-1] - reg1 = &clean[cleani-2] + reg1 := &clean[cleani-2] reg.Op = gc.OEMPTY reg1.Op = gc.OEMPTY goto odot case gc.OINDEX: return false - - // disabled: OINDEX case is now covered by agenr - // for a more suitable register allocation pattern. - if n.Left.Type.Etype == gc.TSTRING { - return false - } - goto oindex } return false @@ -1474,7 +1437,7 @@ if nn.Addable != 0 && o == 1 && oary[0] >= 0 { // directly addressable set of DOTs - n1 = *nn + n1 := *nn n1.Type = n.Type n1.Xoffset += oary[0] @@ -1494,7 +1457,7 @@ n1.Xoffset = -(oary[0] + 1) } - for i = 1; i < o; i++ { + for i := 1; i < o; i++ { if oary[i] >= 0 { gc.Fatal("can't happen") } @@ -1509,240 +1472,6 @@ gc.Naddr(&n1, a, 1) goto yes -oindex: - l = n.Left - r = n.Right - if l.Ullman >= gc.UINF && r.Ullman >= gc.UINF { - return false - } - - // set o to type of array - o = 0 - - if gc.Isptr[l.Type.Etype] != 0 { - gc.Fatal("ptr ary") - } - if l.Type.Etype != gc.TARRAY { - gc.Fatal("not ary") - } - if l.Type.Bound < 0 { - o |= ODynam - } - - w = n.Type.Width - if gc.Isconst(r, gc.CTINT) { - goto oindex_const - } - - switch w { - default: - return false - - case 1, - 2, - 4, - 8: - break - } - - cleani += 2 - reg = &clean[cleani-1] - reg1 = &clean[cleani-2] - reg.Op = gc.OEMPTY - reg1.Op = gc.OEMPTY - - // load the array (reg) - if l.Ullman > r.Ullman { - if xgen(l, reg, o) { - o |= OAddable - } - } - - // load the index (reg1) - t = gc.Types[gc.TUINT64] - - if gc.Issigned[r.Type.Etype] != 0 { - t = gc.Types[gc.TINT64] - } - regalloc(reg1, t, nil) - regalloc(&n3, r.Type, reg1) - cgen(r, &n3) - gmove(&n3, reg1) - regfree(&n3) - - // load the array (reg) - if l.Ullman <= r.Ullman { - if xgen(l, reg, o) { - o |= OAddable - } - } - - // check bounds - if gc.Debug['B'] == 0 && !n.Bounded { - // check bounds - n4.Op = gc.OXXX - - t = gc.Types[gc.Simtype[gc.TUINT]] - if o&ODynam != 0 { - if o&OAddable != 0 { - n2 = *l - n2.Xoffset += int64(gc.Array_nel) - n2.Type = gc.Types[gc.Simtype[gc.TUINT]] - } else { - n2 = *reg - n2.Xoffset = int64(gc.Array_nel) - n2.Op = gc.OINDREG - n2.Type = gc.Types[gc.Simtype[gc.TUINT]] - } - } else { - if gc.Is64(r.Type) { - t = gc.Types[gc.TUINT64] - } - gc.Nodconst(&n2, gc.Types[gc.TUINT64], l.Type.Bound) - } - - gins(optoas(gc.OCMP, t), reg1, &n2) - p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1) - if n4.Op != gc.OXXX { - regfree(&n4) - } - ginscall(gc.Panicindex, -1) - gc.Patch(p1, gc.Pc) - } - - if o&ODynam != 0 { - if o&OAddable != 0 { - n2 = *l - n2.Xoffset += int64(gc.Array_array) - n2.Type = gc.Types[gc.Tptr] - gmove(&n2, reg) - } else { - n2 = *reg - n2.Op = gc.OINDREG - n2.Xoffset = int64(gc.Array_array) - n2.Type = gc.Types[gc.Tptr] - gmove(&n2, reg) - } - } - - if o&OAddable != 0 { - gc.Naddr(reg1, a, 1) - a.Offset = 0 - a.Scale = int8(w) - a.Index = a.Reg - a.Type = obj.TYPE_MEM - a.Reg = reg.Val.U.Reg - } else { - gc.Naddr(reg1, a, 1) - a.Offset = 0 - a.Scale = int8(w) - a.Index = a.Reg - a.Type = obj.TYPE_MEM - a.Reg = reg.Val.U.Reg - } - - goto yes - - // index is constant - // can check statically and - // can multiply by width statically - -oindex_const: - v = gc.Mpgetfix(r.Val.U.Xval) - - if sudoaddable(as, l, a) { - goto oindex_const_sudo - } - - cleani += 2 - reg = &clean[cleani-1] - reg1 = &clean[cleani-2] - reg.Op = gc.OEMPTY - reg1.Op = gc.OEMPTY - - if o&ODynam != 0 { - regalloc(reg, gc.Types[gc.Tptr], nil) - agen(l, reg) - - if gc.Debug['B'] == 0 && !n.Bounded { - n1 = *reg - n1.Op = gc.OINDREG - n1.Type = gc.Types[gc.Tptr] - n1.Xoffset = int64(gc.Array_nel) - gc.Nodconst(&n2, gc.Types[gc.TUINT64], v) - gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1) - ginscall(gc.Panicindex, -1) - gc.Patch(p1, gc.Pc) - } - - n1 = *reg - n1.Op = gc.OINDREG - n1.Type = gc.Types[gc.Tptr] - n1.Xoffset = int64(gc.Array_array) - gmove(&n1, reg) - - n2 = *reg - n2.Op = gc.OINDREG - n2.Xoffset = v * w - fixlargeoffset(&n2) - a.Type = obj.TYPE_NONE - a.Index = obj.TYPE_NONE - gc.Naddr(&n2, a, 1) - goto yes - } - - igen(l, &n1, nil) - if n1.Op == gc.OINDREG { - *reg = n1 - reg.Op = gc.OREGISTER - } - - n1.Xoffset += v * w - fixlargeoffset(&n1) - a.Type = obj.TYPE_NONE - a.Index = obj.TYPE_NONE - gc.Naddr(&n1, a, 1) - goto yes - -oindex_const_sudo: - if o&ODynam == 0 { - // array indexed by a constant - a.Offset += v * w - - goto yes - } - - // slice indexed by a constant - if gc.Debug['B'] == 0 && !n.Bounded { - a.Offset += int64(gc.Array_nel) - gc.Nodconst(&n2, gc.Types[gc.TUINT64], v) - p1 = gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), nil, &n2) - p1.From = *a - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1) - ginscall(gc.Panicindex, -1) - gc.Patch(p1, gc.Pc) - a.Offset -= int64(gc.Array_nel) - } - - a.Offset += int64(gc.Array_array) - reg = &clean[cleani-1] - if reg.Op == gc.OEMPTY { - regalloc(reg, gc.Types[gc.Tptr], nil) - } - - p1 = gins(movptr, nil, reg) - p1.From = *a - - n2 = *reg - n2.Op = gc.OINDREG - n2.Xoffset = v * w - fixlargeoffset(&n2) - a.Type = obj.TYPE_NONE - a.Index = obj.TYPE_NONE - gc.Naddr(&n2, a, 1) - goto yes - yes: return true
diff --git a/src/cmd/6g/peep.go b/src/cmd/6g/peep.go index 9870ca5..ed582d7 100644 --- a/src/cmd/6g/peep.go +++ b/src/cmd/6g/peep.go
@@ -62,10 +62,9 @@ } func rnops(r *gc.Flow) *gc.Flow { - var p *obj.Prog - var r1 *gc.Flow - if r != nil { + var p *obj.Prog + var r1 *gc.Flow for { p = r.Prog if p.As != obj.ANOP || p.From.Type != obj.TYPE_NONE || p.To.Type != obj.TYPE_NONE { @@ -83,14 +82,7 @@ } func peep(firstp *obj.Prog) { - var r *gc.Flow - var r1 *gc.Flow - var g *gc.Graph - var p *obj.Prog - var p1 *obj.Prog - var t int - - g = gc.Flowstart(firstp, nil) + g := (*gc.Graph)(gc.Flowstart(firstp, nil)) if g == nil { return } @@ -103,7 +95,8 @@ // find MOV $con,R followed by // another MOV $con,R without // setting R in the interim - for r = g.Start; r != nil; r = r.Link { + var p *obj.Prog + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { case x86.ALEAL, @@ -130,6 +123,10 @@ } } + var r *gc.Flow + var r1 *gc.Flow + var p1 *obj.Prog + var t int loop1: if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { gc.Dumpit("loop1", g.Start, 0) @@ -266,7 +263,7 @@ // can be replaced by MOVAPD, which moves the pair of float64s // instead of just the lower one. We only use the lower one, but // the processor can do better if we do moves using both. - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog if p.As == x86.AMOVLQZX { if regtyp(&p.From) { @@ -290,7 +287,7 @@ // load pipelining // push any load from memory as early as possible // to give it time to complete before use. - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { case x86.AMOVB, @@ -309,13 +306,10 @@ func pushback(r0 *gc.Flow) { var r *gc.Flow - var b *gc.Flow - var p0 *obj.Prog var p *obj.Prog - var t obj.Prog - b = nil - p0 = r0.Prog + b := (*gc.Flow)(nil) + p0 := (*obj.Prog)(r0.Prog) for r = gc.Uniqp(r0); r != nil && gc.Uniqs(r) != nil; r = gc.Uniqp(r) { p = r.Prog if p.As != obj.ANOP { @@ -346,7 +340,7 @@ if gc.Debug['v'] != 0 { fmt.Printf("pushback\n") - for r = b; ; r = r.Link { + for r := (*gc.Flow)(b); ; r = r.Link { fmt.Printf("\t%v\n", r.Prog) if r == r0 { break @@ -354,7 +348,7 @@ } } - t = *r0.Prog + t := obj.Prog(*r0.Prog) for r = gc.Uniqp(r0); ; r = gc.Uniqp(r) { p0 = r.Link.Prog p = r.Prog @@ -376,7 +370,7 @@ if gc.Debug['v'] != 0 { fmt.Printf("\tafter\n") - for r = b; ; r = r.Link { + for r := (*gc.Flow)(b); ; r = r.Link { fmt.Printf("\t%v\n", r.Prog) if r == r0 { break @@ -386,9 +380,7 @@ } func excise(r *gc.Flow) { - var p *obj.Prog - - p = r.Prog + p := (*obj.Prog)(r.Prog) if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("%v ===delete===\n", p) } @@ -414,9 +406,8 @@ // seems unnecessary, and it makes the instructions longer. func elimshortmov(g *gc.Graph) { var p *obj.Prog - var r *gc.Flow - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog if regtyp(&p.To) { switch p.As { @@ -518,10 +509,9 @@ // is reg guaranteed to be truncated by a previous L instruction? func prevl(r0 *gc.Flow, reg int) bool { var p *obj.Prog - var r *gc.Flow var info gc.ProgInfo - for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) { + for r := (*gc.Flow)(gc.Uniqp(r0)); r != nil; r = gc.Uniqp(r) { p = r.Prog if p.To.Type == obj.TYPE_REG && int(p.To.Reg) == reg { proginfo(&info, p) @@ -552,18 +542,11 @@ * will be eliminated by copy propagation. */ func subprop(r0 *gc.Flow) bool { - var p *obj.Prog - var info gc.ProgInfo - var v1 *obj.Addr - var v2 *obj.Addr - var r *gc.Flow - var t int - if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("subprop %v\n", r0.Prog) } - p = r0.Prog - v1 = &p.From + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) if !regtyp(v1) { if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("\tnot regtype %v; return 0\n", gc.Ctxt.Dconv(v1)) @@ -571,7 +554,7 @@ return false } - v2 = &p.To + v2 := (*obj.Addr)(&p.To) if !regtyp(v2) { if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("\tnot regtype %v; return 0\n", gc.Ctxt.Dconv(v2)) @@ -579,6 +562,8 @@ return false } + var info gc.ProgInfo + var r *gc.Flow for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) { if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("\t? %v\n", r.Prog) @@ -652,7 +637,7 @@ } } - t = int(v1.Reg) + t := int(int(v1.Reg)) v1.Reg = v2.Reg v2.Reg = int16(t) if gc.Debug['P'] != 0 { @@ -674,16 +659,12 @@ * set v2 return success */ func copyprop(g *gc.Graph, r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("copyprop %v\n", r0.Prog) } - p = r0.Prog - v1 = &p.From - v2 = &p.To + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) + v2 := (*obj.Addr)(&p.To) if copyas(v1, v2) { return true } @@ -692,9 +673,6 @@ } func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) bool { - var t int - var p *obj.Prog - if uint32(r.Active) == gactive { if gc.Debug['P'] != 0 { fmt.Printf("act set; return 1\n") @@ -706,6 +684,8 @@ if gc.Debug['P'] != 0 { fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f) } + var t int + var p *obj.Prog for ; r != nil; r = r.S1 { p = r.Prog if gc.Debug['P'] != 0 { @@ -796,8 +776,6 @@ * 0 otherwise (not touched) */ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int { - var info gc.ProgInfo - switch p.As { case obj.AJMP: if s != nil { @@ -851,6 +829,7 @@ if p.As == obj.AVARDEF || p.As == obj.AVARKILL { return 0 } + var info gc.ProgInfo proginfo(&info, p) if (info.Reguse|info.Regset)&RtoB(int(v.Reg)) != 0 { @@ -977,10 +956,8 @@ * return failure to substitute */ func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int { - var reg int - if copyas(a, v) { - reg = int(s.Reg) + reg := int(int(s.Reg)) if reg >= x86.REG_AX && reg <= x86.REG_R15 || reg >= x86.REG_X0 && reg <= x86.REG_X0+15 { if f != 0 { a.Reg = int16(reg) @@ -991,7 +968,7 @@ } if regtyp(v) { - reg = int(v.Reg) + reg := int(int(v.Reg)) if a.Type == obj.TYPE_MEM && int(a.Reg) == reg { if (s.Reg == x86.REG_BP || s.Reg == x86.REG_R13) && a.Index != x86.REG_NONE { return 1 /* can't use BP-base with index */ @@ -1016,15 +993,12 @@ } func conprop(r0 *gc.Flow) { - var r *gc.Flow var p *obj.Prog - var p0 *obj.Prog var t int - var v0 *obj.Addr - p0 = r0.Prog - v0 = &p0.To - r = r0 + p0 := (*obj.Prog)(r0.Prog) + v0 := (*obj.Addr)(&p0.To) + r := (*gc.Flow)(r0) loop: r = gc.Uniqs(r)
diff --git a/src/cmd/6g/reg.go b/src/cmd/6g/reg.go index 0629a62..3c5a699 100644 --- a/src/cmd/6g/reg.go +++ b/src/cmd/6g/reg.go
@@ -85,9 +85,7 @@ } func doregbits(r int) uint64 { - var b uint64 - - b = 0 + b := uint64(0) if r >= x86.REG_AX && r <= x86.REG_R15 { b |= RtoB(r) } else if r >= x86.REG_AL && r <= x86.REG_R15B {
diff --git a/src/cmd/8g/cgen.go b/src/cmd/8g/cgen.go index 9f736b1..d36bef7 100644 --- a/src/cmd/8g/cgen.go +++ b/src/cmd/8g/cgen.go
@@ -19,8 +19,6 @@ * peep.c */ func mgen(n *gc.Node, n1 *gc.Node, rg *gc.Node) { - var n2 gc.Node - n1.Op = gc.OEMPTY if n.Addable != 0 { @@ -34,7 +32,7 @@ gc.Tempname(n1, n.Type) cgen(n, n1) if n.Type.Width <= int64(gc.Widthptr) || gc.Isfloat[n.Type.Etype] != 0 { - n2 = *n1 + n2 := *n1 regalloc(n1, n.Type, rg) gmove(&n2, n1) } @@ -55,17 +53,6 @@ * sudoaddable */ func cgen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var nt gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var a int - if gc.Debug['g'] != 0 { gc.Dump("\ncgen-n", n) gc.Dump("cgen-res", res) @@ -85,6 +72,7 @@ gc.OSLICE3, gc.OSLICE3ARR: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) cgen(&n1, res) @@ -95,6 +83,7 @@ case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) cgen(&n1, res) @@ -110,6 +99,7 @@ // function calls on both sides? introduce temporary if n.Ullman >= gc.UINF && res.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) @@ -154,6 +144,7 @@ if n.Addable == 0 && res.Addable == 0 { // could use regalloc here sometimes, // but have to check for ullman >= UINF. + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) @@ -164,6 +155,7 @@ // if result is not addressable directly but n is, // compute its address and then store via the address. if res.Addable == 0 { + var n1 gc.Node igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) @@ -180,16 +172,17 @@ // let's do some computation. // use ullman to pick operand to eval first. - nl = n.Left + nl := n.Left - nr = n.Right + nr := n.Right if nl != nil && nl.Ullman >= gc.UINF { if nr != nil && nr.Ullman >= gc.UINF { // both are hard + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) - n2 = *n + n2 := *n n2.Left = &n1 cgen(&n2, res) return @@ -222,6 +215,7 @@ return } + var a int switch n.Op { default: gc.Dump("cgen", n) @@ -243,11 +237,11 @@ gc.OGE, gc.OGT, gc.ONOT: - p1 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Pc + p2 := gc.Pc gmove(gc.Nodbool(true), res) - p3 = gc.Gbranch(obj.AJMP, nil, 0) + p3 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n, true, 0, p2) gmove(gc.Nodbool(false), res) @@ -293,7 +287,9 @@ break } + var n2 gc.Node gc.Tempname(&n2, n.Type) + var n1 gc.Node mgen(nl, &n1, res) gmove(&n1, &n2) gmove(&n2, res) @@ -304,12 +300,14 @@ gc.OINDEX, gc.OIND, gc.ONAME: // PHEAP or PPARAMREF var + var n1 gc.Node igen(n, &n1, res) gmove(&n1, res) regfree(&n1) case gc.OITAB: + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Ptrto(gc.Types[gc.TUINTPTR]) gmove(&n1, res) @@ -318,14 +316,16 @@ // pointer is the first word of string or slice. case gc.OSPTR: if gc.Isconst(nl, gc.CTSTR) { + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) - p1 = gins(i386.ALEAL, nil, &n1) + p1 := gins(i386.ALEAL, nil, &n1) gc.Datastring(nl.Val.U.Sval.S, &p1.From) gmove(&n1, res) regfree(&n1) break } + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type gmove(&n1, res) @@ -335,16 +335,18 @@ if gc.Istype(nl.Type, gc.TMAP) || gc.Istype(nl.Type, gc.TCHAN) { // map has len in the first 32-bit word. // a zero pointer means zero length + var n1 gc.Node gc.Tempname(&n1, gc.Types[gc.Tptr]) cgen(nl, &n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], nil) gmove(&n1, &n2) n1 = n2 gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) n2 = n1 n2.Op = gc.OINDREG @@ -360,6 +362,7 @@ if gc.Istype(nl.Type, gc.TSTRING) || gc.Isslice(nl.Type) { // both slice and string have len one pointer into the struct. + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.TUINT32] @@ -375,16 +378,18 @@ if gc.Istype(nl.Type, gc.TCHAN) { // chan has cap in the second 32-bit word. // a zero pointer means zero length + var n1 gc.Node gc.Tempname(&n1, gc.Types[gc.Tptr]) cgen(nl, &n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], nil) gmove(&n1, &n2) n1 = n2 gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1) n2 = n1 n2.Op = gc.OINDREG @@ -400,6 +405,7 @@ } if gc.Isslice(nl.Type) { + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.TUINT32] n1.Xoffset += int64(gc.Array_cap) @@ -439,14 +445,16 @@ sbop: // symmetric binary if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL { - r = nl + r := nl nl = nr nr = r } abop: // asymmetric binary if gc.Smallintconst(nr) { + var n1 gc.Node mgen(nl, &n1, res) + var n2 gc.Node regalloc(&n2, nl.Type, &n1) gmove(&n1, &n2) gins(a, nr, &n2) @@ -454,9 +462,12 @@ regfree(&n2) mfree(&n1) } else if nl.Ullman >= nr.Ullman { + var nt gc.Node gc.Tempname(&nt, nl.Type) cgen(nl, &nt) + var n2 gc.Node mgen(nr, &n2, nil) + var n1 gc.Node regalloc(&n1, nl.Type, res) gmove(&nt, &n1) gins(a, &n2, &n1) @@ -464,8 +475,10 @@ regfree(&n1) mfree(&n2) } else { + var n2 gc.Node regalloc(&n2, nr.Type, res) cgen(nr, &n2) + var n1 gc.Node regalloc(&n1, nl.Type, nil) cgen(nl, &n1) gins(a, &n2, &n1) @@ -477,6 +490,7 @@ return uop: // unary + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) @@ -491,11 +505,6 @@ * returns Prog* to patch to panic call. */ func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog { - var tmp gc.Node - var lo gc.Node - var hi gc.Node - var zero gc.Node - if !gc.Is64(n.Type) { if n.Addable != 0 { // nothing to do. @@ -508,8 +517,11 @@ return nil } + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT64]) cgen(n, &tmp) + var lo gc.Node + var hi gc.Node split64(&tmp, &lo, &hi) gc.Tempname(res, gc.Types[gc.TUINT32]) gmove(&lo, res) @@ -518,6 +530,7 @@ return nil } + var zero gc.Node gc.Nodconst(&zero, gc.Types[gc.TINT32], 0) gins(i386.ACMPL, &hi, &zero) splitclean() @@ -530,20 +543,6 @@ * The generated code checks that the result is not nil. */ func agen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var tmp gc.Node - var nlen gc.Node - var t *gc.Type - var w uint32 - var v uint64 - var p1 *obj.Prog - var p2 *obj.Prog - var bounded bool - if gc.Debug['g'] != 0 { gc.Dump("\nagen-res", res) gc.Dump("agen-r", n) @@ -562,10 +561,12 @@ // Create a temporary we can take the address of and read. // The generated code is just going to panic, so it need not // be terribly efficient. See issue 3670. + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Gvardef(&n1) clearfat(&n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) gins(i386.ALEAL, &n1, &n2) gmove(&n2, res) @@ -578,6 +579,7 @@ if n.Op == gc.OREGISTER { gc.Fatal("agen OREGISTER") } + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) gins(i386.ALEAL, n, &n1) gmove(&n1, res) @@ -586,9 +588,9 @@ } // let's compute - nl = n.Left + nl := n.Left - nr = n.Right + nr := n.Right switch n.Op { default: @@ -611,19 +613,24 @@ gc.OSLICESTR, gc.OSLICE3, gc.OSLICE3ARR: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) agen(&n1, res) case gc.OEFACE: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) agen(&n1, res) case gc.OINDEX: - p2 = nil // to be patched to panicindex. - w = uint32(n.Type.Width) - bounded = gc.Debug['B'] != 0 || n.Bounded + p2 := (*obj.Prog)(nil) // to be patched to panicindex. + w := uint32(n.Type.Width) + bounded := gc.Debug['B'] != 0 || n.Bounded + var n3 gc.Node + var tmp gc.Node + var n1 gc.Node if nr.Addable != 0 { // Generate &nl first, and move nr into register. if !gc.Isconst(nl, gc.CTSTR) { @@ -656,6 +663,7 @@ } // For fixed array we really want the pointer in n3. + var n2 gc.Node if gc.Isfixedarray(nl.Type) { regalloc(&n2, gc.Types[gc.Tptr], &n3) agen(&n3, &n2) @@ -673,15 +681,15 @@ if gc.Isconst(nl, gc.CTSTR) { gc.Fatal("constant string constant index") // front end should handle } - v = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + v := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { if gc.Debug['B'] == 0 && !n.Bounded { - nlen = n3 + nlen := n3 nlen.Type = gc.Types[gc.TUINT32] nlen.Xoffset += int64(gc.Array_nel) gc.Nodconst(&n2, gc.Types[gc.TUINT32], int64(v)) gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &nlen, &n2) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1) ginscall(gc.Panicindex, -1) gc.Patch(p1, gc.Pc) } @@ -705,7 +713,7 @@ } // i is in register n1, extend to 32 bits. - t = gc.Types[gc.TUINT32] + t := gc.Types[gc.TUINT32] if gc.Issigned[n1.Type.Etype] != 0 { t = gc.Types[gc.TINT32] @@ -717,8 +725,9 @@ if gc.Debug['B'] == 0 && !n.Bounded { // check bounds - t = gc.Types[gc.TUINT32] + t := gc.Types[gc.TUINT32] + var nlen gc.Node if gc.Isconst(nl, gc.CTSTR) { gc.Nodconst(&nlen, t, int64(len(nl.Val.U.Sval.S))) } else if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { @@ -730,7 +739,7 @@ } gins(optoas(gc.OCMP, t), &n2, &nlen) - p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLT, t), nil, +1) if p2 != nil { gc.Patch(p2, gc.Pc) } @@ -740,7 +749,7 @@ if gc.Isconst(nl, gc.CTSTR) { regalloc(&n3, gc.Types[gc.Tptr], res) - p1 = gins(i386.ALEAL, nil, &n3) + p1 := gins(i386.ALEAL, nil, &n3) gc.Datastring(nl.Val.U.Sval.S, &p1.From) p1.From.Scale = 1 p1.From.Index = n2.Val.U.Reg @@ -763,7 +772,7 @@ } else // nothing to do if w == 1 || w == 2 || w == 4 || w == 8 { // LEAL (n3)(n2*w), n3 - p1 = gins(i386.ALEAL, &n2, &n3) + p1 := gins(i386.ALEAL, &n2, &n3) p1.From.Scale = int8(w) p1.From.Type = obj.TYPE_MEM @@ -795,6 +804,7 @@ cgen(n.Heapaddr, res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset) gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res) } @@ -806,18 +816,20 @@ case gc.ODOT: agen(nl, res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset) gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res) } case gc.ODOTPTR: - t = nl.Type + t := nl.Type if gc.Isptr[t.Etype] == 0 { gc.Fatal("agen: not ptr %v", gc.Nconv(n, 0)) } cgen(nl, res) gc.Cgen_checknil(res) if n.Xoffset != 0 { + var n1 gc.Node gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset) gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res) } @@ -834,10 +846,6 @@ * The generated code checks that the result is not *nil. */ func igen(n *gc.Node, a *gc.Node, res *gc.Node) { - var fp *gc.Type - var flist gc.Iter - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("\nigen-n", n) } @@ -873,6 +881,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n.Left, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) @@ -904,7 +913,8 @@ cgen_callinter(n, nil, 0) } - fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) *a = gc.Node{} a.Op = gc.OINDREG a.Val.U.Reg = i386.REG_SP @@ -924,6 +934,7 @@ if gc.Isptr[n.Left.Type.Etype] == 0 { igen(n.Left, a, res) } else { + var n1 gc.Node igen(n.Left, &n1, res) gc.Cgen_checknil(&n1) regalloc(a, gc.Types[gc.Tptr], res) @@ -946,6 +957,7 @@ if res != nil && res.Op == gc.OREGISTER { reg[res.Val.U.Reg]-- } + var n1 gc.Node gc.Tempname(&n1, gc.Types[gc.Tptr]) agen(n, &n1) if res != nil && res.Op == gc.OREGISTER { @@ -962,17 +974,6 @@ * if(n == true) goto to; */ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { - var et int - var a int - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var tmp gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['g'] != 0 { gc.Dump("\nbgen", n) } @@ -992,7 +993,7 @@ } } - et = int(n.Type.Etype) + et := int(n.Type.Etype) if et != gc.TBOOL { gc.Yyerror("cgen: bad type %v for %v", gc.Tconv(n.Type, 0), gc.Oconv(int(n.Op), 0)) gc.Patch(gins(obj.AEND, nil, nil), to) @@ -1006,8 +1007,8 @@ } } - nl = n.Left - nr = nil + nl := n.Left + nr := (*gc.Node)(nil) if nl != nil && gc.Isfloat[nl.Type.Etype] != 0 { bgen_float(n, bool2int(true_), likely, to) @@ -1029,9 +1030,10 @@ if n.Addable == 0 { goto def } + var n1 gc.Node gc.Nodconst(&n1, n.Type, 0) gins(optoas(gc.OCMP, n.Type), n, &n1) - a = i386.AJNE + a := i386.AJNE if !true_ { a = i386.AJEQ } @@ -1041,8 +1043,8 @@ case gc.OANDAND, gc.OOROR: if (n.Op == gc.OANDAND) == true_ { - p1 = gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n.Left, !true_, -likely, p2) bgen(n.Right, !true_, -likely, p2) @@ -1086,7 +1088,7 @@ gc.OGT, gc.OLE, gc.OGE: - a = int(n.Op) + a := int(n.Op) if !true_ { a = gc.Brcom(a) true_ = !true_ @@ -1095,7 +1097,7 @@ // make simplest on right if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) { a = gc.Brrev(a) - r = nl + r := nl nl = nr nr = r } @@ -1108,9 +1110,11 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Xoffset += int64(gc.Array_array) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp) gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to) @@ -1126,8 +1130,10 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp) gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to) @@ -1142,12 +1148,14 @@ if gc.Is64(nr.Type) { if nl.Addable == 0 || gc.Isconst(nl, gc.CTINT) { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) nl = &n1 } if nr.Addable == 0 { + var n2 gc.Node gc.Tempname(&n2, nr.Type) cgen(nr, &n2) nr = &n2 @@ -1157,19 +1165,23 @@ break } + var n2 gc.Node if nr.Ullman >= gc.UINF { if nl.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) nl = &n1 } if nr.Addable == 0 { + var tmp gc.Node gc.Tempname(&tmp, nr.Type) cgen(nr, &tmp) nr = &tmp } + var n2 gc.Node regalloc(&n2, nr.Type, nil) cgen(nr, &n2) nr = &n2 @@ -1177,6 +1189,7 @@ } if nl.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) nl = &n1 @@ -1189,6 +1202,7 @@ } if nr.Addable == 0 { + var tmp gc.Node gc.Tempname(&tmp, nr.Type) cgen(nr, &tmp) nr = &tmp @@ -1211,11 +1225,13 @@ return def: + var n1 gc.Node regalloc(&n1, n.Type, nil) cgen(n, &n1) + var n2 gc.Node gc.Nodconst(&n2, n.Type, 0) gins(optoas(gc.OCMP, n.Type), &n1, &n2) - a = i386.AJNE + a := i386.AJNE if !true_ { a = i386.AJEQ } @@ -1230,31 +1246,27 @@ * return n's offset from SP. */ func stkof(n *gc.Node) int32 { - var t *gc.Type - var flist gc.Iter - var off int32 - switch n.Op { case gc.OINDREG: return int32(n.Xoffset) case gc.ODOT: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } return int32(int64(off) + n.Xoffset) case gc.OINDEX: - t = n.Left.Type + t := n.Left.Type if !gc.Isfixedarray(t) { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } @@ -1266,11 +1278,12 @@ case gc.OCALLMETH, gc.OCALLINTER, gc.OCALLFUNC: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } + var flist gc.Iter t = gc.Structfirst(&flist, gc.Getoutarg(t)) if t != nil { return int32(t.Width) @@ -1287,18 +1300,6 @@ * memmove(&res, &n, w); */ func sgen(n *gc.Node, res *gc.Node, w int64) { - var dst gc.Node - var src gc.Node - var tdst gc.Node - var tsrc gc.Node - var cx gc.Node - var c int32 - var q int32 - var odst int32 - var osrc int32 - var l *gc.NodeList - var p *obj.Prog - if gc.Debug['g'] != 0 { fmt.Printf("\nsgen w=%d\n", w) gc.Dump("r", n) @@ -1315,6 +1316,7 @@ if w == 0 { // evaluate side effects only. + var tdst gc.Node gc.Tempname(&tdst, gc.Types[gc.Tptr]) agen(res, &tdst) @@ -1325,7 +1327,7 @@ // If copying .args, that's all the results, so record definition sites // for them for the liveness analysis. if res.Op == gc.ONAME && res.Sym.Name == ".args" { - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { if l.N.Class == gc.PPARAMOUT { gc.Gvardef(l.N) } @@ -1338,15 +1340,16 @@ } // offset on the stack - osrc = stkof(n) + osrc := stkof(n) - odst = stkof(res) + odst := stkof(res) if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) { // osrc and odst both on stack, and at least one is in // an unknown position. Could generate code to test // for forward/backward copy, but instead just copy // to a temporary location first. + var tsrc gc.Node gc.Tempname(&tsrc, n.Type) sgen(n, &tsrc, w) @@ -1354,10 +1357,14 @@ return } + var dst gc.Node gc.Nodreg(&dst, gc.Types[gc.Tptr], i386.REG_DI) + var src gc.Node gc.Nodreg(&src, gc.Types[gc.Tptr], i386.REG_SI) + var tsrc gc.Node gc.Tempname(&tsrc, gc.Types[gc.Tptr]) + var tdst gc.Node gc.Tempname(&tdst, gc.Types[gc.Tptr]) if n.Addable == 0 { agen(n, &tsrc) @@ -1381,8 +1388,8 @@ gmove(&tdst, &dst) } - c = int32(w % 4) // bytes - q = int32(w / 4) // doublewords + c := int32(w % 4) // bytes + q := int32(w / 4) // doublewords // if we are copying forward on the stack and // the src and dst overlap, then reverse direction @@ -1423,13 +1430,14 @@ gins(i386.AREP, nil, nil) // repeat gins(i386.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+ } else if q >= 4 { - p = gins(obj.ADUFFCOPY, nil, nil) + p := gins(obj.ADUFFCOPY, nil, nil) p.To.Type = obj.TYPE_ADDR p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg)) // 10 and 128 = magic constants: see ../../runtime/asm_386.s p.To.Offset = 10 * (128 - int64(q)) } else if !gc.Nacl && c == 0 { + var cx gc.Node gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX) // We don't need the MOVSL side-effect of updating SI and DI, @@ -1484,23 +1492,16 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool { var nodl gc.Node var nodr gc.Node - var tmp gc.Node - var t *gc.Type - var freel int - var freer int - var fldcount int64 - var loffset int64 - var roffset int64 - freel = 0 - freer = 0 + freel := 0 + freer := 0 switch nl.Type.Etype { default: goto no case gc.TARRAY: - t = nl.Type + t := nl.Type // Slices are ok. if gc.Isslice(t) { @@ -1517,9 +1518,9 @@ // Small structs with non-fat types are ok. // Zero-sized structs are treated separately elsewhere. case gc.TSTRUCT: - fldcount = 0 + fldcount := int64(0) - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { if gc.Isfat(t.Type) { goto no } @@ -1555,6 +1556,7 @@ } } else { // When zeroing, prepare a register containing zero. + var tmp gc.Node gc.Nodconst(&tmp, nl.Type, 0) regalloc(&nodr, gc.Types[gc.TUINT], nil) @@ -1576,11 +1578,11 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - t = nl.Type + t := nl.Type if !gc.Isslice(t) { nodl.Type = t.Type nodr.Type = nodl.Type - for fldcount = 0; fldcount < t.Bound; fldcount++ { + for fldcount := int64(0); fldcount < t.Bound; fldcount++ { if nr == nil { gc.Clearslim(&nodl) } else { @@ -1683,8 +1685,8 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - loffset = nodl.Xoffset - roffset = nodr.Xoffset + loffset := nodl.Xoffset + roffset := nodr.Xoffset // funarg structs may not begin at offset zero. if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil { @@ -1694,7 +1696,7 @@ roffset -= nr.Type.Type.Width } - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { nodl.Xoffset = loffset + t.Width nodl.Type = t.Type
diff --git a/src/cmd/8g/cgen64.go b/src/cmd/8g/cgen64.go index 1937ae0..0755f0e 100644 --- a/src/cmd/8g/cgen64.go +++ b/src/cmd/8g/cgen64.go
@@ -16,25 +16,6 @@ * return 1 on success, 0 if op not handled. */ func cgen64(n *gc.Node, res *gc.Node) { - var t1 gc.Node - var t2 gc.Node - var ax gc.Node - var dx gc.Node - var cx gc.Node - var ex gc.Node - var fx gc.Node - var l *gc.Node - var r *gc.Node - var lo1 gc.Node - var lo2 gc.Node - var hi1 gc.Node - var hi2 gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var v uint64 - var lv uint32 - var hv uint32 - if res.Op != gc.OINDREG && res.Op != gc.ONAME { gc.Dump("n", n) gc.Dump("res", res) @@ -47,6 +28,8 @@ case gc.OMINUS: cgen(n.Left, res) + var hi1 gc.Node + var lo1 gc.Node split64(res, &lo1, &hi1) gins(i386.ANEGL, nil, &lo1) gins(i386.AADCL, ncon(0), &hi1) @@ -56,6 +39,8 @@ case gc.OCOM: cgen(n.Left, res) + var lo1 gc.Node + var hi1 gc.Node split64(res, &lo1, &hi1) gins(i386.ANOTL, nil, &lo1) gins(i386.ANOTL, nil, &hi1) @@ -76,27 +61,36 @@ break } - l = n.Left - r = n.Right + l := n.Left + r := n.Right if l.Addable == 0 { + var t1 gc.Node gc.Tempname(&t1, l.Type) cgen(l, &t1) l = &t1 } if r != nil && r.Addable == 0 { + var t2 gc.Node gc.Tempname(&t2, r.Type) cgen(r, &t2) r = &t2 } + var ax gc.Node gc.Nodreg(&ax, gc.Types[gc.TINT32], i386.REG_AX) + var cx gc.Node gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX) + var dx gc.Node gc.Nodreg(&dx, gc.Types[gc.TINT32], i386.REG_DX) // Setup for binary operation. + var hi1 gc.Node + var lo1 gc.Node split64(l, &lo1, &hi1) + var lo2 gc.Node + var hi2 gc.Node if gc.Is64(r.Type) { split64(r, &lo2, &hi2) } @@ -121,8 +115,10 @@ // let's call the next two EX and FX. case gc.OMUL: + var ex gc.Node regalloc(&ex, gc.Types[gc.TPTR32], nil) + var fx gc.Node regalloc(&fx, gc.Types[gc.TPTR32], nil) // load args into DX:AX and EX:CX. @@ -136,9 +132,9 @@ gins(i386.AMOVL, &dx, &fx) gins(i386.AORL, &ex, &fx) - p1 = gc.Gbranch(i386.AJNE, nil, 0) + p1 := gc.Gbranch(i386.AJNE, nil, 0) gins(i386.AMULL, &cx, nil) // implicit &ax - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) // full 64x64 -> 64, from 32x32 -> 64. @@ -166,7 +162,7 @@ // shld hi:lo, c // shld lo:t, c case gc.OLROT: - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) if v >= 32 { // reverse during load to do the first 32 bits of rotate @@ -183,7 +179,7 @@ } else // done { gins(i386.AMOVL, &dx, &cx) - p1 = gins(i386.ASHLL, ncon(uint32(v)), &dx) + p1 := gins(i386.ASHLL, ncon(uint32(v)), &dx) p1.From.Index = i386.REG_AX // double-width shift p1.From.Scale = 0 p1 = gins(i386.ASHLL, ncon(uint32(v)), &ax) @@ -193,7 +189,7 @@ case gc.OLSH: if r.Op == gc.OLITERAL { - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) if v >= 64 { if gc.Is64(r.Type) { splitclean() @@ -226,7 +222,7 @@ gins(i386.AMOVL, &lo1, &ax) gins(i386.AMOVL, &hi1, &dx) - p1 = gins(i386.ASHLL, ncon(uint32(v)), &dx) + p1 := gins(i386.ASHLL, ncon(uint32(v)), &dx) p1.From.Index = i386.REG_AX // double-width shift p1.From.Scale = 0 gins(i386.ASHLL, ncon(uint32(v)), &ax) @@ -240,7 +236,7 @@ // load shift value into register. // if high bits are set, zero value. - p1 = nil + p1 := (*obj.Prog)(nil) if gc.Is64(r.Type) { gins(i386.ACMPL, &hi2, ncon(0)) @@ -254,7 +250,7 @@ // if shift count is >=64, zero value gins(i386.ACMPL, &cx, ncon(64)) - p2 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) + p2 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) if p1 != nil { gc.Patch(p1, gc.Pc) } @@ -282,7 +278,7 @@ case gc.ORSH: if r.Op == gc.OLITERAL { - v = uint64(gc.Mpgetfix(r.Val.U.Xval)) + v := uint64(gc.Mpgetfix(r.Val.U.Xval)) if v >= 64 { if gc.Is64(r.Type) { splitclean() @@ -327,7 +323,7 @@ gins(i386.AMOVL, &lo1, &ax) gins(i386.AMOVL, &hi1, &dx) - p1 = gins(i386.ASHRL, ncon(uint32(v)), &ax) + p1 := gins(i386.ASHRL, ncon(uint32(v)), &ax) p1.From.Index = i386.REG_DX // double-width shift p1.From.Scale = 0 gins(optoas(gc.ORSH, hi1.Type), ncon(uint32(v)), &dx) @@ -341,7 +337,7 @@ // load shift value into register. // if high bits are set, zero value. - p1 = nil + p1 := (*obj.Prog)(nil) if gc.Is64(r.Type) { gins(i386.ACMPL, &hi2, ncon(0)) @@ -355,7 +351,7 @@ // if shift count is >=64, zero or sign-extend value gins(i386.ACMPL, &cx, ncon(64)) - p2 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) + p2 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) if p1 != nil { gc.Patch(p1, gc.Pc) } @@ -404,9 +400,9 @@ if lo2.Op == gc.OLITERAL { // special cases for constants. - lv = uint32(gc.Mpgetfix(lo2.Val.U.Xval)) + lv := uint32(gc.Mpgetfix(lo2.Val.U.Xval)) - hv = uint32(gc.Mpgetfix(hi2.Val.U.Xval)) + hv := uint32(gc.Mpgetfix(hi2.Val.U.Xval)) splitclean() // right side split64(res, &lo2, &hi2) switch n.Op { @@ -518,15 +514,13 @@ var lo2 gc.Node var hi2 gc.Node var rr gc.Node - var br *obj.Prog - var t *gc.Type split64(nl, &lo1, &hi1) split64(nr, &lo2, &hi2) // compare most significant word; // if they differ, we're done. - t = hi1.Type + t := hi1.Type if nl.Op == gc.OLITERAL || nr.Op == gc.OLITERAL { gins(i386.ACMPL, &hi1, &hi2) @@ -537,7 +531,7 @@ regfree(&rr) } - br = nil + br := (*obj.Prog)(nil) switch op { default: gc.Fatal("cmp64 %v %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
diff --git a/src/cmd/8g/ggen.go b/src/cmd/8g/ggen.go index f72beda..ca2a79f 100644 --- a/src/cmd/8g/ggen.go +++ b/src/cmd/8g/ggen.go
@@ -11,30 +11,24 @@ import "cmd/internal/gc" func defframe(ptxt *obj.Prog) { - var frame uint32 - var ax uint32 - var p *obj.Prog - var lo int64 - var hi int64 - var l *gc.NodeList var n *gc.Node // fill in argument size, stack size ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr))) - frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) + frame := uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) ptxt.To.Offset = int64(frame) // insert code to zero ambiguously live variables // so that the garbage collector only sees initialized values // when it looks for pointers. - p = ptxt + p := ptxt - hi = 0 - lo = hi - ax = 0 - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + hi := int64(0) + lo := hi + ax := uint32(0) + for l := gc.Curfn.Dcl; l != nil; l = l.Next { n = l.N if n.Needzero == 0 { continue @@ -66,10 +60,7 @@ } func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Prog { - var cnt int64 - var i int64 - - cnt = hi - lo + cnt := hi - lo if cnt == 0 { return p } @@ -79,7 +70,7 @@ } if cnt <= int64(4*gc.Widthreg) { - for i = 0; i < cnt; i += int64(gc.Widthreg) { + for i := int64(0); i < cnt; i += int64(gc.Widthreg) { p = appendpp(p, i386.AMOVL, obj.TYPE_REG, i386.REG_AX, 0, obj.TYPE_MEM, i386.REG_SP, frame+lo+i) } } else if !gc.Nacl && cnt <= int64(128*gc.Widthreg) { @@ -97,8 +88,7 @@ } func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog { - var q *obj.Prog - q = gc.Ctxt.NewProg() + q := gc.Ctxt.NewProg() gc.Clearp(q) q.As = int16(as) q.Lineno = p.Lineno @@ -114,27 +104,20 @@ } func clearfat(nl *gc.Node) { - var w uint32 - var c uint32 - var q uint32 - var n1 gc.Node - var z gc.Node - var p *obj.Prog - /* clear a fat object */ if gc.Debug['g'] != 0 { gc.Dump("\nclearfat", nl) } - w = uint32(nl.Type.Width) + w := uint32(nl.Type.Width) // Avoid taking the address for simple enough types. if componentgen(nil, nl) { return } - c = w % 4 // bytes - q = w / 4 // quads + c := w % 4 // bytes + q := w / 4 // quads if q < 4 { // Write sequence of MOV 0, off(base) instead of using STOSL. @@ -143,10 +126,12 @@ // than the unrolled STOSL loop. // NOTE: Must use agen, not igen, so that optimizer sees address // being taken. We are not writing on field boundaries. + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], nil) agen(nl, &n1) n1.Op = gc.OINDREG + var z gc.Node gc.Nodconst(&z, gc.Types[gc.TUINT64], 0) for { tmp14 := q @@ -175,6 +160,7 @@ return } + var n1 gc.Node gc.Nodreg(&n1, gc.Types[gc.Tptr], i386.REG_DI) agen(nl, &n1) gconreg(i386.AMOVL, 0, i386.REG_AX) @@ -184,7 +170,7 @@ gins(i386.AREP, nil, nil) // repeat gins(i386.ASTOSL, nil, nil) // STOL AL,*(DI)+ } else if q >= 4 { - p = gins(obj.ADUFFZERO, nil, nil) + p := gins(obj.ADUFFZERO, nil, nil) p.To.Type = obj.TYPE_ADDR p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg)) @@ -213,15 +199,8 @@ * proc=3 normal call to C pointer (not Go func value) */ func ginscall(f *gc.Node, proc int) { - var p *obj.Prog - var reg gc.Node - var r1 gc.Node - var con gc.Node - var stk gc.Node - var extra int32 - if f.Type != nil { - extra = 0 + extra := int32(0) if proc == 1 || proc == 2 { extra = 2 * int32(gc.Widthptr) } @@ -245,12 +224,13 @@ // x86 NOP 0x90 is really XCHG AX, AX; use that description // because the NOP pseudo-instruction will be removed by // the linker. + var reg gc.Node gc.Nodreg(®, gc.Types[gc.TINT], i386.REG_AX) gins(i386.AXCHGL, ®, ®) } - p = gins(obj.ACALL, nil, f) + p := gins(obj.ACALL, nil, f) gc.Afunclit(&p.To, f) if proc == -1 || gc.Noreturn(p) { gins(obj.AUNDEF, nil, nil) @@ -258,7 +238,9 @@ break } + var reg gc.Node gc.Nodreg(®, gc.Types[gc.Tptr], i386.REG_DX) + var r1 gc.Node gc.Nodreg(&r1, gc.Types[gc.Tptr], i386.REG_BX) gmove(f, ®) reg.Op = gc.OINDREG @@ -271,13 +253,14 @@ case 1, // call in new proc (go) 2: // deferred call (defer) - stk = gc.Node{} + stk := gc.Node{} stk.Op = gc.OINDREG stk.Val.U.Reg = i386.REG_SP stk.Xoffset = 0 // size of arguments at 0(SP) + var con gc.Node gc.Nodconst(&con, gc.Types[gc.TINT32], int64(gc.Argsize(f.Type))) gins(i386.AMOVL, &con, &stk) @@ -293,9 +276,10 @@ ginscall(gc.Deferproc, 0) } if proc == 2 { + var reg gc.Node gc.Nodreg(®, gc.Types[gc.TINT32], i386.REG_AX) gins(i386.ATESTL, ®, ®) - p = gc.Gbranch(i386.AJEQ, nil, +1) + p := gc.Gbranch(i386.AJEQ, nil, +1) cgen_ret(nil) gc.Patch(p, gc.Pc) } @@ -307,20 +291,12 @@ * generate res = n. */ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) { - var i *gc.Node - var f *gc.Node - var tmpi gc.Node - var nodi gc.Node - var nodo gc.Node - var nodr gc.Node - var nodsp gc.Node - - i = n.Left + i := n.Left if i.Op != gc.ODOTINTER { gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0)) } - f = i.Right // field + f := i.Right // field if f.Op != gc.ONAME { gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0)) } @@ -328,6 +304,7 @@ i = i.Left // interface if i.Addable == 0 { + var tmpi gc.Node gc.Tempname(&tmpi, i.Type) cgen(i, &tmpi) i = &tmpi @@ -337,8 +314,10 @@ // i is now addable, prepare an indirected // register to hold its address. + var nodi gc.Node igen(i, &nodi, res) // REG = &inter + var nodsp gc.Node gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], i386.REG_SP) nodsp.Xoffset = 0 @@ -349,6 +328,7 @@ nodi.Xoffset += int64(gc.Widthptr) cgen(&nodi, &nodsp) // {0 or 8}(SP) = 4(REG) -- i.data + var nodo gc.Node regalloc(&nodo, gc.Types[gc.Tptr], res) nodi.Type = gc.Types[gc.Tptr] @@ -356,6 +336,7 @@ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab regfree(&nodi) + var nodr gc.Node regalloc(&nodr, gc.Types[gc.Tptr], &nodo) if n.Left.Xoffset == gc.BADWIDTH { gc.Fatal("cgen_callinter: badwidth") @@ -387,14 +368,11 @@ * proc=2 defer call save away stack */ func cgen_call(n *gc.Node, proc int) { - var t *gc.Type - var nod gc.Node - var afun gc.Node - if n == nil { return } + var afun gc.Node if n.Left.Ullman >= gc.UINF { // if name involves a fn call // precompute the address of the fn @@ -404,10 +382,11 @@ } gc.Genlist(n.List) // assign the args - t = n.Left.Type + t := n.Left.Type // call tempname pointer if n.Left.Ullman >= gc.UINF { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, &afun) nod.Type = t @@ -418,6 +397,7 @@ // call pointer if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, n.Left) nod.Type = t @@ -438,22 +418,18 @@ * res = return value from call. */ func cgen_callret(n *gc.Node, res *gc.Node) { - var nod gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_callret: nil") } - nod = gc.Node{} + nod := gc.Node{} nod.Op = gc.OINDREG nod.Val.U.Reg = i386.REG_SP nod.Addable = 1 @@ -469,23 +445,18 @@ * res = &return value from call. */ func cgen_aret(n *gc.Node, res *gc.Node) { - var nod1 gc.Node - var nod2 gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_aret: nil") } - nod1 = gc.Node{} + nod1 := gc.Node{} nod1.Op = gc.OINDREG nod1.Val.U.Reg = i386.REG_SP nod1.Addable = 1 @@ -494,6 +465,7 @@ nod1.Type = fp.Type if res.Op != gc.OREGISTER { + var nod2 gc.Node regalloc(&nod2, gc.Types[gc.Tptr], res) gins(i386.ALEAL, &nod1, &nod2) gins(i386.AMOVL, &nod2, res) @@ -508,8 +480,6 @@ * n->left is assignments to return values. */ func cgen_ret(n *gc.Node) { - var p *obj.Prog - if n != nil { gc.Genlist(n.List) // copy out args } @@ -517,7 +487,7 @@ ginscall(gc.Deferreturn, 0) } gc.Genlist(gc.Curfn.Exit) - p = gins(obj.ARET, nil, nil) + p := gins(obj.ARET, nil, nil) if n != nil && n.Op == gc.ORETJMP { p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN @@ -536,19 +506,6 @@ * according to op. */ func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node, ax *gc.Node, dx *gc.Node) { - var check int - var n1 gc.Node - var t1 gc.Node - var t2 gc.Node - var t3 gc.Node - var t4 gc.Node - var n4 gc.Node - var nz gc.Node - var t *gc.Type - var t0 *gc.Type - var p1 *obj.Prog - var p2 *obj.Prog - // Have to be careful about handling // most negative int divided by -1 correctly. // The hardware will trap. @@ -557,10 +514,10 @@ // Easiest way to avoid for int8, int16: use int32. // For int32 and int64, use explicit test. // Could use int64 hw for int32. - t = nl.Type + t := nl.Type - t0 = t - check = 0 + t0 := t + check := 0 if gc.Issigned[t.Etype] != 0 { check = 1 if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -1<<uint64(t.Width*8-1) { @@ -579,10 +536,14 @@ check = 0 } + var t1 gc.Node gc.Tempname(&t1, t) + var t2 gc.Node gc.Tempname(&t2, t) if t0 != t { + var t3 gc.Node gc.Tempname(&t3, t0) + var t4 gc.Node gc.Tempname(&t4, t0) cgen(nl, &t3) cgen(nr, &t4) @@ -596,6 +557,7 @@ cgen(nr, &t2) } + var n1 gc.Node if !gc.Samereg(ax, res) && !gc.Samereg(dx, res) { regalloc(&n1, t, res) } else { @@ -603,7 +565,8 @@ } gmove(&t2, &n1) gmove(&t1, ax) - p2 = nil + p2 := (*obj.Prog)(nil) + var n4 gc.Node if gc.Nacl { // Native Client does not relay the divide-by-zero trap // to the executing program, so we must insert a check @@ -611,7 +574,7 @@ gc.Nodconst(&n4, t, 0) gins(optoas(gc.OCMP, t), &n1, &n4) - p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.ONE, t), nil, +1) if panicdiv == nil { panicdiv = gc.Sysfunc("panicdivide") } @@ -622,7 +585,7 @@ if check != 0 { gc.Nodconst(&n4, t, -1) gins(optoas(gc.OCMP, t), &n1, &n4) - p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.ONE, t), nil, +1) if op == gc.ODIV { // a / (-1) is -a. gins(optoas(gc.OMINUS, t), nil, ax) @@ -640,6 +603,7 @@ } if gc.Issigned[t.Etype] == 0 { + var nz gc.Node gc.Nodconst(&nz, t, 0) gmove(&nz, dx) } else { @@ -659,9 +623,7 @@ } func savex(dr int, x *gc.Node, oldx *gc.Node, res *gc.Node, t *gc.Type) { - var r int - - r = int(reg[dr]) + r := int(reg[dr]) gc.Nodreg(x, gc.Types[gc.TINT32], dr) // save current ax and dx if they are live @@ -691,22 +653,21 @@ * res = nl % nr */ func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var ax gc.Node - var dx gc.Node - var oldax gc.Node - var olddx gc.Node - var t *gc.Type - if gc.Is64(nl.Type) { gc.Fatal("cgen_div %v", gc.Tconv(nl.Type, 0)) } + var t *gc.Type if gc.Issigned[nl.Type.Etype] != 0 { t = gc.Types[gc.TINT32] } else { t = gc.Types[gc.TUINT32] } + var ax gc.Node + var oldax gc.Node savex(i386.REG_AX, &ax, &oldax, res, t) + var olddx gc.Node + var dx gc.Node savex(i386.REG_DX, &dx, &olddx, res, t) dodiv(op, nl, nr, res, &ax, &dx) restx(&dx, &olddx) @@ -719,33 +680,22 @@ * res = nl >> nr */ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var nt gc.Node - var cx gc.Node - var oldcx gc.Node - var hi gc.Node - var lo gc.Node - var a int - var w int - var p1 *obj.Prog - var p2 *obj.Prog - var sc uint64 - if nl.Type.Width > 4 { gc.Fatal("cgen_shift %v", gc.Tconv(nl.Type, 0)) } - w = int(nl.Type.Width * 8) + w := int(nl.Type.Width * 8) - a = optoas(op, nl.Type) + a := optoas(op, nl.Type) if nr.Op == gc.OLITERAL { + var n2 gc.Node gc.Tempname(&n2, nl.Type) cgen(nl, &n2) + var n1 gc.Node regalloc(&n1, nl.Type, res) gmove(&n2, &n1) - sc = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + sc := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if sc >= uint64(nl.Type.Width*8) { // large shift gets 2 shifts by width-1 gins(a, ncon(uint32(w)-1), &n1) @@ -759,13 +709,16 @@ return } - oldcx = gc.Node{} + oldcx := gc.Node{} + var cx gc.Node gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX) if reg[i386.REG_CX] > 1 && !gc.Samereg(&cx, res) { gc.Tempname(&oldcx, gc.Types[gc.TUINT32]) gmove(&cx, &oldcx) } + var n1 gc.Node + var nt gc.Node if nr.Type.Width > 4 { gc.Tempname(&nt, nr.Type) n1 = nt @@ -774,6 +727,7 @@ regalloc(&n1, nr.Type, &n1) // to hold the shift type in CX } + var n2 gc.Node if gc.Samereg(&cx, res) { regalloc(&n2, nl.Type, nil) } else { @@ -794,20 +748,25 @@ gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX) regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX + var lo gc.Node + var hi gc.Node split64(&nt, &lo, &hi) gmove(&lo, &n1) splitclean() } } else { + var p1 *obj.Prog if nr.Type.Width > 4 { // delayed reg alloc gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX) regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX + var lo gc.Node + var hi gc.Node split64(&nt, &lo, &hi) gmove(&lo, &n1) gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &hi, ncon(0)) - p2 = gc.Gbranch(optoas(gc.ONE, gc.Types[gc.TUINT32]), nil, +1) + p2 := gc.Gbranch(optoas(gc.ONE, gc.Types[gc.TUINT32]), nil, +1) gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n1, ncon(uint32(w))) p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1) splitclean() @@ -845,15 +804,8 @@ * we do a full-width multiplication and truncate afterwards. */ func cgen_bmul(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var nt gc.Node - var tmp *gc.Node - var t *gc.Type - var a int - // copy from byte to full registers - t = gc.Types[gc.TUINT32] + t := gc.Types[gc.TUINT32] if gc.Issigned[nl.Type.Etype] != 0 { t = gc.Types[gc.TINT32] @@ -861,18 +813,21 @@ // largest ullman on left. if nl.Ullman < nr.Ullman { - tmp = nl + tmp := nl nl = nr nr = tmp } + var nt gc.Node gc.Tempname(&nt, nl.Type) cgen(nl, &nt) + var n1 gc.Node regalloc(&n1, t, res) cgen(nr, &n1) + var n2 gc.Node regalloc(&n2, t, nil) gmove(&nt, &n2) - a = optoas(op, t) + a := optoas(op, t) gins(a, &n2, &n1) regfree(&n2) gmove(&n1, res) @@ -884,15 +839,13 @@ * res = (nl*nr) >> width */ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { - var t *gc.Type - var a int var n1 gc.Node var n2 gc.Node var ax gc.Node var dx gc.Node - t = nl.Type - a = optoas(gc.OHMUL, t) + t := nl.Type + a := optoas(gc.OHMUL, t) // gen nl in n1. gc.Tempname(&n1, t) @@ -927,24 +880,17 @@ * generate floating-point operation. */ func cgen_float(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var n1 gc.Node - var n2 gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - - nl = n.Left + nl := n.Left switch n.Op { case gc.OEQ, gc.ONE, gc.OLT, gc.OLE, gc.OGE: - p1 = gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Pc + p1 := gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Pc gmove(gc.Nodbool(true), res) - p3 = gc.Gbranch(obj.AJMP, nil, 0) + p3 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n, true, 0, p2) gmove(gc.Nodbool(false), res) @@ -961,7 +907,9 @@ return } + var n2 gc.Node gc.Tempname(&n2, n.Type) + var n1 gc.Node mgen(nl, &n1, res) gmove(&n1, &n2) gmove(&n2, res) @@ -980,11 +928,9 @@ func cgen_float387(n *gc.Node, res *gc.Node) { var f0 gc.Node var f1 gc.Node - var nl *gc.Node - var nr *gc.Node - nl = n.Left - nr = n.Right + nl := n.Left + nr := n.Right gc.Nodreg(&f0, nl.Type, i386.REG_F0) gc.Nodreg(&f1, n.Type, i386.REG_F0+1) if nr != nil { @@ -1024,16 +970,10 @@ } func cgen_floatsse(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var nt gc.Node var a int - nl = n.Left - nr = n.Right + nl := n.Left + nr := n.Right switch n.Op { default: gc.Dump("cgen_floatsse", n) @@ -1065,16 +1005,19 @@ sbop: // symmetric binary if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL { - r = nl + r := nl nl = nr nr = r } abop: // asymmetric binary if nl.Ullman >= nr.Ullman { + var nt gc.Node gc.Tempname(&nt, nl.Type) cgen(nl, &nt) + var n2 gc.Node mgen(nr, &n2, nil) + var n1 gc.Node regalloc(&n1, nl.Type, res) gmove(&nt, &n1) gins(a, &n2, &n1) @@ -1082,8 +1025,10 @@ regfree(&n1) mfree(&n2) } else { + var n2 gc.Node regalloc(&n2, nr.Type, res) cgen(nr, &n2) + var n1 gc.Node regalloc(&n1, nl.Type, nil) cgen(nl, &n1) gins(a, &n2, &n1) @@ -1096,29 +1041,14 @@ } func bgen_float(n *gc.Node, true_ int, likely int, to *obj.Prog) { - var et int - var a int - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var tmp gc.Node - var t1 gc.Node - var t2 gc.Node - var ax gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - - nl = n.Left - nr = n.Right - a = int(n.Op) + nl := n.Left + nr := n.Right + a := int(n.Op) if true_ == 0 { // brcom is not valid on floats when NaN is involved. - p1 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) // No need to avoid re-genning ninit. @@ -1129,6 +1059,10 @@ return } + var tmp gc.Node + var et int + var n2 gc.Node + var ax gc.Node if gc.Use_sse != 0 { goto sse } else { @@ -1139,7 +1073,7 @@ a = gc.Brrev(a) // because the args are stacked if a == gc.OGE || a == gc.OGT { // only < and <= work right with NaN; reverse if needed - r = nr + r := nr nr = nl nl = r @@ -1169,8 +1103,10 @@ // all the other ops have the same problem. // We need to figure out what the right general // solution is, besides telling people to use float64. + var t1 gc.Node gc.Tempname(&t1, gc.Types[gc.TFLOAT32]) + var t2 gc.Node gc.Tempname(&t2, gc.Types[gc.TFLOAT32]) cgen(nr, &t1) cgen(nl, &t2) @@ -1184,12 +1120,14 @@ sse: if nl.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) nl = &n1 } if nr.Addable == 0 { + var tmp gc.Node gc.Tempname(&tmp, nr.Type) cgen(nr, &tmp) nr = &tmp @@ -1200,6 +1138,7 @@ nr = &n2 if nl.Op != gc.OREGISTER { + var n3 gc.Node regalloc(&n3, nl.Type, nil) gmove(nl, &n3) nl = &n3 @@ -1207,7 +1146,7 @@ if a == gc.OGE || a == gc.OGT { // only < and <= work right with NaN; reverse if needed - r = nr + r := nr nr = nl nl = r @@ -1223,9 +1162,9 @@ ret: if a == gc.OEQ { // neither NE nor P - p1 = gc.Gbranch(i386.AJNE, nil, -likely) + p1 := gc.Gbranch(i386.AJNE, nil, -likely) - p2 = gc.Gbranch(i386.AJPS, nil, -likely) + p2 := gc.Gbranch(i386.AJPS, nil, -likely) gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to) gc.Patch(p1, gc.Pc) gc.Patch(p2, gc.Pc) @@ -1242,11 +1181,10 @@ // Called after regopt and peep have run. // Expand CHECKNIL pseudo-op into actual nil pointer check. func expandchecks(firstp *obj.Prog) { - var p *obj.Prog var p1 *obj.Prog var p2 *obj.Prog - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.As != obj.ACHECKNIL { continue }
diff --git a/src/cmd/8g/gsubr.go b/src/cmd/8g/gsubr.go index 2728c2a..ac3ad41 100644 --- a/src/cmd/8g/gsubr.go +++ b/src/cmd/8g/gsubr.go
@@ -46,13 +46,11 @@ * return Axxx for Oxxx on type t. */ func optoas(op int, t *gc.Type) int { - var a int - if t == nil { gc.Fatal("optoas: t is nil") } - a = obj.AXXX + a := obj.AXXX switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) { default: gc.Fatal("optoas: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0)) @@ -401,11 +399,8 @@ } func foptoas(op int, t *gc.Type, flg int) int { - var et int - var a int - - a = obj.AXXX - et = int(gc.Simtype[t.Etype]) + a := obj.AXXX + et := int(gc.Simtype[t.Etype]) if gc.Use_sse != 0 { goto sse @@ -564,18 +559,16 @@ } func ginit() { - var i int - - for i = 0; i < len(reg); i++ { + for i := 0; i < len(reg); i++ { reg[i] = 1 } - for i = i386.REG_AX; i <= i386.REG_DI; i++ { + for i := i386.REG_AX; i <= i386.REG_DI; i++ { reg[i] = 0 } - for i = i386.REG_X0; i <= i386.REG_X7; i++ { + for i := i386.REG_X0; i <= i386.REG_X7; i++ { reg[i] = 0 } - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]++ } } @@ -583,18 +576,16 @@ var regpc [i386.MAXREG]uint32 func gclean() { - var i int - - for i = 0; i < len(resvd); i++ { + for i := 0; i < len(resvd); i++ { reg[resvd[i]]-- } - for i = i386.REG_AX; i <= i386.REG_DI; i++ { + for i := i386.REG_AX; i <= i386.REG_DI; i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated at %x", gc.Ctxt.Rconv(i), regpc[i]) } } - for i = i386.REG_X0; i <= i386.REG_X7; i++ { + for i := i386.REG_X0; i <= i386.REG_X7; i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i)) } @@ -602,10 +593,9 @@ } func anyregalloc() bool { - var i int var j int - for i = i386.REG_AX; i <= i386.REG_DI; i++ { + for i := i386.REG_AX; i <= i386.REG_DI; i++ { if reg[i] == 0 { goto ok } @@ -618,7 +608,7 @@ ok: } - for i = i386.REG_X0; i <= i386.REG_X7; i++ { + for i := i386.REG_X0; i <= i386.REG_X7; i++ { if reg[i] != 0 { return true } @@ -632,14 +622,12 @@ * caller must regfree(n). */ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) { - var i int - var et int - if t == nil { gc.Fatal("regalloc: t nil") } - et = int(gc.Simtype[t.Etype]) + et := int(gc.Simtype[t.Etype]) + var i int switch et { case gc.TINT64, gc.TUINT64: @@ -668,7 +656,7 @@ } fmt.Printf("registers allocated at\n") - for i = i386.REG_AX; i <= i386.REG_DI; i++ { + for i := i386.REG_AX; i <= i386.REG_DI; i++ { fmt.Printf("\t%v\t%#x\n", gc.Ctxt.Rconv(i), regpc[i]) } gc.Fatal("out of fixed registers") @@ -694,7 +682,7 @@ } } fmt.Printf("registers allocated at\n") - for i = i386.REG_X0; i <= i386.REG_X7; i++ { + for i := i386.REG_X0; i <= i386.REG_X7; i++ { fmt.Printf("\t%v\t%#x\n", gc.Ctxt.Rconv(i), regpc[i]) } gc.Fatal("out of floating registers") @@ -723,15 +711,13 @@ } func regfree(n *gc.Node) { - var i int - if n.Op == gc.ONAME { return } if n.Op != gc.OREGISTER && n.Op != gc.OINDREG { gc.Fatal("regfree: not a register") } - i = int(n.Val.U.Reg) + i := int(n.Val.U.Reg) if i == i386.REG_SP { return } @@ -764,9 +750,7 @@ * swap node contents */ func nswap(a *gc.Node, b *gc.Node) { - var t gc.Node - - t = *a + t := *a *a = *b *b = t } @@ -794,9 +778,6 @@ * n is a 64-bit value. fill in lo and hi to refer to its 32-bit halves. */ func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) { - var n1 gc.Node - var i int64 - if !gc.Is64(n.Type) { gc.Fatal("split64 %v", gc.Tconv(n.Type, 0)) } @@ -810,6 +791,7 @@ default: switch n.Op { default: + var n1 gc.Node if !dotaddable(n, &n1) { igen(n, &n1, nil) sclean[nsclean-1] = n1 @@ -819,6 +801,7 @@ case gc.ONAME: if n.Class == gc.PPARAMREF { + var n1 gc.Node cgen(n.Heapaddr, &n1) sclean[nsclean-1] = n1 n = &n1 @@ -840,8 +823,9 @@ hi.Xoffset += 4 case gc.OLITERAL: + var n1 gc.Node gc.Convconst(&n1, n.Type, &n.Val) - i = gc.Mpgetfix(n1.Val.U.Xval) + i := gc.Mpgetfix(n1.Val.U.Xval) gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i))) i >>= 32 if n.Type.Etype == gc.TINT64 { @@ -901,25 +885,13 @@ } func gmove(f *gc.Node, t *gc.Node) { - var a int - var ft int - var tt int - var cvt *gc.Type - var r1 gc.Node - var r2 gc.Node - var flo gc.Node - var fhi gc.Node - var tlo gc.Node - var thi gc.Node - var con gc.Node - if gc.Debug['M'] != 0 { fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, 0), gc.Nconv(t, 0)) } - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) + cvt := t.Type if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 { gc.Complexmove(f, t) @@ -933,12 +905,15 @@ // cannot have two integer memory operands; // except 64-bit, which always copies via registers anyway. + var r1 gc.Node + var a int if gc.Isint[ft] != 0 && gc.Isint[tt] != 0 && !gc.Is64(f.Type) && !gc.Is64(t.Type) && gc.Ismem(f) && gc.Ismem(t) { goto hard } // convert constant to desired type if f.Op == gc.OLITERAL { + var con gc.Node gc.Convconst(&con, t.Type, &f.Val) f = &con ft = gc.Simsimtype(con.Type) @@ -980,8 +955,11 @@ gc.TUINT64<<16 | gc.TINT8, gc.TINT64<<16 | gc.TUINT8, gc.TUINT64<<16 | gc.TUINT8: + var flo gc.Node + var fhi gc.Node split64(f, &flo, &fhi) + var r1 gc.Node gc.Nodreg(&r1, t.Type, i386.REG_AX) gmove(&flo, &r1) gins(i386.AMOVB, &r1, t) @@ -1006,8 +984,11 @@ gc.TUINT64<<16 | gc.TINT16, gc.TINT64<<16 | gc.TUINT16, gc.TUINT64<<16 | gc.TUINT16: + var flo gc.Node + var fhi gc.Node split64(f, &flo, &fhi) + var r1 gc.Node gc.Nodreg(&r1, t.Type, i386.REG_AX) gmove(&flo, &r1) gins(i386.AMOVW, &r1, t) @@ -1024,8 +1005,11 @@ gc.TUINT64<<16 | gc.TINT32, gc.TINT64<<16 | gc.TUINT32, gc.TUINT64<<16 | gc.TUINT32: + var fhi gc.Node + var flo gc.Node split64(f, &flo, &fhi) + var r1 gc.Node gc.Nodreg(&r1, t.Type, i386.REG_AX) gmove(&flo, &r1) gins(i386.AMOVL, &r1, t) @@ -1036,14 +1020,20 @@ gc.TINT64<<16 | gc.TUINT64, gc.TUINT64<<16 | gc.TINT64, gc.TUINT64<<16 | gc.TUINT64: + var fhi gc.Node + var flo gc.Node split64(f, &flo, &fhi) + var tlo gc.Node + var thi gc.Node split64(t, &tlo, &thi) if f.Op == gc.OLITERAL { gins(i386.AMOVL, &flo, &tlo) gins(i386.AMOVL, &fhi, &thi) } else { + var r1 gc.Node gc.Nodreg(&r1, gc.Types[gc.TUINT32], i386.REG_AX) + var r2 gc.Node gc.Nodreg(&r2, gc.Types[gc.TUINT32], i386.REG_DX) gins(i386.AMOVL, &flo, &r1) gins(i386.AMOVL, &fhi, &r2) @@ -1118,9 +1108,13 @@ case gc.TINT32<<16 | gc.TINT64, // sign extend int32 gc.TINT32<<16 | gc.TUINT64: + var thi gc.Node + var tlo gc.Node split64(t, &tlo, &thi) + var flo gc.Node gc.Nodreg(&flo, tlo.Type, i386.REG_AX) + var fhi gc.Node gc.Nodreg(&fhi, thi.Type, i386.REG_DX) gmove(f, &flo) gins(i386.ACDQ, nil, nil) @@ -1131,6 +1125,8 @@ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32 gc.TUINT32<<16 | gc.TUINT64: + var tlo gc.Node + var thi gc.Node split64(t, &tlo, &thi) gmove(f, &tlo) @@ -1176,27 +1172,10 @@ func floatmove(f *gc.Node, t *gc.Node) { var r1 gc.Node - var r2 gc.Node - var t1 gc.Node - var t2 gc.Node - var tlo gc.Node - var thi gc.Node - var con gc.Node - var f0 gc.Node - var f1 gc.Node - var ax gc.Node - var dx gc.Node - var cx gc.Node - var cvt *gc.Type - var ft int - var tt int - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) + cvt := t.Type // cannot have two floating point memory operands. if gc.Isfloat[ft] != 0 && gc.Isfloat[tt] != 0 && gc.Ismem(f) && gc.Ismem(t) { @@ -1205,6 +1184,7 @@ // convert constant to desired type if f.Op == gc.OLITERAL { + var con gc.Node gc.Convconst(&con, t.Type, &f.Val) f = &con ft = gc.Simsimtype(con.Type) @@ -1242,6 +1222,7 @@ goto hardmem } + var r1 gc.Node gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0) if ft == gc.TFLOAT32 { gins(i386.AFMOVF, f, &r1) @@ -1250,8 +1231,10 @@ } // set round to zero mode during conversion + var t1 gc.Node memname(&t1, gc.Types[gc.TUINT16]) + var t2 gc.Node memname(&t2, gc.Types[gc.TUINT16]) gins(i386.AFSTCW, nil, &t1) gins(i386.AMOVW, ncon(0xf7f), &t2) @@ -1274,8 +1257,11 @@ } bignodes() + var f0 gc.Node gc.Nodreg(&f0, gc.Types[ft], i386.REG_F0) + var f1 gc.Node gc.Nodreg(&f1, gc.Types[ft], i386.REG_F0+1) + var ax gc.Node gc.Nodreg(&ax, gc.Types[gc.TUINT16], i386.REG_AX) if ft == gc.TFLOAT32 { @@ -1288,15 +1274,17 @@ gins(i386.AFMOVD, &zerof, &f0) gins(i386.AFUCOMIP, &f0, &f1) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0) + p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0) // if 1<<64 <= v { answer = 0 too } gins(i386.AFMOVD, &two64f, &f0) gins(i386.AFUCOMIP, &f0, &f1) - p2 = gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0) + p2 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0) gc.Patch(p1, gc.Pc) gins(i386.AFMOVVP, &f0, t) // don't care about t, but will pop the stack + var thi gc.Node + var tlo gc.Node split64(t, &tlo, &thi) gins(i386.AMOVL, ncon(0), &tlo) gins(i386.AMOVL, ncon(0), &thi) @@ -1309,8 +1297,10 @@ // otherwise, subtract 2^63, convert, and add it back. // set round to zero mode during conversion + var t1 gc.Node memname(&t1, gc.Types[gc.TUINT16]) + var t2 gc.Node memname(&t2, gc.Types[gc.TUINT16]) gins(i386.AFSTCW, nil, &t1) gins(i386.AMOVW, ncon(0xf7f), &t2) @@ -1322,7 +1312,7 @@ gins(i386.AFUCOMIP, &f0, &f1) p2 = gc.Gbranch(optoas(gc.OLE, gc.Types[tt]), nil, 0) gins(i386.AFMOVVP, &f0, t) - p3 = gc.Gbranch(obj.AJMP, nil, 0) + p3 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p2, gc.Pc) gins(i386.AFMOVD, &two63f, &f0) gins(i386.AFSUBDP, &f0, &f1) @@ -1346,6 +1336,7 @@ if t.Op == gc.OREGISTER { goto hardmem } + var f0 gc.Node gc.Nodreg(&f0, t.Type, i386.REG_F0) gins(i386.AFMOVV, f, &f0) if tt == gc.TFLOAT32 { @@ -1360,17 +1351,24 @@ // otherwise, halve (rounding to odd?), convert, and double. case gc.TUINT64<<16 | gc.TFLOAT32, gc.TUINT64<<16 | gc.TFLOAT64: + var ax gc.Node gc.Nodreg(&ax, gc.Types[gc.TUINT32], i386.REG_AX) + var dx gc.Node gc.Nodreg(&dx, gc.Types[gc.TUINT32], i386.REG_DX) + var cx gc.Node gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX) + var t1 gc.Node gc.Tempname(&t1, f.Type) + var tlo gc.Node + var thi gc.Node split64(&t1, &tlo, &thi) gmove(f, &t1) gins(i386.ACMPL, &thi, ncon(0)) - p1 = gc.Gbranch(i386.AJLT, nil, 0) + p1 := gc.Gbranch(i386.AJLT, nil, 0) // native + var r1 gc.Node gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0) gins(i386.AFMOVV, &t1, &r1) @@ -1379,7 +1377,7 @@ } else { gins(i386.AFMOVDP, &r1, t) } - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) // simulated gc.Patch(p1, gc.Pc) @@ -1396,6 +1394,7 @@ gmove(&dx, &thi) gmove(&ax, &tlo) gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0) + var r2 gc.Node gc.Nodreg(&r2, gc.Types[tt], i386.REG_F0+1) gins(i386.AFMOVV, &t1, &r1) gins(i386.AFMOVD, &r1, &r1) @@ -1430,19 +1429,11 @@ func floatmove_387(f *gc.Node, t *gc.Node) { var r1 gc.Node - var t1 gc.Node - var t2 gc.Node - var cvt *gc.Type - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog var a int - var ft int - var tt int - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) + cvt := t.Type switch uint32(ft)<<16 | uint32(tt) { default: @@ -1460,6 +1451,7 @@ if t.Op == gc.OREGISTER { goto hardmem } + var r1 gc.Node gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0) if f.Op != gc.OREGISTER { if ft == gc.TFLOAT32 { @@ -1470,8 +1462,10 @@ } // set round to zero mode during conversion + var t1 gc.Node memname(&t1, gc.Types[gc.TUINT16]) + var t2 gc.Node memname(&t2, gc.Types[gc.TUINT16]) gins(i386.AFSTCW, nil, &t1) gins(i386.AMOVW, ncon(0xf7f), &t2) @@ -1493,6 +1487,7 @@ gc.TFLOAT64<<16 | gc.TINT8, gc.TFLOAT64<<16 | gc.TUINT16, gc.TFLOAT64<<16 | gc.TUINT8: + var t1 gc.Node gc.Tempname(&t1, gc.Types[gc.TINT32]) gmove(f, &t1) @@ -1502,10 +1497,10 @@ case gc.TINT8: gins(i386.ACMPL, &t1, ncon(-0x80&(1<<32-1))) - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TINT32]), nil, -1) + p1 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TINT32]), nil, -1) gins(i386.ACMPL, &t1, ncon(0x7f)) - p2 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TINT32]), nil, -1) - p3 = gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TINT32]), nil, -1) + p3 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) gc.Patch(p2, gc.Pc) gmove(ncon(-0x80&(1<<32-1)), &t1) @@ -1514,14 +1509,14 @@ case gc.TUINT8: gins(i386.ATESTL, ncon(0xffffff00), &t1) - p1 = gc.Gbranch(i386.AJEQ, nil, +1) + p1 := gc.Gbranch(i386.AJEQ, nil, +1) gins(i386.AMOVL, ncon(0), &t1) gc.Patch(p1, gc.Pc) gmove(&t1, t) case gc.TUINT16: gins(i386.ATESTL, ncon(0xffff0000), &t1) - p1 = gc.Gbranch(i386.AJEQ, nil, +1) + p1 := gc.Gbranch(i386.AJEQ, nil, +1) gins(i386.AMOVL, ncon(0), &t1) gc.Patch(p1, gc.Pc) gmove(&t1, t) @@ -1640,6 +1635,7 @@ goto hard } if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER { + var r1 gc.Node gc.Tempname(&r1, gc.Types[gc.TFLOAT32]) gins(i386.AFMOVFP, f, &r1) gins(i386.AFMOVF, &r1, t) @@ -1685,11 +1681,9 @@ var r1 gc.Node var cvt *gc.Type var a int - var ft int - var tt int - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) + ft := gc.Simsimtype(f.Type) + tt := gc.Simsimtype(t.Type) switch uint32(ft)<<16 | uint32(tt) { // should not happen @@ -1829,11 +1823,6 @@ * as f, t */ func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog { - var p *obj.Prog - var af obj.Addr - var at obj.Addr - var w int - if as == i386.AFMOVF && f != nil && f.Op == gc.OREGISTER && t != nil && t.Op == gc.OREGISTER { gc.Fatal("gins MOVF reg, reg") } @@ -1858,15 +1847,15 @@ } } - af = obj.Addr{} - at = obj.Addr{} + af := obj.Addr{} + at := obj.Addr{} if f != nil { gc.Naddr(f, &af, 1) } if t != nil { gc.Naddr(t, &at, 1) } - p = gc.Prog(as) + p := gc.Prog(as) if f != nil { p.From = af } @@ -1877,7 +1866,7 @@ fmt.Printf("%v\n", p) } - w = 0 + w := 0 switch as { case i386.AMOVB: w = 1 @@ -1903,15 +1892,13 @@ } func dotaddable(n *gc.Node, n1 *gc.Node) bool { - var o int - var oary [10]int64 - var nn *gc.Node - if n.Op != gc.ODOT { return false } - o = gc.Dotoffset(n, oary[:], &nn) + var oary [10]int64 + var nn *gc.Node + o := gc.Dotoffset(n, oary[:], &nn) if nn != nil && nn.Addable != 0 && o == 1 && oary[0] >= 0 { *n1 = *nn n1.Type = n.Type
diff --git a/src/cmd/8g/peep.go b/src/cmd/8g/peep.go index 0838882..8aa6e94 100644 --- a/src/cmd/8g/peep.go +++ b/src/cmd/8g/peep.go
@@ -63,10 +63,9 @@ } func rnops(r *gc.Flow) *gc.Flow { - var p *obj.Prog - var r1 *gc.Flow - if r != nil { + var p *obj.Prog + var r1 *gc.Flow for { p = r.Prog if p.As != obj.ANOP || p.From.Type != obj.TYPE_NONE || p.To.Type != obj.TYPE_NONE { @@ -84,14 +83,7 @@ } func peep(firstp *obj.Prog) { - var r *gc.Flow - var r1 *gc.Flow - var g *gc.Graph - var p *obj.Prog - var p1 *obj.Prog - var t int - - g = gc.Flowstart(firstp, nil) + g := gc.Flowstart(firstp, nil) if g == nil { return } @@ -104,7 +96,8 @@ // find MOV $con,R followed by // another MOV $con,R without // setting R in the interim - for r = g.Start; r != nil; r = r.Link { + var p *obj.Prog + for r := g.Start; r != nil; r = r.Link { p = r.Prog switch p.As { case i386.ALEAL: @@ -129,6 +122,10 @@ } } + var r1 *gc.Flow + var p1 *obj.Prog + var r *gc.Flow + var t int loop1: if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { gc.Dumpit("loop1", g.Start, 0) @@ -229,7 +226,7 @@ // can be replaced by MOVAPD, which moves the pair of float64s // instead of just the lower one. We only use the lower one, but // the processor can do better if we do moves using both. - for r = g.Start; r != nil; r = r.Link { + for r := g.Start; r != nil; r = r.Link { p = r.Prog if p.As == i386.AMOVSD { if regtyp(&p.From) { @@ -244,9 +241,7 @@ } func excise(r *gc.Flow) { - var p *obj.Prog - - p = r.Prog + p := r.Prog if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("%v ===delete===\n", p) } @@ -269,9 +264,8 @@ // causing any trouble. func elimshortmov(g *gc.Graph) { var p *obj.Prog - var r *gc.Flow - for r = g.Start; r != nil; r = r.Link { + for r := g.Start; r != nil; r = r.Link { p = r.Prog if regtyp(&p.To) { switch p.As { @@ -367,22 +361,17 @@ * will be eliminated by copy propagation. */ func subprop(r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - var r *gc.Flow - var t int - var info gc.ProgInfo - - p = r0.Prog - v1 = &p.From + p := r0.Prog + v1 := &p.From if !regtyp(v1) { return false } - v2 = &p.To + v2 := &p.To if !regtyp(v2) { return false } + var info gc.ProgInfo + var r *gc.Flow for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) { if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("\t? %v\n", r.Prog) @@ -436,7 +425,7 @@ } } - t = int(v1.Reg) + t := int(v1.Reg) v1.Reg = v2.Reg v2.Reg = int16(t) if gc.Debug['P'] != 0 { @@ -458,13 +447,9 @@ * set v2 return success */ func copyprop(g *gc.Graph, r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - - p = r0.Prog - v1 = &p.From - v2 = &p.To + p := r0.Prog + v1 := &p.From + v2 := &p.To if copyas(v1, v2) { return true } @@ -473,9 +458,6 @@ } func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) bool { - var t int - var p *obj.Prog - if uint32(r.Active) == gactive { if gc.Debug['P'] != 0 { fmt.Printf("act set; return 1\n") @@ -487,6 +469,8 @@ if gc.Debug['P'] != 0 { fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f) } + var t int + var p *obj.Prog for ; r != nil; r = r.S1 { p = r.Prog if gc.Debug['P'] != 0 { @@ -577,8 +561,6 @@ * 0 otherwise (not touched) */ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int { - var info gc.ProgInfo - switch p.As { case obj.AJMP: if s != nil { @@ -632,6 +614,7 @@ if p.As == obj.AVARDEF || p.As == obj.AVARKILL { return 0 } + var info gc.ProgInfo proginfo(&info, p) if (info.Reguse|info.Regset)&RtoB(int(v.Reg)) != 0 { @@ -747,10 +730,8 @@ * return failure to substitute */ func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int { - var reg int - if copyas(a, v) { - reg = int(s.Reg) + reg := int(s.Reg) if reg >= i386.REG_AX && reg <= i386.REG_DI || reg >= i386.REG_X0 && reg <= i386.REG_X7 { if f != 0 { a.Reg = int16(reg) @@ -761,7 +742,7 @@ } if regtyp(v) { - reg = int(v.Reg) + reg := int(v.Reg) if a.Type == obj.TYPE_MEM && int(a.Reg) == reg { if (s.Reg == i386.REG_BP) && a.Index != obj.TYPE_NONE { return 1 /* can't use BP-base with index */ @@ -786,15 +767,12 @@ } func conprop(r0 *gc.Flow) { - var r *gc.Flow var p *obj.Prog - var p0 *obj.Prog var t int - var v0 *obj.Addr - p0 = r0.Prog - v0 = &p0.To - r = r0 + p0 := r0.Prog + v0 := &p0.To + r := r0 loop: r = gc.Uniqs(r)
diff --git a/src/cmd/8g/reg.go b/src/cmd/8g/reg.go index 76bd260..4d4d9a5 100644 --- a/src/cmd/8g/reg.go +++ b/src/cmd/8g/reg.go
@@ -66,9 +66,7 @@ } func doregbits(r int) uint64 { - var b uint64 - - b = 0 + b := uint64(0) if r >= i386.REG_AX && r <= i386.REG_DI { b |= RtoB(r) } else if r >= i386.REG_AL && r <= i386.REG_BL {
diff --git a/src/cmd/9g/cgen.go b/src/cmd/9g/cgen.go index 7a1e967..74accf2 100644 --- a/src/cmd/9g/cgen.go +++ b/src/cmd/9g/cgen.go
@@ -20,24 +20,17 @@ * simplifies and calls gmove. */ func cgen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var a int - var f int - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var addr obj.Addr - //print("cgen %N(%d) -> %N(%d)\n", n, n->addable, res, res->addable); if gc.Debug['g'] != 0 { gc.Dump("\ncgen-n", n) gc.Dump("cgen-res", res) } + var a int + var nr *gc.Node + var nl *gc.Node + var n1 gc.Node + var n2 gc.Node if n == nil || n.Type == nil { goto ret } @@ -57,6 +50,7 @@ gc.OSLICE3, gc.OSLICE3ARR: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) cgen(&n1, res) @@ -67,6 +61,7 @@ case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) cgen(&n1, res) @@ -81,6 +76,7 @@ gc.Fatal("cgen: this is going to misscompile") } if res.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) @@ -98,6 +94,7 @@ if res.Addable == 0 { if n.Ullman > res.Ullman { + var n1 gc.Node regalloc(&n1, n.Type, res) cgen(n, &n1) if n1.Ullman > res.Ullman { @@ -111,6 +108,7 @@ goto ret } + var f int if res.Ullman >= gc.UINF { goto gen } @@ -132,9 +130,12 @@ } if gc.Iscomplex[n.Type.Etype] == 0 { - a = optoas(gc.OAS, res.Type) + a := optoas(gc.OAS, res.Type) + var addr obj.Addr if sudoaddable(a, res, &addr) { + var p1 *obj.Prog if f != 0 { + var n2 gc.Node regalloc(&n2, res.Type, nil) cgen(n, &n2) p1 = gins(a, &n2, nil) @@ -152,6 +153,7 @@ } gen: + var n1 gc.Node igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) @@ -187,6 +189,7 @@ if n.Op == gc.OREGISTER || res.Op == gc.OREGISTER { gmove(n, res) } else { + var n1 gc.Node regalloc(&n1, n.Type, nil) gmove(n, &n1) cgen(&n1, res) @@ -201,9 +204,10 @@ if nl != nil && nl.Ullman >= gc.UINF { if nr != nil && nr.Ullman >= gc.UINF { + var n1 gc.Node gc.Tempname(&n1, nl.Type) cgen(nl, &n1) - n2 = *n + n2 := *n n2.Left = &n1 cgen(&n2, res) goto ret @@ -211,14 +215,16 @@ } if gc.Iscomplex[n.Type.Etype] == 0 { - a = optoas(gc.OAS, n.Type) + a := optoas(gc.OAS, n.Type) + var addr obj.Addr if sudoaddable(a, n, &addr) { if res.Op == gc.OREGISTER { - p1 = gins(a, nil, res) + p1 := gins(a, nil, res) p1.From = addr } else { + var n2 gc.Node regalloc(&n2, n.Type, nil) - p1 = gins(a, nil, &n2) + p1 := gins(a, nil, &n2) p1.From = addr gins(a, &n2, res) regfree(&n2) @@ -248,11 +254,11 @@ gc.OGE, gc.OGT, gc.ONOT: - p1 = gc.Gbranch(ppc64.ABR, nil, 0) + p1 := gc.Gbranch(ppc64.ABR, nil, 0) - p2 = gc.Pc + p2 := gc.Pc gmove(gc.Nodbool(true), res) - p3 = gc.Gbranch(ppc64.ABR, nil, 0) + p3 := gc.Gbranch(ppc64.ABR, nil, 0) gc.Patch(p1, gc.Pc) bgen(n, true, 0, p2) gmove(gc.Nodbool(false), res) @@ -265,10 +271,12 @@ // unary case gc.OCOM: - a = optoas(gc.OXOR, nl.Type) + a := optoas(gc.OXOR, nl.Type) + var n1 gc.Node regalloc(&n1, nl.Type, nil) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, nl.Type, -1) gins(a, &n2, &n1) gmove(&n1, res) @@ -315,7 +323,9 @@ gc.OINDEX, gc.OIND, gc.ONAME: + var n1 gc.Node igen(nl, &n1, res) + var n2 gc.Node regalloc(&n2, n.Type, res) gmove(&n1, &n2) gmove(&n2, res) @@ -325,7 +335,9 @@ } } + var n1 gc.Node regalloc(&n1, nl.Type, res) + var n2 gc.Node regalloc(&n2, n.Type, &n1) cgen(nl, &n1) @@ -343,6 +355,7 @@ gc.OINDEX, gc.OIND, gc.ONAME: // PHEAP or PPARAMREF var + var n1 gc.Node igen(n, &n1, res) gmove(&n1, res) @@ -350,6 +363,7 @@ // interface table is first word of interface value case gc.OITAB: + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type @@ -359,14 +373,16 @@ // pointer is the first word of string or slice. case gc.OSPTR: if gc.Isconst(nl, gc.CTSTR) { + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) - p1 = gins(ppc64.AMOVD, nil, &n1) + p1 := gins(ppc64.AMOVD, nil, &n1) gc.Datastring(nl.Val.U.Sval.S, &p1.From) gmove(&n1, res) regfree(&n1) break } + var n1 gc.Node igen(nl, &n1, res) n1.Type = n.Type gmove(&n1, res) @@ -376,13 +392,15 @@ if gc.Istype(nl.Type, gc.TMAP) || gc.Istype(nl.Type, gc.TCHAN) { // map and chan have len in the first int-sized word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) n2 = n1 n2.Op = gc.OINDREG @@ -399,6 +417,7 @@ if gc.Istype(nl.Type, gc.TSTRING) || gc.Isslice(nl.Type) { // both slice and string have len one pointer into the struct. // a zero pointer means zero length + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.Simtype[gc.TUINT]] @@ -414,13 +433,15 @@ if gc.Istype(nl.Type, gc.TCHAN) { // chan has cap in the second int-sized word. // a zero pointer means zero length + var n1 gc.Node regalloc(&n1, gc.Types[gc.Tptr], res) cgen(nl, &n1) + var n2 gc.Node gc.Nodconst(&n2, gc.Types[gc.Tptr], 0) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2) - p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) + p1 := gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0) n2 = n1 n2.Op = gc.OINDREG @@ -436,6 +457,7 @@ } if gc.Isslice(nl.Type) { + var n1 gc.Node igen(nl, &n1, res) n1.Type = gc.Types[gc.Simtype[gc.TUINT]] n1.Xoffset += int64(gc.Array_cap) @@ -475,11 +497,13 @@ } if nl.Ullman >= nr.Ullman { + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) cgen_div(int(n.Op), &n1, nr, res) regfree(&n1) } else { + var n2 gc.Node if !gc.Smallintconst(nr) { regalloc(&n2, nr.Type, res) cgen(nr, &n2) @@ -519,7 +543,7 @@ */ sbop: // symmetric binary if nl.Ullman < nr.Ullman || (nl.Ullman == nr.Ullman && (gc.Smallintconst(nl) || (nr.Op == gc.OLITERAL && !gc.Smallintconst(nr)))) { - r = nl + r := nl nl = nr nr = r } @@ -606,8 +630,6 @@ * The caller must call regfree(a). */ func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("cgenr-n", n) } @@ -630,6 +652,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) gmove(&n1, a) @@ -648,24 +671,12 @@ * The generated code checks that the result is not nil. */ func agenr(n *gc.Node, a *gc.Node, res *gc.Node) { - var nl *gc.Node - var nr *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var n4 gc.Node - var tmp gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - var w uint32 - var v uint64 - if gc.Debug['g'] != 0 { gc.Dump("agenr-n", n) } - nl = n.Left - nr = n.Right + nl := n.Left + nr := n.Right switch n.Op { case gc.ODOT, @@ -673,6 +684,7 @@ gc.OCALLFUNC, gc.OCALLMETH, gc.OCALLINTER: + var n1 gc.Node igen(n, &n1, res) regalloc(a, gc.Types[gc.Tptr], &n1) agen(&n1, a) @@ -683,11 +695,14 @@ gc.Cgen_checknil(a) case gc.OINDEX: - p2 = nil // to be patched to panicindex. - w = uint32(n.Type.Width) + p2 := (*obj.Prog)(nil) // to be patched to panicindex. + w := uint32(n.Type.Width) //bounded = debug['B'] || n->bounded; + var n3 gc.Node + var n1 gc.Node if nr.Addable != 0 { + var tmp gc.Node if !gc.Isconst(nr, gc.CTINT) { gc.Tempname(&tmp, gc.Types[gc.TINT64]) } @@ -701,6 +716,7 @@ } } else if nl.Addable != 0 { if !gc.Isconst(nr, gc.CTINT) { + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT64]) cgen(nr, &tmp) regalloc(&n1, tmp.Type, nil) @@ -711,6 +727,7 @@ agenr(nl, &n3, res) } } else { + var tmp gc.Node gc.Tempname(&tmp, gc.Types[gc.TINT64]) cgen(nr, &tmp) nr = &tmp @@ -730,18 +747,19 @@ if gc.Isconst(nl, gc.CTSTR) { gc.Fatal("constant string constant index") } - v = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + v := uint64(gc.Mpgetfix(nr.Val.U.Xval)) if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { if gc.Debug['B'] == 0 && !n.Bounded { n1 = n3 n1.Op = gc.OINDREG n1.Type = gc.Types[gc.Tptr] n1.Xoffset = int64(gc.Array_nel) + var n4 gc.Node regalloc(&n4, n1.Type, nil) gmove(&n1, &n4) ginscon2(optoas(gc.OCMP, gc.Types[gc.TUINT64]), &n4, int64(v)) regfree(&n4) - p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT64]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT64]), nil, +1) ginscall(gc.Panicindex, 0) gc.Patch(p1, gc.Pc) } @@ -761,10 +779,12 @@ break } + var n2 gc.Node regalloc(&n2, gc.Types[gc.TINT64], &n1) // i gmove(&n1, &n2) regfree(&n1) + var n4 gc.Node if gc.Debug['B'] == 0 && !n.Bounded { // check bounds if gc.Isconst(nl, gc.CTSTR) { @@ -781,7 +801,7 @@ gc.Nodconst(&n4, gc.Types[gc.TUINT64], nl.Type.Bound) } else { regalloc(&n4, gc.Types[gc.TUINT64], nil) - p1 = gins(ppc64.AMOVD, nil, &n4) + p1 := gins(ppc64.AMOVD, nil, &n4) p1.From.Type = obj.TYPE_CONST p1.From.Offset = nl.Type.Bound } @@ -791,7 +811,7 @@ if n4.Op == gc.OREGISTER { regfree(&n4) } - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1) + p1 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1) if p2 != nil { gc.Patch(p2, gc.Pc) } @@ -801,7 +821,7 @@ if gc.Isconst(nl, gc.CTSTR) { regalloc(&n3, gc.Types[gc.Tptr], res) - p1 = gins(ppc64.AMOVD, nil, &n3) + p1 := gins(ppc64.AMOVD, nil, &n3) gc.Datastring(nl.Val.U.Sval.S, &p1.From) p1.From.Type = obj.TYPE_ADDR } else if gc.Isslice(nl.Type) || nl.Type.Etype == gc.TSTRING { @@ -854,11 +874,6 @@ * The generated code checks that the result is not nil. */ func agen(n *gc.Node, res *gc.Node) { - var nl *gc.Node - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("\nagen-res", res) gc.Dump("agen-r", n) @@ -872,17 +887,20 @@ n = n.Left } + var nl *gc.Node if gc.Isconst(n, gc.CTNIL) && n.Type.Width > int64(gc.Widthptr) { // Use of a nil interface or nil slice. // Create a temporary we can take the address of and read. // The generated code is just going to panic, so it need not // be terribly efficient. See issue 3670. + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Gvardef(&n1) clearfat(&n1) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) - n3 = gc.Node{} + n3 := gc.Node{} n3.Op = gc.OADDR n3.Left = &n1 gins(ppc64.AMOVD, &n3, &n2) @@ -892,9 +910,10 @@ } if n.Addable != 0 { - n1 = gc.Node{} + n1 := gc.Node{} n1.Op = gc.OADDR n1.Left = n + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], res) gins(ppc64.AMOVD, &n1, &n2) gmove(&n2, res) @@ -928,16 +947,19 @@ gc.OSLICESTR, gc.OSLICE3, gc.OSLICE3ARR: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_slice(n, &n1) agen(&n1, res) case gc.OEFACE: + var n1 gc.Node gc.Tempname(&n1, n.Type) gc.Cgen_eface(n, &n1) agen(&n1, res) case gc.OINDEX: + var n1 gc.Node agenr(n, &n1, res) gmove(&n1, res) regfree(&n1) @@ -991,10 +1013,6 @@ * The generated code checks that the result is not *nil. */ func igen(n *gc.Node, a *gc.Node, res *gc.Node) { - var fp *gc.Type - var flist gc.Iter - var n1 gc.Node - if gc.Debug['g'] != 0 { gc.Dump("\nigen-n", n) } @@ -1046,7 +1064,8 @@ cgen_callinter(n, nil, 0) } - fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type)) *a = gc.Node{} a.Op = gc.OINDREG a.Val.U.Reg = ppc64.REGSP @@ -1066,6 +1085,7 @@ if gc.Isptr[n.Left.Type.Etype] == 0 { igen(n.Left, a, res) } else { + var n1 gc.Node igen(n.Left, &n1, res) gc.Cgen_checknil(&n1) regalloc(a, gc.Types[gc.Tptr], res) @@ -1094,19 +1114,6 @@ * if(n == true) goto to; */ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { - var et int - var a int - var nl *gc.Node - var nr *gc.Node - var l *gc.Node - var r *gc.Node - var n1 gc.Node - var n2 gc.Node - var tmp gc.Node - var ll *gc.NodeList - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['g'] != 0 { gc.Dump("\nbgen", n) } @@ -1119,6 +1126,9 @@ gc.Genlist(n.Ninit) } + var et int + var nl *gc.Node + var nr *gc.Node if n.Type == nil { gc.Convlit(&n, gc.Types[gc.TBOOL]) if n.Type == nil { @@ -1144,11 +1154,13 @@ switch n.Op { default: + var n1 gc.Node regalloc(&n1, n.Type, nil) cgen(n, &n1) + var n2 gc.Node gc.Nodconst(&n2, n.Type, 0) gins(optoas(gc.OCMP, n.Type), &n1, &n2) - a = ppc64.ABNE + a := ppc64.ABNE if !true_ { a = ppc64.ABEQ } @@ -1166,8 +1178,8 @@ case gc.OANDAND, gc.OOROR: if (n.Op == gc.OANDAND) == true_ { - p1 = gc.Gbranch(obj.AJMP, nil, 0) - p2 = gc.Gbranch(obj.AJMP, nil, 0) + p1 := gc.Gbranch(obj.AJMP, nil, 0) + p2 := gc.Gbranch(obj.AJMP, nil, 0) gc.Patch(p1, gc.Pc) bgen(n.Left, !true_, -likely, p2) bgen(n.Right, !true_, -likely, p2) @@ -1212,15 +1224,15 @@ gc.OGT, gc.OLE, gc.OGE: - a = int(n.Op) + a := int(n.Op) if !true_ { if gc.Isfloat[nr.Type.Etype] != 0 { // brcom is not valid on floats when NaN is involved. - p1 = gc.Gbranch(ppc64.ABR, nil, 0) + p1 := gc.Gbranch(ppc64.ABR, nil, 0) - p2 = gc.Gbranch(ppc64.ABR, nil, 0) + p2 := gc.Gbranch(ppc64.ABR, nil, 0) gc.Patch(p1, gc.Pc) - ll = n.Ninit // avoid re-genning ninit + ll := n.Ninit // avoid re-genning ninit n.Ninit = nil bgen(n, true, -likely, p2) n.Ninit = ll @@ -1236,7 +1248,7 @@ // make simplest on right if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) { a = gc.Brrev(a) - r = nl + r := nl nl = nr nr = r } @@ -1249,10 +1261,13 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Xoffset += int64(gc.Array_array) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], &n1) gmove(&n1, &n2) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n2, &tmp) @@ -1270,9 +1285,12 @@ } a = optoas(a, gc.Types[gc.Tptr]) + var n1 gc.Node igen(nl, &n1, nil) n1.Type = gc.Types[gc.Tptr] + var tmp gc.Node gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0) + var n2 gc.Node regalloc(&n2, gc.Types[gc.Tptr], &n1) gmove(&n1, &n2) gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n2, &tmp) @@ -1287,10 +1305,13 @@ break } + var n1 gc.Node + var n2 gc.Node if nr.Ullman >= gc.UINF { regalloc(&n1, nl.Type, nil) cgen(nl, &n1) + var tmp gc.Node gc.Tempname(&tmp, nl.Type) gmove(&n1, &tmp) regfree(&n1) @@ -1321,8 +1342,8 @@ cgen(nr, &n2) cmp: - l = &n1 - r = &n2 + l := &n1 + r := &n2 gins(optoas(gc.OCMP, nr.Type), l, r) if gc.Isfloat[nr.Type.Etype] != 0 && (a == gc.OLE || a == gc.OGE) { // To get NaN right, must rewrite x <= y into separate x < y or x = y. @@ -1355,31 +1376,27 @@ * return n's offset from SP. */ func stkof(n *gc.Node) int64 { - var t *gc.Type - var flist gc.Iter - var off int64 - switch n.Op { case gc.OINDREG: return n.Xoffset case gc.ODOT: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } return off + n.Xoffset case gc.OINDEX: - t = n.Left.Type + t := n.Left.Type if !gc.Isfixedarray(t) { break } - off = stkof(n.Left) + off := stkof(n.Left) if off == -1000 || off == 1000 { return off } @@ -1391,11 +1408,12 @@ case gc.OCALLMETH, gc.OCALLINTER, gc.OCALLFUNC: - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } + var flist gc.Iter t = gc.Structfirst(&flist, gc.Getoutarg(t)) if t != nil { return t.Width + int64(gc.Widthptr) // +widthptr: correct for saved LR @@ -1412,19 +1430,6 @@ * memmove(&ns, &n, w); */ func sgen(n *gc.Node, ns *gc.Node, w int64) { - var dst gc.Node - var src gc.Node - var tmp gc.Node - var nend gc.Node - var c int32 - var odst int32 - var osrc int32 - var dir int - var align int - var op int - var p *obj.Prog - var ploop *obj.Prog - var l *gc.NodeList var res *gc.Node = ns if gc.Debug['g'] != 0 { @@ -1444,7 +1449,7 @@ // If copying .args, that's all the results, so record definition sites // for them for the liveness analysis. if ns.Op == gc.ONAME && ns.Sym.Name == ".args" { - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { if l.N.Class == gc.PPARAMOUT { gc.Gvardef(l.N) } @@ -1456,6 +1461,7 @@ // return; if w == 0 { // evaluate side effects only. + var dst gc.Node regalloc(&dst, gc.Types[gc.Tptr], nil) agen(res, &dst) @@ -1468,8 +1474,9 @@ // want to avoid unaligned access, so have to use // smaller operations for less aligned types. // for example moving [4]byte must use 4 MOVB not 1 MOVW. - align = int(n.Type.Align) + align := int(n.Type.Align) + var op int switch align { default: gc.Fatal("sgen: invalid alignment %d for %v", align, gc.Tconv(n.Type, 0)) @@ -1490,17 +1497,18 @@ if w%int64(align) != 0 { gc.Fatal("sgen: unaligned size %d (align=%d) for %v", w, align, gc.Tconv(n.Type, 0)) } - c = int32(w / int64(align)) + c := int32(w / int64(align)) // offset on the stack - osrc = int32(stkof(n)) + osrc := int32(stkof(n)) - odst = int32(stkof(res)) + odst := int32(stkof(res)) if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) { // osrc and odst both on stack, and at least one is in // an unknown position. Could generate code to test // for forward/backward copy, but instead just copy // to a temporary location first. + var tmp gc.Node gc.Tempname(&tmp, n.Type) sgen(n, &tmp, w) @@ -1514,12 +1522,14 @@ // if we are copying forward on the stack and // the src and dst overlap, then reverse direction - dir = align + dir := align if osrc < odst && int64(odst) < int64(osrc)+w { dir = -dir } + var dst gc.Node + var src gc.Node if n.Ullman >= res.Ullman { agenr(n, &dst, res) // temporarily use dst regalloc(&src, gc.Types[gc.Tptr], nil) @@ -1536,19 +1546,20 @@ agenr(n, &src, nil) } + var tmp gc.Node regalloc(&tmp, gc.Types[gc.Tptr], nil) // set up end marker - nend = gc.Node{} + nend := gc.Node{} // move src and dest to the end of block if necessary if dir < 0 { if c >= 4 { regalloc(&nend, gc.Types[gc.Tptr], nil) - p = gins(ppc64.AMOVD, &src, &nend) + gins(ppc64.AMOVD, &src, &nend) } - p = gins(ppc64.AADD, nil, &src) + p := gins(ppc64.AADD, nil, &src) p.From.Type = obj.TYPE_CONST p.From.Offset = w @@ -1556,7 +1567,7 @@ p.From.Type = obj.TYPE_CONST p.From.Offset = w } else { - p = gins(ppc64.AADD, nil, &src) + p := gins(ppc64.AADD, nil, &src) p.From.Type = obj.TYPE_CONST p.From.Offset = int64(-dir) @@ -1566,7 +1577,7 @@ if c >= 4 { regalloc(&nend, gc.Types[gc.Tptr], nil) - p = gins(ppc64.AMOVD, &src, &nend) + p := gins(ppc64.AMOVD, &src, &nend) p.From.Type = obj.TYPE_ADDR p.From.Offset = w } @@ -1575,10 +1586,10 @@ // move // TODO: enable duffcopy for larger copies. if c >= 4 { - p = gins(op, &src, &tmp) + p := gins(op, &src, &tmp) p.From.Type = obj.TYPE_MEM p.From.Offset = int64(dir) - ploop = p + ploop := p p = gins(op, &tmp, &dst) p.To.Type = obj.TYPE_MEM @@ -1594,6 +1605,7 @@ // generate the offsets directly and eliminate the // ADDs. That will produce shorter, more // pipeline-able code. + var p *obj.Prog for { tmp14 := c c-- @@ -1642,23 +1654,16 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool { var nodl gc.Node var nodr gc.Node - var tmp gc.Node - var t *gc.Type - var freel int - var freer int - var fldcount int64 - var loffset int64 - var roffset int64 - freel = 0 - freer = 0 + freel := 0 + freer := 0 switch nl.Type.Etype { default: goto no case gc.TARRAY: - t = nl.Type + t := nl.Type // Slices are ok. if gc.Isslice(t) { @@ -1675,9 +1680,9 @@ // Small structs with non-fat types are ok. // Zero-sized structs are treated separately elsewhere. case gc.TSTRUCT: - fldcount = 0 + fldcount := int64(0) - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { if gc.Isfat(t.Type) { goto no } @@ -1713,6 +1718,7 @@ } } else { // When zeroing, prepare a register containing zero. + var tmp gc.Node gc.Nodconst(&tmp, nl.Type, 0) regalloc(&nodr, gc.Types[gc.TUINT], nil) @@ -1734,11 +1740,11 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - t = nl.Type + t := nl.Type if !gc.Isslice(t) { nodl.Type = t.Type nodr.Type = nodl.Type - for fldcount = 0; fldcount < t.Bound; fldcount++ { + for fldcount := int64(0); fldcount < t.Bound; fldcount++ { if nr == nil { gc.Clearslim(&nodl) } else { @@ -1841,8 +1847,8 @@ if nl.Op == gc.ONAME { gc.Gvardef(nl) } - loffset = nodl.Xoffset - roffset = nodr.Xoffset + loffset := nodl.Xoffset + roffset := nodr.Xoffset // funarg structs may not begin at offset zero. if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil { @@ -1852,7 +1858,7 @@ roffset -= nr.Type.Type.Width } - for t = nl.Type.Type; t != nil; t = t.Down { + for t := nl.Type.Type; t != nil; t = t.Down { nodl.Xoffset = loffset + t.Width nodl.Type = t.Type
diff --git a/src/cmd/9g/ggen.go b/src/cmd/9g/ggen.go index 54bebdd..3197e46 100644 --- a/src/cmd/9g/ggen.go +++ b/src/cmd/9g/ggen.go
@@ -12,30 +12,25 @@ import "cmd/internal/gc" func defframe(ptxt *obj.Prog) { - var frame uint32 - var p *obj.Prog - var hi int64 - var lo int64 - var l *gc.NodeList var n *gc.Node // fill in argument size, stack size ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr))) - frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) + frame := uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg))) ptxt.To.Offset = int64(frame) // insert code to zero ambiguously live variables // so that the garbage collector only sees initialized values // when it looks for pointers. - p = ptxt + p := ptxt - hi = 0 - lo = hi + hi := int64(0) + lo := hi // iterate through declarations - they are sorted in decreasing xoffset order. - for l = gc.Curfn.Dcl; l != nil; l = l.Next { + for l := gc.Curfn.Dcl; l != nil; l = l.Next { n = l.N if n.Needzero == 0 { continue @@ -68,24 +63,19 @@ } func zerorange(p *obj.Prog, frame int64, lo int64, hi int64) *obj.Prog { - var cnt int64 - var i int64 - var p1 *obj.Prog - var f *gc.Node - - cnt = hi - lo + cnt := hi - lo if cnt == 0 { return p } if cnt < int64(4*gc.Widthptr) { - for i = 0; i < cnt; i += int64(gc.Widthptr) { + for i := int64(0); i < cnt; i += int64(gc.Widthptr) { p = appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, 8+frame+lo+i) } } else if cnt <= int64(128*gc.Widthptr) { p = appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, ppc64.REGRT1, 0) p.Reg = ppc64.REGSP p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0) - f = gc.Sysfunc("duffzero") + f := gc.Sysfunc("duffzero") gc.Naddr(f, &p.To, 1) gc.Afunclit(&p.To, f) p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr)) @@ -97,7 +87,7 @@ p = appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0) p.Reg = ppc64.REGRT1 p = appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(gc.Widthptr)) - p1 = p + p1 := p p = appendpp(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0) p = appendpp(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0) gc.Patch(p, p1) @@ -107,8 +97,7 @@ } func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog { - var q *obj.Prog - q = gc.Ctxt.NewProg() + q := gc.Ctxt.NewProg() gc.Clearp(q) q.As = int16(as) q.Lineno = p.Lineno @@ -129,8 +118,7 @@ * On power, f must be moved to CTR first. */ func ginsBL(reg *gc.Node, f *gc.Node) { - var p *obj.Prog - p = gins(ppc64.AMOVD, f, nil) + p := gins(ppc64.AMOVD, f, nil) p.To.Type = obj.TYPE_REG p.To.Reg = ppc64.REG_CTR p = gins(ppc64.ABL, reg, nil) @@ -148,15 +136,8 @@ * proc=3 normal call to C pointer (not Go func value) */ func ginscall(f *gc.Node, proc int) { - var p *obj.Prog - var reg gc.Node - var con gc.Node - var reg2 gc.Node - var r1 gc.Node - var extra int32 - if f.Type != nil { - extra = 0 + extra := int32(0) if proc == 1 || proc == 2 { extra = 2 * int32(gc.Widthptr) } @@ -180,12 +161,13 @@ // The ppc64 NOP is really or r0, r0, r0; use that description // because the NOP pseudo-instruction would be removed by // the linker. + var reg gc.Node gc.Nodreg(®, gc.Types[gc.TINT], ppc64.REG_R0) gins(ppc64.AOR, ®, ®) } - p = gins(ppc64.ABL, nil, f) + p := gins(ppc64.ABL, nil, f) gc.Afunclit(&p.To, f) if proc == -1 || gc.Noreturn(p) { gins(obj.AUNDEF, nil, nil) @@ -193,7 +175,9 @@ break } + var reg gc.Node gc.Nodreg(®, gc.Types[gc.Tptr], ppc64.REGCTXT) + var r1 gc.Node gc.Nodreg(&r1, gc.Types[gc.Tptr], ppc64.REG_R3) gmove(f, ®) reg.Op = gc.OINDREG @@ -206,14 +190,17 @@ case 1, // call in new proc (go) 2: // deferred call (defer) + var con gc.Node gc.Nodconst(&con, gc.Types[gc.TINT64], int64(gc.Argsize(f.Type))) + var reg gc.Node gc.Nodreg(®, gc.Types[gc.TINT64], ppc64.REG_R3) + var reg2 gc.Node gc.Nodreg(®2, gc.Types[gc.TINT64], ppc64.REG_R4) gmove(f, ®) gmove(&con, ®2) - p = gins(ppc64.AMOVW, ®2, nil) + p := gins(ppc64.AMOVW, ®2, nil) p.To.Type = obj.TYPE_MEM p.To.Reg = ppc64.REGSP p.To.Offset = 8 @@ -234,7 +221,7 @@ if proc == 2 { gc.Nodreg(®, gc.Types[gc.TINT64], ppc64.REG_R3) - p = gins(ppc64.ACMP, ®, nil) + p := gins(ppc64.ACMP, ®, nil) p.To.Type = obj.TYPE_REG p.To.Reg = ppc64.REG_R0 p = gc.Gbranch(ppc64.ABEQ, nil, +1) @@ -249,21 +236,12 @@ * generate res = n. */ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) { - var i *gc.Node - var f *gc.Node - var tmpi gc.Node - var nodi gc.Node - var nodo gc.Node - var nodr gc.Node - var nodsp gc.Node - var p *obj.Prog - - i = n.Left + i := n.Left if i.Op != gc.ODOTINTER { gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0)) } - f = i.Right // field + f := i.Right // field if f.Op != gc.ONAME { gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0)) } @@ -271,6 +249,7 @@ i = i.Left // interface if i.Addable == 0 { + var tmpi gc.Node gc.Tempname(&tmpi, i.Type) cgen(i, &tmpi) i = &tmpi @@ -280,8 +259,10 @@ // i is now addable, prepare an indirected // register to hold its address. + var nodi gc.Node igen(i, &nodi, res) // REG = &inter + var nodsp gc.Node gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], ppc64.REGSP) nodsp.Xoffset = int64(gc.Widthptr) @@ -292,6 +273,7 @@ nodi.Xoffset += int64(gc.Widthptr) cgen(&nodi, &nodsp) // {8 or 24}(SP) = 8(REG) -- i.data + var nodo gc.Node regalloc(&nodo, gc.Types[gc.Tptr], res) nodi.Type = gc.Types[gc.Tptr] @@ -299,6 +281,7 @@ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab regfree(&nodi) + var nodr gc.Node regalloc(&nodr, gc.Types[gc.Tptr], &nodo) if n.Left.Xoffset == gc.BADWIDTH { gc.Fatal("cgen_callinter: badwidth") @@ -312,7 +295,7 @@ proc = 3 } else { // go/defer. generate go func value. - p = gins(ppc64.AMOVD, &nodo, &nodr) // REG = &(32+offset(REG)) -- i.tab->fun[f] + p := gins(ppc64.AMOVD, &nodo, &nodr) // REG = &(32+offset(REG)) -- i.tab->fun[f] p.From.Type = obj.TYPE_ADDR } @@ -330,14 +313,11 @@ * proc=2 defer call save away stack */ func cgen_call(n *gc.Node, proc int) { - var t *gc.Type - var nod gc.Node - var afun gc.Node - if n == nil { return } + var afun gc.Node if n.Left.Ullman >= gc.UINF { // if name involves a fn call // precompute the address of the fn @@ -347,10 +327,11 @@ } gc.Genlist(n.List) // assign the args - t = n.Left.Type + t := n.Left.Type // call tempname pointer if n.Left.Ullman >= gc.UINF { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, &afun) nod.Type = t @@ -361,6 +342,7 @@ // call pointer if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC { + var nod gc.Node regalloc(&nod, gc.Types[gc.Tptr], nil) gc.Cgen_as(&nod, n.Left) nod.Type = t @@ -381,22 +363,18 @@ * res = return value from call. */ func cgen_callret(n *gc.Node, res *gc.Node) { - var nod gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_callret: nil") } - nod = gc.Node{} + nod := gc.Node{} nod.Op = gc.OINDREG nod.Val.U.Reg = ppc64.REGSP nod.Addable = 1 @@ -412,23 +390,18 @@ * res = &return value from call. */ func cgen_aret(n *gc.Node, res *gc.Node) { - var nod1 gc.Node - var nod2 gc.Node - var fp *gc.Type - var t *gc.Type - var flist gc.Iter - - t = n.Left.Type + t := n.Left.Type if gc.Isptr[t.Etype] != 0 { t = t.Type } - fp = gc.Structfirst(&flist, gc.Getoutarg(t)) + var flist gc.Iter + fp := gc.Structfirst(&flist, gc.Getoutarg(t)) if fp == nil { gc.Fatal("cgen_aret: nil") } - nod1 = gc.Node{} + nod1 := gc.Node{} nod1.Op = gc.OINDREG nod1.Val.U.Reg = ppc64.REGSP nod1.Addable = 1 @@ -437,6 +410,7 @@ nod1.Type = fp.Type if res.Op != gc.OREGISTER { + var nod2 gc.Node regalloc(&nod2, gc.Types[gc.Tptr], res) agen(&nod1, &nod2) gins(ppc64.AMOVD, &nod2, res) @@ -451,8 +425,6 @@ * n->left is assignments to return values. */ func cgen_ret(n *gc.Node) { - var p *obj.Prog - if n != nil { gc.Genlist(n.List) // copy out args } @@ -460,7 +432,7 @@ ginscall(gc.Deferreturn, 0) } gc.Genlist(gc.Curfn.Exit) - p = gins(obj.ARET, nil, nil) + p := gins(obj.ARET, nil, nil) if n != nil && n.Op == gc.ORETJMP { p.To.Name = obj.NAME_EXTERN p.To.Type = obj.TYPE_ADDR @@ -476,20 +448,6 @@ * according to op. */ func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var a int - var check int - var t *gc.Type - var t0 *gc.Type - var tl gc.Node - var tr gc.Node - var tl2 gc.Node - var tr2 gc.Node - var nm1 gc.Node - var nz gc.Node - var tm gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - // Have to be careful about handling // most negative int divided by -1 correctly. // The hardware will generate undefined result. @@ -497,10 +455,10 @@ // the hardware will silently generate undefined result. // DIVW will leave unpredicable result in higher 32-bit, // so always use DIVD/DIVDU. - t = nl.Type + t := nl.Type - t0 = t - check = 0 + t0 := t + check := 0 if gc.Issigned[t.Etype] != 0 { check = 1 if gc.Isconst(nl, gc.CTINT) && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) { @@ -519,9 +477,11 @@ check = 0 } - a = optoas(gc.ODIV, t) + a := optoas(gc.ODIV, t) + var tl gc.Node regalloc(&tl, t0, nil) + var tr gc.Node regalloc(&tr, t0, nil) if nl.Ullman >= nr.Ullman { cgen(nl, &tl) @@ -533,9 +493,9 @@ if t != t0 { // Convert - tl2 = tl + tl2 := tl - tr2 = tr + tr2 := tr tl.Type = t tr.Type = t gmove(&tl2, &tl) @@ -543,7 +503,7 @@ } // Handle divide-by-zero panic. - p1 = gins(optoas(gc.OCMP, t), &tr, nil) + p1 := gins(optoas(gc.OCMP, t), &tr, nil) p1.To.Type = obj.TYPE_REG p1.To.Reg = ppc64.REGZERO @@ -554,10 +514,12 @@ ginscall(panicdiv, -1) gc.Patch(p1, gc.Pc) + var p2 *obj.Prog if check != 0 { + var nm1 gc.Node gc.Nodconst(&nm1, t, -1) gins(optoas(gc.OCMP, t), &tr, &nm1) - p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1) + p1 := gc.Gbranch(optoas(gc.ONE, t), nil, +1) if op == gc.ODIV { // a / (-1) is -a. gins(optoas(gc.OMINUS, t), nil, &tl) @@ -565,6 +527,7 @@ gmove(&tl, res) } else { // a % (-1) is 0. + var nz gc.Node gc.Nodconst(&nz, t, 0) gmove(&nz, res) @@ -580,6 +543,7 @@ gmove(&tl, res) } else { // A%B = A-(A/B*B) + var tm gc.Node regalloc(&tm, t, nil) // patch div to use the 3 register form @@ -606,135 +570,15 @@ * res = nl % nr */ func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { - var n1 gc.Node - var n2 gc.Node - var n3 gc.Node - var w int - var a int - var m gc.Magic - // TODO(minux): enable division by magic multiply (also need to fix longmod below) //if(nr->op != OLITERAL) goto longdiv - w = int(nl.Type.Width * 8) - - // Front end handled 32-bit division. We only need to handle 64-bit. - // try to do division by multiply by (2^w)/d - // see hacker's delight chapter 10 - switch gc.Simtype[nl.Type.Etype] { - default: - goto longdiv - - case gc.TUINT64: - m.W = w - m.Ud = uint64(gc.Mpgetfix(nr.Val.U.Xval)) - gc.Umagic(&m) - if m.Bad != 0 { - break - } - if op == gc.OMOD { - goto longmod - } - - cgenr(nl, &n1, nil) - gc.Nodconst(&n2, nl.Type, int64(m.Um)) - regalloc(&n3, nl.Type, res) - cgen_hmul(&n1, &n2, &n3) - - if m.Ua != 0 { - // need to add numerator accounting for overflow - gins(optoas(gc.OADD, nl.Type), &n1, &n3) - - gc.Nodconst(&n2, nl.Type, 1) - gins(optoas(gc.ORROTC, nl.Type), &n2, &n3) - gc.Nodconst(&n2, nl.Type, int64(m.S)-1) - gins(optoas(gc.ORSH, nl.Type), &n2, &n3) - } else { - gc.Nodconst(&n2, nl.Type, int64(m.S)) - gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift dx - } - - gmove(&n3, res) - regfree(&n1) - regfree(&n3) - return - - case gc.TINT64: - m.W = w - m.Sd = gc.Mpgetfix(nr.Val.U.Xval) - gc.Smagic(&m) - if m.Bad != 0 { - break - } - if op == gc.OMOD { - goto longmod - } - - cgenr(nl, &n1, res) - gc.Nodconst(&n2, nl.Type, m.Sm) - regalloc(&n3, nl.Type, nil) - cgen_hmul(&n1, &n2, &n3) - - if m.Sm < 0 { - // need to add numerator - gins(optoas(gc.OADD, nl.Type), &n1, &n3) - } - - gc.Nodconst(&n2, nl.Type, int64(m.S)) - gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift n3 - - gc.Nodconst(&n2, nl.Type, int64(w)-1) - - gins(optoas(gc.ORSH, nl.Type), &n2, &n1) // -1 iff num is neg - gins(optoas(gc.OSUB, nl.Type), &n1, &n3) // added - - if m.Sd < 0 { - // this could probably be removed - // by factoring it into the multiplier - gins(optoas(gc.OMINUS, nl.Type), nil, &n3) - } - - gmove(&n3, res) - regfree(&n1) - regfree(&n3) - return - } - - goto longdiv - // division and mod using (slow) hardware instruction longdiv: dodiv(op, nl, nr, res) return - - // mod using formula A%B = A-(A/B*B) but - // we know that there is a fast algorithm for A/B -longmod: - regalloc(&n1, nl.Type, res) - - cgen(nl, &n1) - regalloc(&n2, nl.Type, nil) - cgen_div(gc.ODIV, &n1, nr, &n2) - a = optoas(gc.OMUL, nl.Type) - if w == 8 { - } - // use 2-operand 16-bit multiply - // because there is no 2-operand 8-bit multiply - //a = AIMULW; - if !gc.Smallintconst(nr) { - regalloc(&n3, nl.Type, nil) - cgen(nr, &n3) - gins(a, &n3, &n2) - regfree(&n3) - } else { - gins(a, nr, &n2) - } - gins(optoas(gc.OSUB, nl.Type), &n2, &n1) - gmove(&n1, res) - regfree(&n1) - regfree(&n2) } /* @@ -742,30 +586,25 @@ * res = (nl*nr) >> width */ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { - var w int - var n1 gc.Node - var n2 gc.Node - var tmp *gc.Node - var t *gc.Type - var p *obj.Prog - // largest ullman on left. if nl.Ullman < nr.Ullman { - tmp = nl + tmp := (*gc.Node)(nl) nl = nr nr = tmp } - t = nl.Type - w = int(t.Width * 8) + t := (*gc.Type)(nl.Type) + w := int(int(t.Width * 8)) + var n1 gc.Node cgenr(nl, &n1, res) + var n2 gc.Node cgenr(nr, &n2, nil) switch gc.Simtype[t.Etype] { case gc.TINT8, gc.TINT16, gc.TINT32: gins(optoas(gc.OMUL, t), &n2, &n1) - p = gins(ppc64.ASRAD, nil, &n1) + p := (*obj.Prog)(gins(ppc64.ASRAD, nil, &n1)) p.From.Type = obj.TYPE_CONST p.From.Offset = int64(w) @@ -773,16 +612,16 @@ gc.TUINT16, gc.TUINT32: gins(optoas(gc.OMUL, t), &n2, &n1) - p = gins(ppc64.ASRD, nil, &n1) + p := (*obj.Prog)(gins(ppc64.ASRD, nil, &n1)) p.From.Type = obj.TYPE_CONST p.From.Offset = int64(w) case gc.TINT64, gc.TUINT64: if gc.Issigned[t.Etype] != 0 { - p = gins(ppc64.AMULHD, &n2, &n1) + gins(ppc64.AMULHD, &n2, &n1) } else { - p = gins(ppc64.AMULHDU, &n2, &n1) + gins(ppc64.AMULHDU, &n2, &n1) } default: @@ -803,21 +642,18 @@ var n1 gc.Node var n2 gc.Node var n3 gc.Node - var n4 gc.Node - var n5 gc.Node - var a int - var p1 *obj.Prog - var sc uint64 var tcount *gc.Type - a = optoas(op, nl.Type) + a := int(optoas(op, nl.Type)) if nr.Op == gc.OLITERAL { + var n1 gc.Node regalloc(&n1, nl.Type, res) cgen(nl, &n1) - sc = uint64(gc.Mpgetfix(nr.Val.U.Xval)) + sc := uint64(uint64(gc.Mpgetfix(nr.Val.U.Xval))) if sc >= uint64(nl.Type.Width*8) { // large shift gets 2 shifts by width-1 + var n3 gc.Node gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1) gins(a, &n3, &n1) @@ -831,12 +667,14 @@ } if nl.Ullman >= gc.UINF { + var n4 gc.Node gc.Tempname(&n4, nl.Type) cgen(nl, &n4) nl = &n4 } if nr.Ullman >= gc.UINF { + var n5 gc.Node gc.Tempname(&n5, nr.Type) cgen(nr, &n5) nr = &n5 @@ -872,7 +710,7 @@ if !bounded { gc.Nodconst(&n3, tcount, nl.Type.Width*8) gins(optoas(gc.OCMP, tcount), &n1, &n3) - p1 = gc.Gbranch(optoas(gc.OLT, tcount), nil, +1) + p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, tcount), nil, +1)) if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 { gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1) gins(a, &n3, &n2) @@ -895,46 +733,39 @@ } func clearfat(nl *gc.Node) { - var w uint64 - var c uint64 - var q uint64 - var t uint64 - var boff uint64 - var dst gc.Node - var end gc.Node - var r0 gc.Node - var f *gc.Node - var p *obj.Prog - var pl *obj.Prog - /* clear a fat object */ if gc.Debug['g'] != 0 { fmt.Printf("clearfat %v (%v, size: %d)\n", gc.Nconv(nl, 0), gc.Tconv(nl.Type, 0), nl.Type.Width) } - w = uint64(nl.Type.Width) + w := uint64(uint64(nl.Type.Width)) // Avoid taking the address for simple enough types. //if(componentgen(N, nl)) // return; - c = w % 8 // bytes - q = w / 8 // dwords + c := uint64(w % 8) // bytes + q := uint64(w / 8) // dwords if reg[ppc64.REGRT1] > 0 { gc.Fatal("R%d in use during clearfat", ppc64.REGRT1) } + var r0 gc.Node gc.Nodreg(&r0, gc.Types[gc.TUINT64], ppc64.REG_R0) // r0 is always zero + var dst gc.Node gc.Nodreg(&dst, gc.Types[gc.Tptr], ppc64.REGRT1) reg[ppc64.REGRT1]++ agen(nl, &dst) + var boff uint64 + var p *obj.Prog if q > 128 { p = gins(ppc64.ASUB, nil, &dst) p.From.Type = obj.TYPE_CONST p.From.Offset = 8 + var end gc.Node regalloc(&end, gc.Types[gc.Tptr], nil) p = gins(ppc64.AMOVD, &dst, &end) p.From.Type = obj.TYPE_ADDR @@ -943,7 +774,7 @@ p = gins(ppc64.AMOVDU, &r0, &dst) p.To.Type = obj.TYPE_MEM p.To.Offset = 8 - pl = p + pl := (*obj.Prog)(p) p = gins(ppc64.ACMP, &dst, &end) gc.Patch(gc.Gbranch(ppc64.ABNE, nil, 0), pl) @@ -956,7 +787,7 @@ p = gins(ppc64.ASUB, nil, &dst) p.From.Type = obj.TYPE_CONST p.From.Offset = 8 - f = gc.Sysfunc("duffzero") + f := (*gc.Node)(gc.Sysfunc("duffzero")) p = gins(obj.ADUFFZERO, nil, f) gc.Afunclit(&p.To, f) @@ -966,7 +797,7 @@ // duffzero leaves R3 on the last zeroed dword boff = 8 } else { - for t = 0; t < q; t++ { + for t := uint64(0); t < q; t++ { p = gins(ppc64.AMOVD, &r0, &dst) p.To.Type = obj.TYPE_MEM p.To.Offset = int64(8 * t) @@ -975,7 +806,7 @@ boff = 8 * q } - for t = 0; t < c; t++ { + for t := uint64(0); t < c; t++ { p = gins(ppc64.AMOVB, &r0, &dst) p.To.Type = obj.TYPE_MEM p.To.Offset = int64(t + boff) @@ -987,11 +818,10 @@ // Called after regopt and peep have run. // Expand CHECKNIL pseudo-op into actual nil pointer check. func expandchecks(firstp *obj.Prog) { - var p *obj.Prog var p1 *obj.Prog var p2 *obj.Prog - for p = firstp; p != nil; p = p.Link { + for p := (*obj.Prog)(firstp); p != nil; p = p.Link { if gc.Debug_checknil != 0 && gc.Ctxt.Debugvlog != 0 { fmt.Printf("expandchecks: %v\n", p) }
diff --git a/src/cmd/9g/gsubr.go b/src/cmd/9g/gsubr.go index 91e87ff..9a00434 100644 --- a/src/cmd/9g/gsubr.go +++ b/src/cmd/9g/gsubr.go
@@ -63,16 +63,14 @@ } func ginit() { - var i int - - for i = 0; i < len(reg); i++ { + for i := int(0); i < len(reg); i++ { reg[i] = 1 } - for i = 0; i < ppc64.NREG+ppc64.NFREG; i++ { + for i := int(0); i < ppc64.NREG+ppc64.NFREG; i++ { reg[i] = 0 } - for i = 0; i < len(resvd); i++ { + for i := int(0); i < len(resvd); i++ { reg[resvd[i]-ppc64.REG_R0]++ } } @@ -80,13 +78,11 @@ var regpc [len(reg)]uint32 func gclean() { - var i int - - for i = 0; i < len(resvd); i++ { + for i := int(0); i < len(resvd); i++ { reg[resvd[i]-ppc64.REG_R0]-- } - for i = 0; i < len(reg); i++ { + for i := int(0); i < len(reg); i++ { if reg[i] != 0 { gc.Yyerror("reg %v left allocated, %p\n", gc.Ctxt.Rconv(i+ppc64.REG_R0), regpc[i]) } @@ -94,10 +90,9 @@ } func anyregalloc() bool { - var i int var j int - for i = 0; i < len(reg); i++ { + for i := int(0); i < len(reg); i++ { if reg[i] == 0 { goto ok } @@ -119,20 +114,15 @@ * caller must regfree(n). */ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) { - var i int - var et int - var fixfree int - var fltfree int - if t == nil { gc.Fatal("regalloc: t nil") } - et = int(gc.Simtype[t.Etype]) + et := int(int(gc.Simtype[t.Etype])) if gc.Debug['r'] != 0 { - fixfree = 0 - fltfree = 0 - for i = ppc64.REG_R0; i < ppc64.REG_F31; i++ { + fixfree := int(0) + fltfree := int(0) + for i := int(ppc64.REG_R0); i < ppc64.REG_F31; i++ { if reg[i-ppc64.REG_R0] == 0 { if i < ppc64.REG_F0 { fixfree++ @@ -145,6 +135,7 @@ fmt.Printf("regalloc fix %d flt %d free\n", fixfree, fltfree) } + var i int switch et { case gc.TINT8, gc.TUINT8, @@ -172,7 +163,7 @@ } gc.Flusherrors() - for i = ppc64.REG_R0; i < ppc64.REG_R0+ppc64.NREG; i++ { + for i := int(ppc64.REG_R0); i < ppc64.REG_R0+ppc64.NREG; i++ { fmt.Printf("R%d %p\n", i, regpc[i-ppc64.REG_R0]) } gc.Fatal("out of fixed registers") @@ -194,7 +185,7 @@ } gc.Flusherrors() - for i = ppc64.REG_F0; i < ppc64.REG_F0+ppc64.NREG; i++ { + for i := int(ppc64.REG_F0); i < ppc64.REG_F0+ppc64.NREG; i++ { fmt.Printf("F%d %p\n", i, regpc[i-ppc64.REG_R0]) } gc.Fatal("out of floating registers") @@ -214,15 +205,13 @@ } func regfree(n *gc.Node) { - var i int - if n.Op == gc.ONAME { return } if n.Op != gc.OREGISTER && n.Op != gc.OINDREG { gc.Fatal("regfree: not a register") } - i = int(n.Val.U.Reg) - ppc64.REG_R0 + i := int(int(n.Val.U.Reg) - ppc64.REG_R0) if i == ppc64.REGSP-ppc64.REG_R0 { return } @@ -244,13 +233,13 @@ */ func ginscon(as int, c int64, n2 *gc.Node) { var n1 gc.Node - var ntmp gc.Node gc.Nodconst(&n1, gc.Types[gc.TINT64], c) if as != ppc64.AMOVD && (c < -ppc64.BIG || c > ppc64.BIG) { // cannot have more than 16-bit of immediate in ADD, etc. // instead, MOV into register first. + var ntmp gc.Node regalloc(&ntmp, gc.Types[gc.TINT64], nil) gins(ppc64.AMOVD, &n1, &ntmp) @@ -268,7 +257,6 @@ */ func ginscon2(as int, n2 *gc.Node, c int64) { var n1 gc.Node - var ntmp gc.Node gc.Nodconst(&n1, gc.Types[gc.TINT64], c) @@ -290,6 +278,7 @@ } // MOV n1 into register first + var ntmp gc.Node regalloc(&ntmp, gc.Types[gc.TINT64], nil) gins(ppc64.AMOVD, &n1, &ntmp) @@ -328,24 +317,13 @@ * hard part is conversions. */ func gmove(f *gc.Node, t *gc.Node) { - var a int - var ft int - var tt int - var cvt *gc.Type - var r1 gc.Node - var r2 gc.Node - var r3 gc.Node - var con gc.Node - var p1 *obj.Prog - var p2 *obj.Prog - if gc.Debug['M'] != 0 { fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, obj.FmtLong), gc.Nconv(t, obj.FmtLong)) } - ft = gc.Simsimtype(f.Type) - tt = gc.Simsimtype(t.Type) - cvt = t.Type + ft := int(gc.Simsimtype(f.Type)) + tt := int(gc.Simsimtype(t.Type)) + cvt := (*gc.Type)(t.Type) if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 { gc.Complexmove(f, t) @@ -353,12 +331,16 @@ } // cannot have two memory operands + var r2 gc.Node + var r1 gc.Node + var a int if gc.Ismem(f) && gc.Ismem(t) { goto hard } // convert constant to desired type if f.Op == gc.OLITERAL { + var con gc.Node switch tt { default: gc.Convconst(&con, t.Type, &f.Val) @@ -366,7 +348,9 @@ case gc.TINT32, gc.TINT16, gc.TINT8: + var con gc.Node gc.Convconst(&con, gc.Types[gc.TINT64], &f.Val) + var r1 gc.Node regalloc(&r1, con.Type, t) gins(ppc64.AMOVD, &con, &r1) gmove(&r1, t) @@ -376,7 +360,9 @@ case gc.TUINT32, gc.TUINT16, gc.TUINT8: + var con gc.Node gc.Convconst(&con, gc.Types[gc.TUINT64], &f.Val) + var r1 gc.Node regalloc(&r1, con.Type, t) gins(ppc64.AMOVD, &con, &r1) gmove(&r1, t) @@ -559,22 +545,24 @@ gc.TFLOAT64<<16 | gc.TUINT64: bignodes() + var r1 gc.Node regalloc(&r1, gc.Types[ft], f) gmove(f, &r1) if tt == gc.TUINT64 { regalloc(&r2, gc.Types[gc.TFLOAT64], nil) gmove(&bigf, &r2) gins(ppc64.AFCMPU, &r1, &r2) - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1) + p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1)) gins(ppc64.AFSUB, &r2, &r1) gc.Patch(p1, gc.Pc) regfree(&r2) } regalloc(&r2, gc.Types[gc.TFLOAT64], nil) + var r3 gc.Node regalloc(&r3, gc.Types[gc.TINT64], t) gins(ppc64.AFCTIDZ, &r1, &r2) - p1 = gins(ppc64.AFMOVD, &r2, nil) + p1 := (*obj.Prog)(gins(ppc64.AFMOVD, &r2, nil)) p1.To.Type = obj.TYPE_MEM p1.To.Reg = ppc64.REGSP p1.To.Offset = -8 @@ -585,7 +573,7 @@ regfree(&r2) regfree(&r1) if tt == gc.TUINT64 { - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1) // use CR0 here again + p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1)) // use CR0 here again gc.Nodreg(&r1, gc.Types[gc.TINT64], ppc64.REGTMP) gins(ppc64.AMOVD, &bigi, &r1) gins(ppc64.AADD, &r1, &r3) @@ -622,21 +610,22 @@ gc.TUINT64<<16 | gc.TFLOAT64: bignodes() + var r1 gc.Node regalloc(&r1, gc.Types[gc.TINT64], nil) gmove(f, &r1) if ft == gc.TUINT64 { gc.Nodreg(&r2, gc.Types[gc.TUINT64], ppc64.REGTMP) gmove(&bigi, &r2) gins(ppc64.ACMPU, &r1, &r2) - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1) - p2 = gins(ppc64.ASRD, nil, &r1) + p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1)) + p2 := (*obj.Prog)(gins(ppc64.ASRD, nil, &r1)) p2.From.Type = obj.TYPE_CONST p2.From.Offset = 1 gc.Patch(p1, gc.Pc) } regalloc(&r2, gc.Types[gc.TFLOAT64], t) - p1 = gins(ppc64.AMOVD, &r1, nil) + p1 := (*obj.Prog)(gins(ppc64.AMOVD, &r1, nil)) p1.To.Type = obj.TYPE_MEM p1.To.Reg = ppc64.REGSP p1.To.Offset = -8 @@ -647,7 +636,7 @@ gins(ppc64.AFCFID, &r2, &r2) regfree(&r1) if ft == gc.TUINT64 { - p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1) // use CR0 here again + p1 := (*obj.Prog)(gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1)) // use CR0 here again gc.Nodreg(&r1, gc.Types[gc.TFLOAT64], ppc64.FREGTWO) gins(ppc64.AFMUL, &r1, &r2) gc.Patch(p1, gc.Pc) @@ -702,24 +691,19 @@ * as f, t */ func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog { - var w int32 - var p *obj.Prog - var af obj.Addr - var at obj.Addr - // TODO(austin): Add self-move test like in 6g (but be careful // of truncation moves) - af = obj.Addr{} + af := obj.Addr(obj.Addr{}) - at = obj.Addr{} + at := obj.Addr(obj.Addr{}) if f != nil { gc.Naddr(f, &af, 1) } if t != nil { gc.Naddr(t, &at, 1) } - p = gc.Prog(as) + p := (*obj.Prog)(gc.Prog(as)) if f != nil { p.From = af } @@ -730,7 +714,7 @@ fmt.Printf("%v\n", p) } - w = 0 + w := int32(0) switch as { case ppc64.AMOVB, ppc64.AMOVBU, @@ -768,8 +752,6 @@ } func fixlargeoffset(n *gc.Node) { - var a gc.Node - if n == nil { return } @@ -784,7 +766,7 @@ // this is used only in test/fixedbugs/issue6036.go. gc.Fatal("offset too large: %v", gc.Nconv(n, 0)) - a = *n + a := gc.Node(*n) a.Op = gc.OREGISTER a.Type = gc.Types[gc.Tptr] a.Xoffset = 0 @@ -798,13 +780,11 @@ * return Axxx for Oxxx on type t. */ func optoas(op int, t *gc.Type) int { - var a int - if t == nil { gc.Fatal("optoas: t is nil") } - a = obj.AXXX + a := int(obj.AXXX) switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) { default: gc.Fatal("optoas: no entry for op=%v type=%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
diff --git a/src/cmd/9g/peep.go b/src/cmd/9g/peep.go index 486b316..f7c0a95 100644 --- a/src/cmd/9g/peep.go +++ b/src/cmd/9g/peep.go
@@ -40,19 +40,15 @@ var gactive uint32 func peep(firstp *obj.Prog) { - var g *gc.Graph - var r *gc.Flow - var r1 *gc.Flow - var p *obj.Prog - var p1 *obj.Prog - var t int - - g = gc.Flowstart(firstp, nil) + g := (*gc.Graph)(gc.Flowstart(firstp, nil)) if g == nil { return } gactive = 0 + var p *obj.Prog + var r *gc.Flow + var t int loop1: if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { gc.Dumpit("loop1", g.Start, 0) @@ -109,7 +105,9 @@ /* * look for MOVB x,R; MOVB R,R (for small MOVs not handled above) */ - for r = g.Start; r != nil; r = r.Link { + var p1 *obj.Prog + var r1 *gc.Flow + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { default: @@ -151,7 +149,7 @@ * look for OP x,y,R; CMP R, $0 -> OPCC x,y,R * when OP can set condition codes correctly */ - for r = g.Start; r != nil; r = r.Link { + for r := (*gc.Flow)(g.Start); r != nil; r = r.Link { p = r.Prog switch p.As { case ppc64.ACMP, @@ -350,9 +348,7 @@ } func excise(r *gc.Flow) { - var p *obj.Prog - - p = r.Prog + p := (*obj.Prog)(r.Prog) if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 { fmt.Printf("%v ===delete===\n", p) } @@ -402,22 +398,17 @@ * above sequences. This returns 1 if it modified any instructions. */ func subprop(r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - var r *gc.Flow - var t int - var info gc.ProgInfo - - p = r0.Prog - v1 = &p.From + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) if !regtyp(v1) { return false } - v2 = &p.To + v2 := (*obj.Addr)(&p.To) if !regtyp(v2) { return false } + var r *gc.Flow + var info gc.ProgInfo for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) { if gc.Uniqs(r) == nil { break @@ -469,7 +460,7 @@ } } - t = int(v1.Reg) + t := int(int(v1.Reg)) v1.Reg = v2.Reg v2.Reg = int16(t) if gc.Debug['P'] != 0 { @@ -491,13 +482,9 @@ * set v2 return success (caller can remove v1->v2 move) */ func copyprop(r0 *gc.Flow) bool { - var p *obj.Prog - var v1 *obj.Addr - var v2 *obj.Addr - - p = r0.Prog - v1 = &p.From - v2 = &p.To + p := (*obj.Prog)(r0.Prog) + v1 := (*obj.Addr)(&p.From) + v2 := (*obj.Addr)(&p.To) if copyas(v1, v2) { if gc.Debug['P'] != 0 { fmt.Printf("eliminating self-move\n", r0.Prog) @@ -515,9 +502,6 @@ // copy1 replaces uses of v2 with v1 starting at r and returns 1 if // all uses were rewritten. func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) bool { - var t int - var p *obj.Prog - if uint32(r.Active) == gactive { if gc.Debug['P'] != 0 { fmt.Printf("act set; return 1\n") @@ -529,6 +513,8 @@ if gc.Debug['P'] != 0 { fmt.Printf("copy1 replace %v with %v f=%d\n", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1), f) } + var t int + var p *obj.Prog for ; r != nil; r = r.S1 { p = r.Prog if gc.Debug['P'] != 0 {
diff --git a/src/cmd/9g/prog.go b/src/cmd/9g/prog.go index e188f0d..b971256 100644 --- a/src/cmd/9g/prog.go +++ b/src/cmd/9g/prog.go
@@ -108,10 +108,6 @@ func initproginfo() { var addvariant = []int{V_CC, V_V, V_CC | V_V} - var as int - var as2 int - var i int - var variant int if initproginfo_initialized != 0 { return @@ -120,7 +116,10 @@ // Perform one-time expansion of instructions in progtable to // their CC, V, and VCC variants - for as = 0; as < len(progtable); as++ { + var as2 int + var i int + var variant int + for as := int(0); as < len(progtable); as++ { if progtable[as].Flags == 0 { continue } @@ -272,15 +271,13 @@ var initvariants_initialized int func initvariants() { - var i int - var j int - if initvariants_initialized != 0 { return } initvariants_initialized = 1 - for i = 0; i < len(varianttable); i++ { + var j int + for i := int(0); i < len(varianttable); i++ { if varianttable[i][0] == 0 { // Instruction has no variants varianttable[i][0] = i @@ -299,9 +296,8 @@ // as2variant returns the variant (V_*) flags of instruction as. func as2variant(as int) int { - var i int initvariants() - for i = 0; i < len(varianttable[as]); i++ { + for i := int(0); i < len(varianttable[as]); i++ { if varianttable[as][i] == as { return i }
diff --git a/src/cmd/9g/reg.go b/src/cmd/9g/reg.go index faed60d..b1b681a 100644 --- a/src/cmd/9g/reg.go +++ b/src/cmd/9g/reg.go
@@ -110,10 +110,8 @@ } func excludedregs() uint64 { - var regbits uint64 - // Exclude registers with fixed functions - regbits = 1<<0 | RtoB(ppc64.REGSP) | RtoB(ppc64.REGG) | RtoB(ppc64.REGTLS) + regbits := uint64(1<<0 | RtoB(ppc64.REGSP) | RtoB(ppc64.REGG) | RtoB(ppc64.REGTLS)) // Also exclude floating point registers with fixed constants regbits |= RtoB(ppc64.REG_F27) | RtoB(ppc64.REG_F28) | RtoB(ppc64.REG_F29) | RtoB(ppc64.REG_F30) | RtoB(ppc64.REG_F31)
diff --git a/src/cmd/internal/gc/align.go b/src/cmd/internal/gc/align.go index 994b7a2..a588ca3 100644 --- a/src/cmd/internal/gc/align.go +++ b/src/cmd/internal/gc/align.go
@@ -22,11 +22,8 @@ } func offmod(t *Type) { - var f *Type - var o int32 - - o = 0 - for f = t.Type; f != nil; f = f.Down { + o := int32(0) + for f := t.Type; f != nil; f = f.Down { if f.Etype != TFIELD { Fatal("offmod: not TFIELD: %v", Tconv(f, obj.FmtLong)) } @@ -40,19 +37,14 @@ } func widstruct(errtype *Type, t *Type, o int64, flag int) int64 { - var f *Type - var w int64 - var maxalign int32 - var starto int64 - var lastzero int64 - - starto = o - maxalign = int32(flag) + starto := o + maxalign := int32(flag) if maxalign < 1 { maxalign = 1 } - lastzero = 0 - for f = t.Type; f != nil; f = f.Down { + lastzero := int64(0) + var w int64 + for f := t.Type; f != nil; f = f.Down { if f.Etype != TFIELD { Fatal("widstruct: not TFIELD: %v", Tconv(f, obj.FmtLong)) } @@ -118,11 +110,6 @@ } func dowidth(t *Type) { - var et int32 - var w int64 - var lno int - var t1 *Type - if Widthptr == 0 { Fatal("dowidth without betypeinit") } @@ -136,7 +123,7 @@ } if t.Width == -2 { - lno = int(lineno) + lno := int(lineno) lineno = int32(t.Lineno) if t.Broke == 0 { t.Broke = 1 @@ -157,12 +144,12 @@ // defer checkwidth calls until after we're done defercalc++ - lno = int(lineno) + lno := int(lineno) lineno = int32(t.Lineno) t.Width = -2 t.Align = 0 - et = int32(t.Etype) + et := int32(t.Etype) switch et { case TFUNC, TCHAN, @@ -177,7 +164,7 @@ } } - w = 0 + w := int64(0) switch et { default: Fatal("dowidth: unknown type: %v", Tconv(t, 0)) @@ -233,13 +220,13 @@ // make fake type to check later to // trigger channel argument check. - t1 = typ(TCHANARGS) + t1 := typ(TCHANARGS) t1.Type = t checkwidth(t1) case TCHANARGS: - t1 = t.Type + t1 := t.Type dowidth(t.Type) // just in case if t1.Type.Width >= 1<<16 { Yyerror("channel element type too large (>64kB)") @@ -277,11 +264,9 @@ break } if t.Bound >= 0 { - var cap uint64 - dowidth(t.Type) if t.Type.Width != 0 { - cap = (uint64(Thearch.MAXWIDTH) - 1) / uint64(t.Type.Width) + cap := (uint64(Thearch.MAXWIDTH) - 1) / uint64(t.Type.Width) if uint64(t.Bound) > cap { Yyerror("type %v larger than address space", Tconv(t, obj.FmtLong)) } @@ -311,7 +296,7 @@ // make fake type to check later to // trigger function argument computation. case TFUNC: - t1 = typ(TFUNCARGS) + t1 := typ(TFUNCARGS) t1.Type = t checkwidth(t1) @@ -322,7 +307,7 @@ // function is 3 cated structures; // compute their widths as side-effect. case TFUNCARGS: - t1 = t.Type + t1 := t.Type w = widstruct(t.Type, *getthis(t1), 0, 0) w = widstruct(t.Type, *getinarg(t1), w, Widthreg) @@ -382,8 +367,6 @@ var tlq *TypeList func checkwidth(t *Type) { - var l *TypeList - if t == nil { return } @@ -404,7 +387,7 @@ } t.Deferwidth = 1 - l = tlfree + l := tlfree if l != nil { tlfree = l.next } else { @@ -425,12 +408,10 @@ } func resumecheckwidth() { - var l *TypeList - if defercalc == 0 { Fatal("resumecheckwidth") } - for l = tlq; l != nil; l = tlq { + for l := tlq; l != nil; l = tlq { l.t.Deferwidth = 0 tlq = l.next dowidth(l.t) @@ -442,18 +423,11 @@ } func typeinit() { - var i int - var etype int - var sameas int - var t *Type - var s *Sym - var s1 *Sym - if Widthptr == 0 { Fatal("typeinit before betypeinit") } - for i = 0; i < NTYPE; i++ { + for i := 0; i < NTYPE; i++ { Simtype[i] = uint8(i) } @@ -463,7 +437,7 @@ Types[TPTR64] = typ(TPTR64) dowidth(Types[TPTR64]) - t = typ(TUNSAFEPTR) + t := typ(TUNSAFEPTR) Types[TUNSAFEPTR] = t t.Sym = Pkglookup("Pointer", unsafepkg) t.Sym.Def = typenod(t) @@ -475,7 +449,7 @@ Tptr = TPTR64 } - for i = TINT8; i <= TUINT64; i++ { + for i := TINT8; i <= TUINT64; i++ { Isint[i] = 1 } Isint[TINT] = 1 @@ -502,7 +476,7 @@ /* * initialize okfor */ - for i = 0; i < NTYPE; i++ { + for i := 0; i < NTYPE; i++ { if Isint[i] != 0 || i == TIDEAL { okforeq[i] = 1 okforcmp[i] = 1 @@ -566,6 +540,7 @@ okforcmp[TSTRING] = 1 + var i int for i = 0; i < len(okfor); i++ { okfor[i] = okfornone[:] } @@ -655,6 +630,10 @@ Simtype[TUNSAFEPTR] = uint8(Tptr) /* pick up the backend thearch.typedefs */ + var s1 *Sym + var etype int + var sameas int + var s *Sym for i = range Thearch.Typedefs { s = Lookup(Thearch.Typedefs[i].Name) s1 = Pkglookup(Thearch.Typedefs[i].Name, builtinpkg) @@ -703,13 +682,11 @@ */ func Argsize(t *Type) int { var save Iter - var fp *Type - var w int64 var x int64 - w = 0 + w := int64(0) - fp = Structfirst(&save, Getoutarg(t)) + fp := Structfirst(&save, Getoutarg(t)) for fp != nil { x = fp.Width + fp.Type.Width if x > w {
diff --git a/src/cmd/internal/gc/bits.go b/src/cmd/internal/gc/bits.go index 23da356..95421e5 100644 --- a/src/cmd/internal/gc/bits.go +++ b/src/cmd/internal/gc/bits.go
@@ -67,9 +67,7 @@ } */ func bany(a *Bits) bool { - var i int - - for i = 0; i < BITS; i++ { + for i := 0; i < BITS; i++ { if a.b[i] != 0 { return true } @@ -90,10 +88,9 @@ } */ func bnum(a Bits) int { - var i int var b uint64 - for i = 0; i < BITS; i++ { + for i := 0; i < BITS; i++ { b = a.b[i] if b != 0 { return 64*i + Bitno(b) @@ -105,9 +102,7 @@ } func blsh(n uint) Bits { - var c Bits - - c = zbits + c := zbits c.b[n/64] = 1 << (n % 64) return c } @@ -125,9 +120,7 @@ } func Bitno(b uint64) int { - var i int - - for i = 0; i < 64; i++ { + for i := 0; i < 64; i++ { if b&(1<<uint(i)) != 0 { return i } @@ -140,9 +133,8 @@ var fp string var i int - var first int - first = 1 + first := 1 for bany(&bits) { i = bnum(bits)
diff --git a/src/cmd/internal/gc/bv.go b/src/cmd/internal/gc/bv.go index 002b5a4..e7fdd70 100644 --- a/src/cmd/internal/gc/bv.go +++ b/src/cmd/internal/gc/bv.go
@@ -63,16 +63,13 @@ } func bvconcat(src1 *Bvec, src2 *Bvec) *Bvec { - var dst *Bvec - var i int32 - - dst = bvalloc(src1.n + src2.n) - for i = 0; i < src1.n; i++ { + dst := bvalloc(src1.n + src2.n) + for i := int32(0); i < src1.n; i++ { if bvget(src1, i) != 0 { bvset(dst, i) } } - for i = 0; i < src2.n; i++ { + for i := int32(0); i < src2.n; i++ { if bvget(src2, i) != 0 { bvset(dst, i+src1.n) } @@ -90,8 +87,6 @@ // bvnext returns the smallest index >= i for which bvget(bv, i) == 1. // If there is no such index, bvnext returns -1. func bvnext(bv *Bvec, i int32) int { - var w uint32 - if i >= bv.n { return -1 } @@ -110,7 +105,7 @@ } // Find 1 bit. - w = bv.b[i>>WORDSHIFT] >> uint(i&WORDMASK) + w := bv.b[i>>WORDSHIFT] >> uint(i&WORDMASK) for w&1 == 0 { w >>= 1 @@ -121,9 +116,7 @@ } func bvisempty(bv *Bvec) bool { - var i int32 - - for i = 0; i < bv.n; i += WORDBITS { + for i := int32(0); i < bv.n; i += WORDBITS { if bv.b[i>>WORDSHIFT] != 0 { return false } @@ -173,21 +166,17 @@ } func bvprint(bv *Bvec) { - var i int32 - fmt.Printf("#*") - for i = 0; i < bv.n; i++ { + for i := int32(0); i < bv.n; i++ { fmt.Printf("%d", bvget(bv, i)) } } func bvreset(bv *Bvec, i int32) { - var mask uint32 - if i < 0 || i >= bv.n { Fatal("bvreset: index %d is out of bounds with length %d\n", i, bv.n) } - mask = ^(1 << uint(i%WORDBITS)) + mask := uint32(^(1 << uint(i%WORDBITS))) bv.b[i/WORDBITS] &= mask } @@ -198,11 +187,9 @@ } func bvset(bv *Bvec, i int32) { - var mask uint32 - if i < 0 || i >= bv.n { Fatal("bvset: index %d is out of bounds with length %d\n", i, bv.n) } - mask = 1 << uint(i%WORDBITS) + mask := uint32(1 << uint(i%WORDBITS)) bv.b[i/WORDBITS] |= mask }
diff --git a/src/cmd/internal/gc/closure.go b/src/cmd/internal/gc/closure.go index c2c802e..20a0349 100644 --- a/src/cmd/internal/gc/closure.go +++ b/src/cmd/internal/gc/closure.go
@@ -13,12 +13,10 @@ * function literals aka closures */ func closurehdr(ntype *Node) { - var n *Node var name *Node var a *Node - var l *NodeList - n = Nod(OCLOSURE, nil, nil) + n := Nod(OCLOSURE, nil, nil) n.Ntype = ntype n.Funcdepth = Funcdepth n.Outerfunc = Curfn @@ -35,7 +33,7 @@ n.Rlist = ntype.Rlist ntype.List = nil ntype.Rlist = nil - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { name = l.N.Left if name != nil { name = newname(name.Sym) @@ -48,7 +46,7 @@ ntype.List = list(ntype.List, a) } - for l = n.Rlist; l != nil; l = l.Next { + for l := n.Rlist; l != nil; l = l.Next { name = l.N.Left if name != nil { name = newname(name.Sym) @@ -58,15 +56,11 @@ } func closurebody(body *NodeList) *Node { - var func_ *Node - var v *Node - var l *NodeList - if body == nil { body = list1(Nod(OEMPTY, nil, nil)) } - func_ = Curfn + func_ := Curfn func_.Nbody = body func_.Endlineno = lineno funcbody(func_) @@ -75,7 +69,8 @@ // ordinary ones in the symbol table; see oldname. // unhook them. // make the list of pointers for the closure call. - for l = func_.Cvars; l != nil; l = l.Next { + var v *Node + for l := func_.Cvars; l != nil; l = l.Next { v = l.N v.Closure.Closure = v.Outer v.Outerexpr = oldname(v.Sym) @@ -85,12 +80,9 @@ } func typecheckclosure(func_ *Node, top int) { - var oldfn *Node var n *Node - var l *NodeList - var olddd int - for l = func_.Cvars; l != nil; l = l.Next { + for l := func_.Cvars; l != nil; l = l.Next { n = l.N.Closure if n.Captured == 0 { n.Captured = 1 @@ -106,13 +98,13 @@ } } - for l = func_.Dcl; l != nil; l = l.Next { + for l := func_.Dcl; l != nil; l = l.Next { if l.N.Op == ONAME && (l.N.Class == PPARAM || l.N.Class == PPARAMOUT) { l.N.Decldepth = 1 } } - oldfn = Curfn + oldfn := Curfn typecheck(&func_.Ntype, Etype) func_.Type = func_.Ntype.Type func_.Top = top @@ -123,7 +115,7 @@ // underlying closure function we create is added to xtop. if Curfn != nil && func_.Type != nil { Curfn = func_ - olddd = decldepth + olddd := decldepth decldepth = 1 typechecklist(func_.Nbody, Etop) decldepth = olddd @@ -143,16 +135,12 @@ var closurename_closgen int func closurename(n *Node) *Sym { - var outer string - var prefix string - var gen int - if n.Sym != nil { return n.Sym } - gen = 0 - outer = "" - prefix = "" + gen := 0 + outer := "" + prefix := "" if n.Outerfunc == nil { // Global closure. outer = "glob" @@ -192,20 +180,17 @@ } func makeclosure(func_ *Node) *Node { - var xtype *Node - var xfunc *Node - /* * wrap body in external function * that begins by reading closure parameters. */ - xtype = Nod(OTFUNC, nil, nil) + xtype := Nod(OTFUNC, nil, nil) xtype.List = func_.List xtype.Rlist = func_.Rlist // create the function - xfunc = Nod(ODCLFUNC, nil, nil) + xfunc := Nod(ODCLFUNC, nil, nil) xfunc.Nname = newname(closurename(func_)) xfunc.Nname.Sym.Flags |= SymExported // disable export @@ -239,18 +224,15 @@ // We use value capturing for values <= 128 bytes that are never reassigned // after capturing (effectively constant). func capturevars(xfunc *Node) { - var func_ *Node var v *Node var outer *Node - var l *NodeList - var lno int - lno = int(lineno) + lno := int(lineno) lineno = xfunc.Lineno - func_ = xfunc.Closure + func_ := xfunc.Closure func_.Enter = nil - for l = func_.Cvars; l != nil; l = l.Next { + for l := func_.Cvars; l != nil; l = l.Next { v = l.N if v.Type == nil { // if v->type is nil, it means v looked like it was @@ -280,13 +262,11 @@ } if Debug['m'] > 1 { - var name *Sym - var how string - name = nil + name := (*Sym)(nil) if v.Curfn != nil && v.Curfn.Nname != nil { name = v.Curfn.Nname.Sym } - how = "ref" + how := "ref" if v.Byval != 0 { how = "value" } @@ -303,22 +283,9 @@ // transformclosure is called in a separate phase after escape analysis. // It transform closure bodies to properly reference captured variables. func transformclosure(xfunc *Node) { - var func_ *Node - var cv *Node - var addr *Node - var v *Node - var f *Node - var l *NodeList - var body *NodeList - var param **Type - var fld *Type - var offset int64 - var lno int - var nvar int - - lno = int(lineno) + lno := int(lineno) lineno = xfunc.Lineno - func_ = xfunc.Closure + func_ := xfunc.Closure if func_.Top&Ecall != 0 { // If the closure is directly called, we transform it to a plain function call @@ -337,15 +304,18 @@ // }(42, byval, &byref) // f is ONAME of the actual function. - f = xfunc.Nname + f := xfunc.Nname // Get pointer to input arguments and rewind to the end. // We are going to append captured variables to input args. - param = &getinargx(f.Type).Type + param := &getinargx(f.Type).Type for ; *param != nil; param = &(*param).Down { } - for l = func_.Cvars; l != nil; l = l.Next { + var v *Node + var addr *Node + var fld *Type + for l := func_.Cvars; l != nil; l = l.Next { v = l.N if v.Op == OXXX { continue @@ -390,11 +360,14 @@ xfunc.Type = f.Type // update type of ODCLFUNC } else { // The closure is not called, so it is going to stay as closure. - nvar = 0 + nvar := 0 - body = nil - offset = int64(Widthptr) - for l = func_.Cvars; l != nil; l = l.Next { + body := (*NodeList)(nil) + offset := int64(Widthptr) + var addr *Node + var v *Node + var cv *Node + for l := func_.Cvars; l != nil; l = l.Next { v = l.N if v.Op == OXXX { continue @@ -450,12 +423,6 @@ } func walkclosure(func_ *Node, init **NodeList) *Node { - var clos *Node - var typ *Node - var typ1 *Node - var v *Node - var l *NodeList - // If no closure vars, don't bother wrapping. if func_.Cvars == nil { return func_.Closure.Nname @@ -475,10 +442,12 @@ // the struct is unnamed so that closures in multiple packages with the // same struct type can share the descriptor. - typ = Nod(OTSTRUCT, nil, nil) + typ := Nod(OTSTRUCT, nil, nil) typ.List = list1(Nod(ODCLFIELD, newname(Lookup(".F")), typenod(Types[TUINTPTR]))) - for l = func_.Cvars; l != nil; l = l.Next { + var typ1 *Node + var v *Node + for l := func_.Cvars; l != nil; l = l.Next { v = l.N if v.Op == OXXX { continue @@ -490,7 +459,7 @@ typ.List = list(typ.List, Nod(ODCLFIELD, newname(v.Sym), typ1)) } - clos = Nod(OCOMPLIT, nil, Nod(OIND, typ, nil)) + clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil)) clos.Esc = func_.Esc clos.Right.Implicit = 1 clos.List = concat(list1(Nod(OCFUNC, func_.Closure.Nname, nil)), func_.Enter) @@ -541,34 +510,15 @@ var makepartialcall_gopkg *Pkg func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node { - var ptr *Node - var n *Node - var fld *Node - var call *Node - var xtype *Node - var xfunc *Node - var cv *Node - var savecurfn *Node - var rcvrtype *Type - var basetype *Type - var t *Type - var body *NodeList - var l *NodeList - var callargs *NodeList - var retargs *NodeList var p string - var sym *Sym - var spkg *Pkg - var i int - var ddd int - rcvrtype = fn.Left.Type + rcvrtype := fn.Left.Type if exportname(meth.Sym.Name) { p = fmt.Sprintf("(%v).%s-fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), meth.Sym.Name) } else { p = fmt.Sprintf("(%v).(%v)-fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), Sconv(meth.Sym, obj.FmtLeft)) } - basetype = rcvrtype + basetype := rcvrtype if Isptr[rcvrtype.Etype] != 0 { basetype = basetype.Type } @@ -576,7 +526,7 @@ Fatal("missing base type for %v", Tconv(rcvrtype, 0)) } - spkg = nil + spkg := (*Pkg)(nil) if basetype.Sym != nil { spkg = basetype.Sym.Pkg } @@ -587,24 +537,26 @@ spkg = makepartialcall_gopkg } - sym = Pkglookup(p, spkg) + sym := Pkglookup(p, spkg) if sym.Flags&SymUniq != 0 { return sym.Def } sym.Flags |= SymUniq - savecurfn = Curfn + savecurfn := Curfn Curfn = nil - xtype = Nod(OTFUNC, nil, nil) - i = 0 - l = nil - callargs = nil - ddd = 0 - xfunc = Nod(ODCLFUNC, nil, nil) + xtype := Nod(OTFUNC, nil, nil) + i := 0 + l := (*NodeList)(nil) + callargs := (*NodeList)(nil) + ddd := 0 + xfunc := Nod(ODCLFUNC, nil, nil) Curfn = xfunc - for t = getinargx(t0).Type; t != nil; t = t.Down { + var fld *Node + var n *Node + for t := getinargx(t0).Type; t != nil; t = t.Down { namebuf = fmt.Sprintf("a%d", i) i++ n = newname(Lookup(namebuf)) @@ -623,8 +575,8 @@ xtype.List = l i = 0 l = nil - retargs = nil - for t = getoutargx(t0).Type; t != nil; t = t.Down { + retargs := (*NodeList)(nil) + for t := getoutargx(t0).Type; t != nil; t = t.Down { namebuf = fmt.Sprintf("r%d", i) i++ n = newname(Lookup(namebuf)) @@ -644,16 +596,16 @@ declare(xfunc.Nname, PFUNC) // Declare and initialize variable holding receiver. - body = nil + body := (*NodeList)(nil) xfunc.Needctxt = true - cv = Nod(OCLOSUREVAR, nil, nil) + cv := Nod(OCLOSUREVAR, nil, nil) cv.Xoffset = int64(Widthptr) cv.Type = rcvrtype if int(cv.Type.Align) > Widthptr { cv.Xoffset = int64(cv.Type.Align) } - ptr = Nod(ONAME, nil, nil) + ptr := Nod(ONAME, nil, nil) ptr.Sym = Lookup("rcvr") ptr.Class = PAUTO ptr.Addable = 1 @@ -669,13 +621,13 @@ body = list(body, Nod(OAS, ptr, Nod(OADDR, cv, nil))) } - call = Nod(OCALL, Nod(OXDOT, ptr, meth), nil) + call := Nod(OCALL, Nod(OXDOT, ptr, meth), nil) call.List = callargs call.Isddd = uint8(ddd) if t0.Outtuple == 0 { body = list(body, call) } else { - n = Nod(OAS2, nil, nil) + n := Nod(OAS2, nil, nil) n.List = retargs n.Rlist = list1(call) body = list(body, n) @@ -694,9 +646,6 @@ } func walkpartialcall(n *Node, init **NodeList) *Node { - var clos *Node - var typ *Node - // Create closure in the form of a composite literal. // For x.M with receiver (x) type T, the generated code looks like: // @@ -712,11 +661,11 @@ checknil(n.Left, init) } - typ = Nod(OTSTRUCT, nil, nil) + typ := Nod(OTSTRUCT, nil, nil) typ.List = list1(Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR]))) typ.List = list(typ.List, Nod(ODCLFIELD, newname(Lookup("R")), typenod(n.Left.Type))) - clos = Nod(OCOMPLIT, nil, Nod(OIND, typ, nil)) + clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil)) clos.Esc = n.Esc clos.Right.Implicit = 1 clos.List = list1(Nod(OCFUNC, n.Nname.Nname, nil))
diff --git a/src/cmd/internal/gc/const.go b/src/cmd/internal/gc/const.go index 49d3bcc..43c8809 100644 --- a/src/cmd/internal/gc/const.go +++ b/src/cmd/internal/gc/const.go
@@ -11,31 +11,27 @@ * according to type; return truncated value. */ func truncfltlit(oldv *Mpflt, t *Type) *Mpflt { - var d float64 - var fv *Mpflt - var v Val - if t == nil { return oldv } - v = Val{} + v := Val{} v.Ctype = CTFLT v.U.Fval = oldv overflow(v, t) - fv = new(Mpflt) + fv := new(Mpflt) *fv = *oldv // convert large precision literal floating // into limited precision (float64 or float32) switch t.Etype { case TFLOAT64: - d = mpgetflt(fv) + d := mpgetflt(fv) Mpmovecflt(fv, d) case TFLOAT32: - d = mpgetflt32(fv) + d := mpgetflt32(fv) Mpmovecflt(fv, d) } @@ -56,12 +52,7 @@ * (if n is a named constant, can't edit n->type directly). */ func convlit1(np **Node, t *Type, explicit bool) { - var ct int - var et int - var n *Node - var nn *Node - - n = *np + n := *np if n == nil || t == nil || n.Type == nil || isideal(t) || n.Type == t { return } @@ -70,7 +61,7 @@ } if n.Op == OLITERAL { - nn = Nod(OXXX, nil, nil) + nn := Nod(OXXX, nil, nil) *nn = *n n = nn *np = n @@ -148,7 +139,8 @@ return } - ct = consttype(n) + ct := consttype(n) + var et int if ct < 0 { goto bad } @@ -214,7 +206,7 @@ CTRUNE, CTFLT, CTCPLX: - ct = int(n.Val.Ctype) + ct := int(n.Val.Ctype) if Isint[et] != 0 { switch ct { default: @@ -285,24 +277,20 @@ } func copyval(v Val) Val { - var i *Mpint - var f *Mpflt - var c *Mpcplx - switch v.Ctype { case CTINT, CTRUNE: - i = new(Mpint) + i := new(Mpint) mpmovefixfix(i, v.U.Xval) v.U.Xval = i case CTFLT: - f = new(Mpflt) + f := new(Mpflt) mpmovefltflt(f, v.U.Fval) v.U.Fval = f case CTCPLX: - c = new(Mpcplx) + c := new(Mpcplx) mpmovefltflt(&c.Real, &v.U.Cval.Real) mpmovefltflt(&c.Imag, &v.U.Cval.Imag) v.U.Cval = c @@ -312,19 +300,17 @@ } func tocplx(v Val) Val { - var c *Mpcplx - switch v.Ctype { case CTINT, CTRUNE: - c = new(Mpcplx) + c := new(Mpcplx) Mpmovefixflt(&c.Real, v.U.Xval) Mpmovecflt(&c.Imag, 0.0) v.Ctype = CTCPLX v.U.Cval = c case CTFLT: - c = new(Mpcplx) + c := new(Mpcplx) mpmovefltflt(&c.Real, v.U.Fval) Mpmovecflt(&c.Imag, 0.0) v.Ctype = CTCPLX @@ -335,18 +321,16 @@ } func toflt(v Val) Val { - var f *Mpflt - switch v.Ctype { case CTINT, CTRUNE: - f = new(Mpflt) + f := new(Mpflt) Mpmovefixflt(f, v.U.Xval) v.Ctype = CTFLT v.U.Fval = f case CTCPLX: - f = new(Mpflt) + f := new(Mpflt) mpmovefltflt(f, &v.U.Cval.Real) if mpcmpfltc(&v.U.Cval.Imag, 0) != 0 { Yyerror("constant %v%vi truncated to real", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp|obj.FmtSign)) @@ -359,14 +343,12 @@ } func toint(v Val) Val { - var i *Mpint - switch v.Ctype { case CTRUNE: v.Ctype = CTINT case CTFLT: - i = new(Mpint) + i := new(Mpint) if mpmovefltfix(i, v.U.Fval) < 0 { Yyerror("constant %v truncated to integer", Fconv(v.U.Fval, obj.FmtSharp)) } @@ -374,7 +356,7 @@ v.U.Xval = i case CTCPLX: - i = new(Mpint) + i := new(Mpint) if mpmovefltfix(i, &v.U.Cval.Real) < 0 { Yyerror("constant %v%vi truncated to integer", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp|obj.FmtSign)) } @@ -444,17 +426,14 @@ } func tostr(v Val) Val { - var rune_ uint - var s *Strlit - switch v.Ctype { case CTINT, CTRUNE: if Mpcmpfixfix(v.U.Xval, Minintval[TINT]) < 0 || Mpcmpfixfix(v.U.Xval, Maxintval[TINT]) > 0 { Yyerror("overflow in int -> string") } - rune_ = uint(Mpgetfix(v.U.Xval)) - s = &Strlit{S: string(rune_)} + rune_ := uint(Mpgetfix(v.U.Xval)) + s := &Strlit{S: string(rune_)} v = Val{} v.Ctype = CTSTR v.U.Sval = s @@ -480,9 +459,7 @@ } func Isconst(n *Node, ct int) bool { - var t int - - t = consttype(n) + t := consttype(n) // If the caller is asking for CTINT, allow CTRUNE too. // Makes life easier for back ends. @@ -490,11 +467,9 @@ } func saveorig(n *Node) *Node { - var n1 *Node - if n == n.Orig { // duplicate node for n->orig. - n1 = Nod(OLITERAL, nil, nil) + n1 := Nod(OLITERAL, nil, nil) n.Orig = n1 *n1 = *n @@ -507,20 +482,6 @@ * if n is constant, rewrite as OLITERAL node. */ func evconst(n *Node) { - var nl *Node - var nr *Node - var norig *Node - var str *Strlit - var wl int - var wr int - var lno int - var et int - var v Val - var rv Val - var b Mpint - var l1 *NodeList - var l2 *NodeList - // pick off just the opcodes that can be // constant evaluated. switch n.Op { @@ -563,7 +524,11 @@ // merge adjacent constants in the argument list. case OADDSTR: - for l1 = n.List; l1 != nil; l1 = l1.Next { + var nr *Node + var nl *Node + var str *Strlit + var l2 *NodeList + for l1 := n.List; l1 != nil; l1 = l1.Next { if Isconst(l1.N, CTSTR) && l1.Next != nil && Isconst(l1.Next.N, CTSTR) { // merge from l1 up to but not including l2 str = new(Strlit) @@ -585,7 +550,7 @@ } // fix list end pointer. - for l2 = n.List; l2 != nil; l2 = l2.Next { + for l2 := n.List; l2 != nil; l2 = l2.Next { n.List.End = l2 } @@ -598,19 +563,24 @@ return } - nl = n.Left + nl := n.Left if nl == nil || nl.Type == nil { return } if consttype(nl) < 0 { return } - wl = int(nl.Type.Etype) + wl := int(nl.Type.Etype) if Isint[wl] != 0 || Isfloat[wl] != 0 || Iscomplex[wl] != 0 { wl = TIDEAL } - nr = n.Right + nr := n.Right + var rv Val + var lno int + var wr int + var v Val + var norig *Node if nr == nil { goto unary } @@ -1020,13 +990,14 @@ case OCOM<<16 | CTINT, OCOM<<16 | CTRUNE: - et = Txxx + et := Txxx if nl.Type != nil { et = int(nl.Type.Etype) } // calculate the mask in b // result will be (a ^ mask) + var b Mpint switch et { // signed guys change sign default: @@ -1107,9 +1078,7 @@ } func nodlit(v Val) *Node { - var n *Node - - n = Nod(OLITERAL, nil, nil) + n := Nod(OLITERAL, nil, nil) n.Val = v switch v.Ctype { default: @@ -1135,14 +1104,11 @@ } func nodcplxlit(r Val, i Val) *Node { - var n *Node - var c *Mpcplx - r = toflt(r) i = toflt(i) - c = new(Mpcplx) - n = Nod(OLITERAL, nil, nil) + c := new(Mpcplx) + n := Nod(OLITERAL, nil, nil) n.Type = Types[TIDEAL] n.Val.U.Cval = c n.Val.Ctype = CTCPLX @@ -1159,9 +1125,6 @@ // idealkind returns a constant kind like consttype // but for an arbitrary "ideal" (untyped constant) expression. func idealkind(n *Node) int { - var k1 int - var k2 int - if n == nil || !isideal(n.Type) { return CTxxx } @@ -1186,9 +1149,9 @@ OXOR, OOR, OPLUS: - k1 = idealkind(n.Left) + k1 := idealkind(n.Left) - k2 = idealkind(n.Right) + k2 := idealkind(n.Right) if k1 > k2 { return k1 } else { @@ -1227,26 +1190,21 @@ } func defaultlit(np **Node, t *Type) { - var lno int - var ctype int - var n *Node - var nn *Node - var t1 *Type - - n = *np + n := *np if n == nil || !isideal(n.Type) { return } if n.Op == OLITERAL { - nn = Nod(OXXX, nil, nil) + nn := Nod(OXXX, nil, nil) *nn = *n n = nn *np = n } - lno = int(setlineno(n)) - ctype = idealkind(n) + lno := int(setlineno(n)) + ctype := idealkind(n) + var t1 *Type switch ctype { default: if t != nil { @@ -1266,7 +1224,7 @@ } if n.Val.Ctype == CTSTR { - t1 = Types[TSTRING] + t1 := Types[TSTRING] Convlit(np, t1) break } @@ -1277,7 +1235,7 @@ Fatal("defaultlit: idealkind is CTxxx: %v", Nconv(n, obj.FmtSign)) case CTBOOL: - t1 = Types[TBOOL] + t1 := Types[TBOOL] if t != nil && t.Etype == TBOOL { t1 = t } @@ -1330,13 +1288,8 @@ * force means must assign concrete (non-ideal) type. */ func defaultlit2(lp **Node, rp **Node, force int) { - var l *Node - var r *Node - var lkind int - var rkind int - - l = *lp - r = *rp + l := *lp + r := *rp if l.Type == nil || r.Type == nil { return } @@ -1358,8 +1311,8 @@ Convlit(rp, Types[TBOOL]) } - lkind = idealkind(l) - rkind = idealkind(r) + lkind := idealkind(l) + rkind := idealkind(r) if lkind == CTCPLX || rkind == CTCPLX { Convlit(lp, Types[TCOMPLEX128]) Convlit(rp, Types[TCOMPLEX128]) @@ -1473,10 +1426,7 @@ * for back end. */ func Convconst(con *Node, t *Type, val *Val) { - var i int64 - var tt int - - tt = Simsimtype(t) + tt := Simsimtype(t) // copy the constant for conversion Nodconst(con, Types[TINT8], 0) @@ -1487,6 +1437,7 @@ if Isint[tt] != 0 { con.Val.Ctype = CTINT con.Val.U.Xval = new(Mpint) + var i int64 switch val.Ctype { default: Fatal("convconst ctype=%d %v", val.Ctype, Tconv(t, obj.FmtLong)) @@ -1614,9 +1565,6 @@ // Only called for expressions known to evaluated to compile-time // constants. func isgoconst(n *Node) bool { - var l *Node - var t *Type - if n.Orig != nil { n = n.Orig } @@ -1661,7 +1609,7 @@ case OLEN, OCAP: - l = n.Left + l := n.Left if isgoconst(l) { return true } @@ -1669,7 +1617,7 @@ // Special case: len/cap is constant when applied to array or // pointer to array when the expression does not contain // function calls or channel receive operations. - t = l.Type + t := l.Type if t != nil && Isptr[t.Etype] != 0 { t = t.Type @@ -1684,7 +1632,7 @@ } case ONAME: - l = n.Sym.Def + l := n.Sym.Def if l != nil && l.Op == OLITERAL && n.Val.Ctype != CTNIL { return true } @@ -1696,7 +1644,7 @@ // Only constant calls are unsafe.Alignof, Offsetof, and Sizeof. case OCALL: - l = n.Left + l := n.Left for l.Op == OPAREN { l = l.Left @@ -1714,8 +1662,6 @@ } func hascallchan(n *Node) bool { - var l *NodeList - if n == nil { return false } @@ -1747,12 +1693,12 @@ return true } - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if hascallchan(l.N) { return true } } - for l = n.Rlist; l != nil; l = l.Next { + for l := n.Rlist; l != nil; l = l.Next { if hascallchan(l.N) { return true }
diff --git a/src/cmd/internal/gc/cplx.go b/src/cmd/internal/gc/cplx.go index 34decd1..c07ba34 100644 --- a/src/cmd/internal/gc/cplx.go +++ b/src/cmd/internal/gc/cplx.go
@@ -20,14 +20,6 @@ func Complexbool(op int, nl *Node, nr *Node, true_ bool, likely int, to *obj.Prog) { var tnl Node - var tnr Node - var n1 Node - var n2 Node - var n3 Node - var n4 Node - var na Node - var nb Node - var nc Node // make both sides addable in ullman order if nr != nil { @@ -38,6 +30,7 @@ } if nr.Addable == 0 { + var tnr Node Tempname(&tnr, nr.Type) Thearch.Cgen(nr, &tnr) nr = &tnr @@ -53,13 +46,19 @@ // build tree // real(l) == real(r) && imag(l) == imag(r) + var n2 Node + var n1 Node subnode(&n1, &n2, nl) + var n3 Node + var n4 Node subnode(&n3, &n4, nr) - na = Node{} + na := Node{} na.Op = OANDAND + var nb Node na.Left = &nb + var nc Node na.Right = &nc na.Type = Types[TBOOL] @@ -84,16 +83,13 @@ // break addable nc-complex into nr-real and ni-imaginary func subnode(nr *Node, ni *Node, nc *Node) { - var tc int - var t *Type - if nc.Addable == 0 { Fatal("subnode not addable") } - tc = Simsimtype(nc.Type) + tc := Simsimtype(nc.Type) tc = cplxsubtype(tc) - t = Types[tc] + t := Types[tc] if nc.Op == OLITERAL { nodfconst(nr, t, &nc.Val.U.Cval.Real) @@ -111,9 +107,7 @@ // generate code res = -nl func minus(nl *Node, res *Node) { - var ra Node - - ra = Node{} + ra := Node{} ra.Op = OMINUS ra.Left = nl ra.Type = nl.Type @@ -146,13 +140,12 @@ var n4 Node var n5 Node var n6 Node - var ra Node subnode(&n1, &n2, nl) subnode(&n3, &n4, nr) subnode(&n5, &n6, res) - ra = Node{} + ra := Node{} ra.Op = uint8(op) ra.Left = &n1 ra.Right = &n3 @@ -178,9 +171,6 @@ var n4 Node var n5 Node var n6 Node - var rm1 Node - var rm2 Node - var ra Node var tmp Node subnode(&n1, &n2, nl) @@ -189,20 +179,20 @@ Tempname(&tmp, n5.Type) // real part -> tmp - rm1 = Node{} + rm1 := Node{} rm1.Op = OMUL rm1.Left = &n1 rm1.Right = &n3 rm1.Type = n1.Type - rm2 = Node{} + rm2 := Node{} rm2.Op = OMUL rm2.Left = &n2 rm2.Right = &n4 rm2.Type = n2.Type - ra = Node{} + ra := Node{} ra.Op = OSUB ra.Left = &rm1 ra.Right = &rm2 @@ -300,14 +290,6 @@ } func Complexmove(f *Node, t *Node) { - var ft int - var tt int - var n1 Node - var n2 Node - var n3 Node - var n4 Node - var tmp Node - if Debug['g'] != 0 { Dump("\ncomplexmove-f", f) Dump("complexmove-t", t) @@ -317,8 +299,8 @@ Fatal("complexmove: to not addable") } - ft = Simsimtype(f.Type) - tt = Simsimtype(t.Type) + ft := Simsimtype(f.Type) + tt := Simsimtype(t.Type) switch uint32(ft)<<16 | uint32(tt) { default: Fatal("complexmove: unknown conversion: %v -> %v\n", Tconv(f.Type, 0), Tconv(t.Type, 0)) @@ -331,12 +313,17 @@ TCOMPLEX128<<16 | TCOMPLEX64, TCOMPLEX128<<16 | TCOMPLEX128: if f.Addable == 0 || overlap_cplx(f, t) { + var tmp Node Tempname(&tmp, f.Type) Complexmove(f, &tmp) f = &tmp } + var n1 Node + var n2 Node subnode(&n1, &n2, f) + var n4 Node + var n3 Node subnode(&n3, &n4, t) Thearch.Cgen(&n1, &n3) @@ -345,16 +332,6 @@ } func Complexgen(n *Node, res *Node) { - var nl *Node - var nr *Node - var tnl Node - var tnr Node - var n1 Node - var n2 Node - var tmp Node - var tl int - var tr int - if Debug['g'] != 0 { Dump("\ncomplexgen-n", n) Dump("complexgen-res", res) @@ -368,7 +345,10 @@ switch n.Op { case OCOMPLEX: if res.Addable != 0 { + var n1 Node + var n2 Node subnode(&n1, &n2, res) + var tmp Node Tempname(&tmp, n1.Type) Thearch.Cgen(n.Left, &tmp) Thearch.Cgen(n.Right, &n2) @@ -378,13 +358,16 @@ case OREAL, OIMAG: - nl = n.Left + nl := n.Left if nl.Addable == 0 { + var tmp Node Tempname(&tmp, nl.Type) Complexgen(nl, &tmp) nl = &tmp } + var n1 Node + var n2 Node subnode(&n1, &n2, nl) if n.Op == OREAL { Thearch.Cgen(&n1, res) @@ -396,13 +379,14 @@ } // perform conversion from n to res - tl = Simsimtype(res.Type) + tl := Simsimtype(res.Type) tl = cplxsubtype(tl) - tr = Simsimtype(n.Type) + tr := Simsimtype(n.Type) tr = cplxsubtype(tr) if tl != tr { if n.Addable == 0 { + var n1 Node Tempname(&n1, n.Type) Complexmove(n, &n1) n = &n1 @@ -413,6 +397,7 @@ } if res.Addable == 0 { + var n1 Node Thearch.Igen(res, &n1, nil) Thearch.Cgen(n, &n1) Thearch.Regfree(&n1) @@ -437,6 +422,7 @@ OCALLFUNC, OCALLMETH, OCALLINTER: + var n1 Node Thearch.Igen(n, &n1, res) Complexmove(&n1, res) @@ -454,13 +440,14 @@ break } - nl = n.Left + nl := n.Left if nl == nil { return } - nr = n.Right + nr := n.Right // make both sides addable in ullman order + var tnl Node if nr != nil { if nl.Ullman > nr.Ullman && nl.Addable == 0 { Tempname(&tnl, nl.Type) @@ -469,6 +456,7 @@ } if nr.Addable == 0 { + var tnr Node Tempname(&tnr, nr.Type) Thearch.Cgen(nr, &tnr) nr = &tnr
diff --git a/src/cmd/internal/gc/dcl.go b/src/cmd/internal/gc/dcl.go index 577f7ec..ceececd 100644 --- a/src/cmd/internal/gc/dcl.go +++ b/src/cmd/internal/gc/dcl.go
@@ -35,9 +35,7 @@ } func push() *Sym { - var d *Sym - - d = new(Sym) + d := new(Sym) d.Lastlineno = lineno d.Link = dclstack dclstack = d @@ -45,9 +43,7 @@ } func pushdcl(s *Sym) *Sym { - var d *Sym - - d = push() + d := push() dcopy(d, s) if dflag() { fmt.Printf("\t%v push %v %p\n", Ctxt.Line(int(lineno)), Sconv(s, 0), s.Def) @@ -94,9 +90,7 @@ } func markdcl() { - var d *Sym - - d = push() + d := push() d.Name = "" // used as a mark in fifo d.Block = block @@ -108,11 +102,9 @@ // print("markdcl\n"); func dumpdcl(st string) { var s *Sym - var d *Sym - var i int - i = 0 - for d = dclstack; d != nil; d = d.Link { + i := 0 + for d := dclstack; d != nil; d = d.Link { i++ fmt.Printf(" %.2d %p", i, d) if d.Name == "" { @@ -127,9 +119,7 @@ } func testdclstack() { - var d *Sym - - for d = dclstack; d != nil; d = d.Link { + for d := dclstack; d != nil; d = d.Link { if d.Name == "" { if nerrors != 0 { errorexit() @@ -141,10 +131,6 @@ } func redeclare(s *Sym, where string) { - var pkgstr *Strlit - var line1 int - var line2 int - if s.Lastlineno == 0 { var tmp *Strlit if s.Origpkg != nil { @@ -152,11 +138,11 @@ } else { tmp = s.Pkg.Path } - pkgstr = tmp + pkgstr := tmp Yyerror("%v redeclared %s\n"+"\tprevious declaration during import \"%v\"", Sconv(s, 0), where, Zconv(pkgstr, 0)) } else { - line1 = parserline() - line2 = int(s.Lastlineno) + line1 := parserline() + line2 := int(s.Lastlineno) // When an import and a declaration collide in separate files, // present the import as the "redeclared", because the declaration @@ -180,9 +166,6 @@ var declare_typegen int func declare(n *Node, ctxt int) { - var s *Sym - var gen int - if ctxt == PDISCARD { return } @@ -192,7 +175,7 @@ } n.Lineno = int32(parserline()) - s = n.Sym + s := n.Sym // kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later. if importpkg == nil && typecheckok == 0 && s.Pkg != localpkg { @@ -203,7 +186,7 @@ Yyerror("cannot declare init - must be func", s) } - gen = 0 + gen := 0 if ctxt == PEXTERN { externdcl = list(externdcl, n) if dflag() { @@ -264,20 +247,15 @@ * new_name_list (type | [type] = expr_list) */ func variter(vl *NodeList, t *Node, el *NodeList) *NodeList { - var doexpr bool - var v *Node - var e *Node - var as2 *Node - var init *NodeList - - init = nil - doexpr = el != nil + init := (*NodeList)(nil) + doexpr := el != nil if count(el) == 1 && count(vl) > 1 { - e = el.N - as2 = Nod(OAS2, nil, nil) + e := el.N + as2 := Nod(OAS2, nil, nil) as2.List = vl as2.Rlist = list1(e) + var v *Node for ; vl != nil; vl = vl.Next { v = vl.N v.Op = ONAME @@ -292,6 +270,8 @@ return list(init, as2) } + var v *Node + var e *Node for ; vl != nil; vl = vl.Next { if doexpr { if el == nil { @@ -333,11 +313,7 @@ * new_name_list [[type] = expr_list] */ func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList { - var v *Node - var c *Node - var vv *NodeList - - vv = nil + vv := (*NodeList)(nil) if cl == nil { if t != nil { Yyerror("const declaration cannot have type without expression") @@ -351,6 +327,8 @@ cl = listtreecopy(cl) + var v *Node + var c *Node for ; vl != nil; vl = vl.Next { if cl == nil { Yyerror("missing value in const declaration") @@ -382,13 +360,11 @@ * typically for labels or other one-off names. */ func newname(s *Sym) *Node { - var n *Node - if s == nil { Fatal("newname nil") } - n = Nod(ONAME, nil, nil) + n := Nod(ONAME, nil, nil) n.Sym = s n.Type = nil n.Addable = 1 @@ -402,9 +378,7 @@ * being declared. */ func dclname(s *Sym) *Node { - var n *Node - - n = newname(s) + n := newname(s) n.Op = ONONAME // caller will correct it return n } @@ -429,10 +403,7 @@ * generated if no name has been defined. */ func oldname(s *Sym) *Node { - var n *Node - var c *Node - - n = s.Def + n := s.Def if n == nil { // maybe a top-level name will come along // to give this a definition later. @@ -453,7 +424,7 @@ // make x a closure variable unnecessarily. if n.Closure == nil || n.Closure.Funcdepth != Funcdepth { // create new closure var. - c = Nod(ONAME, nil, nil) + c := Nod(ONAME, nil, nil) c.Sym = s c.Class = PPARAMREF @@ -493,20 +464,16 @@ } func colasdefn(left *NodeList, defn *Node) { - var nnew int - var nerr int - var l *NodeList - var n *Node - - for l = left; l != nil; l = l.Next { + for l := left; l != nil; l = l.Next { if l.N.Sym != nil { l.N.Sym.Flags |= SymUniq } } - nnew = 0 - nerr = 0 - for l = left; l != nil; l = l.Next { + nnew := 0 + nerr := 0 + var n *Node + for l := left; l != nil; l = l.Next { n = l.N if isblank(n) { continue @@ -543,9 +510,7 @@ } func colas(left *NodeList, right *NodeList, lno int32) *Node { - var as *Node - - as = Nod(OAS2, nil, nil) + as := Nod(OAS2, nil, nil) as.List = left as.Rlist = right as.Colas = 1 @@ -622,11 +587,6 @@ } func funcargs(nt *Node) { - var n *Node - var nn *Node - var l *NodeList - var gen int - if nt.Op != OTFUNC { Fatal("funcargs %v", Oconv(int(nt.Op), 0)) } @@ -640,7 +600,7 @@ // no n->defn because type checking of func header // will not fill in the types until later if nt.Left != nil { - n = nt.Left + n := nt.Left if n.Op != ODCLFIELD { Fatal("funcargs receiver %v", Oconv(int(n.Op), 0)) } @@ -655,7 +615,8 @@ } } - for l = nt.List; l != nil; l = l.Next { + var n *Node + for l := nt.List; l != nil; l = l.Next { n = l.N if n.Op != ODCLFIELD { Fatal("funcargs in %v", Oconv(int(n.Op), 0)) @@ -672,9 +633,10 @@ } // declare the out arguments. - gen = count(nt.List) + gen := count(nt.List) var i int = 0 - for l = nt.Rlist; l != nil; l = l.Next { + var nn *Node + for l := nt.Rlist; l != nil; l = l.Next { n = l.N if n.Op != ODCLFIELD { @@ -726,15 +688,13 @@ * used functype directly to parse the function's type. */ func funcargs2(t *Type) { - var ft *Type - var n *Node - if t.Etype != TFUNC { Fatal("funcargs2 %v", Tconv(t, 0)) } if t.Thistuple != 0 { - for ft = getthisx(t).Type; ft != nil; ft = ft.Down { + var n *Node + for ft := getthisx(t).Type; ft != nil; ft = ft.Down { if ft.Nname == nil || ft.Nname.Sym == nil { continue } @@ -745,7 +705,8 @@ } if t.Intuple != 0 { - for ft = getinargx(t).Type; ft != nil; ft = ft.Down { + var n *Node + for ft := getinargx(t).Type; ft != nil; ft = ft.Down { if ft.Nname == nil || ft.Nname.Sym == nil { continue } @@ -756,7 +717,8 @@ } if t.Outtuple != 0 { - for ft = getoutargx(t).Type; ft != nil; ft = ft.Down { + var n *Node + for ft := getoutargx(t).Type; ft != nil; ft = ft.Down { if ft.Nname == nil || ft.Nname.Sym == nil { continue } @@ -790,9 +752,7 @@ * new type being defined with name s. */ func typedcl0(s *Sym) *Node { - var n *Node - - n = newname(s) + n := newname(s) n.Op = OTYPE declare(n, dclcontext) return n @@ -833,17 +793,14 @@ } func structfield(n *Node) *Type { - var f *Type - var lno int - - lno = int(lineno) + lno := int(lineno) lineno = n.Lineno if n.Op != ODCLFIELD { Fatal("structfield: oops %v\n", Nconv(n, 0)) } - f = typ(TFIELD) + f := typ(TFIELD) f.Isddd = n.Isddd if n.Right != nil { @@ -890,9 +847,7 @@ var uniqgen uint32 func checkdupfields(t *Type, what string) { - var lno int - - lno = int(lineno) + lno := int(lineno) for ; t != nil; t = t.Down { if t.Sym != nil && t.Nname != nil && !isblank(t.Nname) { @@ -913,19 +868,17 @@ * a type for struct/interface/arglist */ func tostruct(l *NodeList) *Type { - var t *Type var f *Type - var tp **Type - t = typ(TSTRUCT) + t := typ(TSTRUCT) - for tp = &t.Type; l != nil; l = l.Next { + for tp := &t.Type; l != nil; l = l.Next { f = structfield(l.N) *tp = f tp = &f.Down } - for f = t.Type; f != nil && t.Broke == 0; f = f.Down { + for f := t.Type; f != nil && t.Broke == 0; f = f.Down { if f.Broke != 0 { t.Broke = 1 } @@ -942,14 +895,12 @@ } func tofunargs(l *NodeList) *Type { - var t *Type var f *Type - var tp **Type - t = typ(TSTRUCT) + t := typ(TSTRUCT) t.Funarg = 1 - for tp = &t.Type; l != nil; l = l.Next { + for tp := &t.Type; l != nil; l = l.Next { f = structfield(l.N) f.Funarg = 1 @@ -962,7 +913,7 @@ tp = &f.Down } - for f = t.Type; f != nil && t.Broke == 0; f = f.Down { + for f := t.Type; f != nil && t.Broke == 0; f = f.Down { if f.Broke != 0 { t.Broke = 1 } @@ -972,10 +923,7 @@ } func interfacefield(n *Node) *Type { - var f *Type - var lno int - - lno = int(lineno) + lno := int(lineno) lineno = n.Lineno if n.Op != ODCLFIELD { @@ -986,7 +934,7 @@ Yyerror("interface method cannot have annotation") } - f = typ(TFIELD) + f := typ(TFIELD) f.Isddd = n.Isddd if n.Right != nil { @@ -1042,14 +990,12 @@ } func tointerface(l *NodeList) *Type { - var t *Type var f *Type - var tp **Type var t1 *Type - t = typ(TINTER) + t := typ(TINTER) - tp = &t.Type + tp := &t.Type for ; l != nil; l = l.Next { f = interfacefield(l.N) @@ -1072,7 +1018,7 @@ } } - for f = t.Type; f != nil && t.Broke == 0; f = f.Down { + for f := t.Type; f != nil && t.Broke == 0; f = f.Down { if f.Broke != 0 { t.Broke = 1 } @@ -1087,20 +1033,19 @@ } func embedded(s *Sym, pkg *Pkg) *Node { - var n *Node - var name string const ( CenterDot = 0xB7 ) // Names sometimes have disambiguation junk // appended after a center dot. Discard it when // making the name for the embedded struct field. - name = s.Name + name := s.Name if i := strings.Index(s.Name, string(CenterDot)); i >= 0 { name = s.Name[:i] } + var n *Node if exportname(name) { n = newname(Lookup(name)) } else if s.Pkg == builtinpkg { @@ -1127,14 +1072,8 @@ } func checkarglist(all *NodeList, input int) *NodeList { - var named int - var n *Node - var t *Node - var nextt *Node - var l *NodeList - - named = 0 - for l = all; l != nil; l = l.Next { + named := 0 + for l := all; l != nil; l = l.Next { if l.N.Op == OKEY { named = 1 break @@ -1142,7 +1081,8 @@ } if named != 0 { - n = nil + n := (*Node)(nil) + var l *NodeList for l = all; l != nil; l = l.Next { n = l.N if n.Op != OKEY && n.Sym == nil { @@ -1156,8 +1096,10 @@ } } - nextt = nil - for l = all; l != nil; l = l.Next { + nextt := (*Node)(nil) + var t *Node + var n *Node + for l := all; l != nil; l = l.Next { // can cache result from findtype to avoid // quadratic behavior here, but unlikely to matter. n = l.N @@ -1220,9 +1162,7 @@ } func fakethis() *Node { - var n *Node - - n = Nod(ODCLFIELD, nil, typenod(Ptrto(typ(TSTRUCT)))) + n := Nod(ODCLFIELD, nil, typenod(Ptrto(typ(TSTRUCT)))) return n } @@ -1233,14 +1173,11 @@ * (See fakethis above.) */ func isifacemethod(f *Type) bool { - var rcvr *Type - var t *Type - - rcvr = getthisx(f).Type + rcvr := getthisx(f).Type if rcvr.Sym != nil { return false } - t = rcvr.Type + t := rcvr.Type if Isptr[t.Etype] == 0 { return false } @@ -1256,13 +1193,9 @@ * into a type */ func functype(this *Node, in *NodeList, out *NodeList) *Type { - var t *Type - var rcvr *NodeList - var s *Sym + t := typ(TFUNC) - t = typ(TFUNC) - - rcvr = nil + rcvr := (*NodeList)(nil) if this != nil { rcvr = list1(this) } @@ -1286,7 +1219,7 @@ t.Intuple = count(in) t.Outnamed = 0 if t.Outtuple > 0 && out.N.Left != nil && out.N.Left.Orig != nil { - s = out.N.Left.Orig.Sym + s := out.N.Left.Orig.Sym if s != nil && (s.Name[0] != '~' || s.Name[1] != 'r') { // ~r%d is the name invented for an unnamed result t.Outnamed = 1 } @@ -1300,11 +1233,10 @@ func methodsym(nsym *Sym, t0 *Type, iface int) *Sym { var s *Sym var p string - var t *Type var suffix string var spkg *Pkg - t = t0 + t := t0 if t == nil { goto bad } @@ -1367,9 +1299,7 @@ } func methodname(n *Node, t *Type) *Node { - var s *Sym - - s = methodsym(n.Sym, t, 0) + s := methodsym(n.Sym, t, 0) if s == nil { return n } @@ -1377,10 +1307,7 @@ } func methodname1(n *Node, t *Node) *Node { - var star string - var p string - - star = "" + star := "" if t.Op == OIND { star = "*" t = t.Left @@ -1390,6 +1317,7 @@ return newname(n.Sym) } + var p string if star != "" { p = fmt.Sprintf("(%s%v).%v", star, Sconv(t.Sym, 0), Sconv(n.Sym, 0)) } else { @@ -1410,25 +1338,20 @@ * n is fieldname, pa is base type, t is function type */ func addmethod(sf *Sym, t *Type, local bool, nointerface bool) { - var f *Type - var d *Type - var pa *Type - var n *Node - // get field sym if sf == nil { Fatal("no method symbol") } // get parent type sym - pa = getthisx(t).Type // ptr to this structure + pa := getthisx(t).Type // ptr to this structure if pa == nil { Yyerror("missing receiver") return } pa = pa.Type - f = methtype(pa, 1) + f := methtype(pa, 1) if f == nil { t = pa if t == nil { // rely on typecheck having complained before @@ -1472,7 +1395,7 @@ pa = f if pa.Etype == TSTRUCT { - for f = pa.Type; f != nil; f = f.Down { + for f := pa.Type; f != nil; f = f.Down { if f.Sym == sf { Yyerror("type %v has both field and method named %v", Tconv(pa, 0), Sconv(sf, 0)) return @@ -1487,11 +1410,11 @@ return } - n = Nod(ODCLFIELD, newname(sf), nil) + n := Nod(ODCLFIELD, newname(sf), nil) n.Type = t - d = nil // last found - for f = pa.Method; f != nil; f = f.Down { + d := (*Type)(nil) // last found + for f := pa.Method; f != nil; f = f.Down { d = f if f.Etype != TFIELD { Fatal("addmethod: not TFIELD: %v", Tconv(f, obj.FmtLong)) @@ -1549,11 +1472,8 @@ } func funcsym(s *Sym) *Sym { - var p string - var s1 *Sym - - p = fmt.Sprintf("%s·f", s.Name) - s1 = Pkglookup(p, s.Pkg) + p := fmt.Sprintf("%s·f", s.Name) + s1 := Pkglookup(p, s.Pkg) if s1.Def == nil { s1.Def = newname(s1)
diff --git a/src/cmd/internal/gc/esc.go b/src/cmd/internal/gc/esc.go index f4d5b43..697ca677 100644 --- a/src/cmd/internal/gc/esc.go +++ b/src/cmd/internal/gc/esc.go
@@ -49,30 +49,23 @@ ) func escapes(all *NodeList) { - var l *NodeList - - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { l.N.Walkgen = 0 } visitgen = 0 - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { if l.N.Op == ODCLFUNC && l.N.Curfn == nil { visit(l.N) } } - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { l.N.Walkgen = 0 } } func visit(n *Node) uint32 { - var min uint32 - var recursive bool - var l *NodeList - var block *NodeList - if n.Walkgen > 0 { // already visited return n.Walkgen @@ -81,9 +74,9 @@ visitgen++ n.Walkgen = visitgen visitgen++ - min = visitgen + min := visitgen - l = new(NodeList) + l := new(NodeList) l.Next = stack l.N = n stack = l @@ -95,13 +88,14 @@ // If visitcodelist found its way back to n->walkgen, then this // block is a set of mutually recursive functions. // Otherwise it's just a lone function that does not recurse. - recursive = min == n.Walkgen + recursive := min == n.Walkgen // Remove connected component from stack. // Mark walkgen so that future visits return a large number // so as not to affect the caller's min. - block = stack + block := stack + var l *NodeList for l = stack; l.N != n; l = l.Next { l.N.Walkgen = ^uint32(0) } @@ -124,9 +118,6 @@ } func visitcode(n *Node, min uint32) uint32 { - var fn *Node - var m uint32 - if n == nil { return min } @@ -142,12 +133,12 @@ min = visitcodelist(n.Rlist, min) if n.Op == OCALLFUNC || n.Op == OCALLMETH { - fn = n.Left + fn := n.Left if n.Op == OCALLMETH { fn = n.Left.Right.Sym.Def } if fn != nil && fn.Op == ONAME && fn.Class == PFUNC && fn.Defn != nil { - m = visit(fn.Defn) + m := visit(fn.Defn) if m < min { min = m } @@ -155,7 +146,7 @@ } if n.Op == OCLOSURE { - m = visit(n.Closure) + m := visit(n.Closure) if m < min { min = m } @@ -205,9 +196,6 @@ var tags [16]*Strlit func mktag(mask int) *Strlit { - var s *Strlit - var buf string - switch mask & EscMask { case EscNone, EscReturn: @@ -223,8 +211,8 @@ return tags[mask] } - buf = fmt.Sprintf("esc:0x%x", mask) - s = newstrlit(buf) + buf := fmt.Sprintf("esc:0x%x", mask) + s := newstrlit(buf) if mask < len(tags) { tags[mask] = s } @@ -232,15 +220,13 @@ } func parsetag(note *Strlit) int { - var em int - if note == nil { return EscUnknown } if !strings.HasPrefix(note.S, "esc:") { return EscUnknown } - em = atoi(note.S[4:]) + em := atoi(note.S[4:]) if em == 0 { return EscNone } @@ -248,12 +234,8 @@ } func analyze(all *NodeList, recursive bool) { - var l *NodeList - var es EscState - var e *EscState - - es = EscState{} - e = &es + es := EscState{} + e := &es e.theSink.Op = ONAME e.theSink.Orig = &e.theSink e.theSink.Class = PEXTERN @@ -267,14 +249,14 @@ e.funcParam.Sym = Lookup(".param") e.funcParam.Escloopdepth = 10000000 - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { l.N.Esc = EscFuncPlanned } } // flow-analyze functions - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { escfunc(e, l.N) } @@ -284,19 +266,19 @@ // visit the upstream of each dst, mark address nodes with // addrescapes, mark parameters unsafe - for l = e.dsts; l != nil; l = l.Next { + for l := e.dsts; l != nil; l = l.Next { escflood(e, l.N) } // for all top level functions, tag the typenodes corresponding to the param nodes - for l = all; l != nil; l = l.Next { + for l := all; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { esctag(e, l.N) } } if Debug['m'] != 0 { - for l = e.noesc; l != nil; l = l.Next { + for l := e.noesc; l != nil; l = l.Next { if l.N.Esc == EscNone { var tmp *Sym if l.N.Curfn != nil && l.N.Curfn.Nname != nil { @@ -311,10 +293,6 @@ } func escfunc(e *EscState, func_ *Node) { - var savefn *Node - var ll *NodeList - var saveld int - // print("escfunc %N %s\n", func->nname, e->recursive?"(recursive)":""); if func_.Esc != 1 { @@ -322,12 +300,12 @@ } func_.Esc = EscFuncStarted - saveld = e.loopdepth + saveld := e.loopdepth e.loopdepth = 1 - savefn = Curfn + savefn := Curfn Curfn = func_ - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { if ll.N.Op != ONAME { continue } @@ -352,7 +330,7 @@ // in a mutually recursive group we lose track of the return values if e.recursive { - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { if ll.N.Op == ONAME && ll.N.Class == PPARAMOUT { escflows(e, &e.theSink, ll.N) } @@ -426,17 +404,14 @@ } func esc(e *EscState, n *Node, up *Node) { - var lno int var ll *NodeList var lr *NodeList - var a *Node - var v *Node if n == nil { return } - lno = int(setlineno(n)) + lno := int(setlineno(n)) // ninit logically runs at a different loopdepth than the rest of the for loop. esclist(e, n.Ninit, n) @@ -702,6 +677,8 @@ // Link addresses of captured variables to closure. case OCLOSURE: + var a *Node + var v *Node for ll = n.Cvars; ll != nil; ll = ll.Next { v = ll.N if v.Op == OXXX { // unnamed out argument; see dcl.c:/^funcargs @@ -780,9 +757,6 @@ // evaluated in curfn. For expr==nil, dst must still be examined for // evaluations inside it (e.g *f(x) = y) func escassign(e *EscState, dst *Node, src *Node) { - var lno int - var ll *NodeList - if isblank(dst) || dst == nil || src == nil || src.Op == ONONAME || src.Op == OXXX { return } @@ -846,7 +820,7 @@ dst = &e.theSink } - lno = int(setlineno(src)) + lno := int(setlineno(src)) e.pdepth++ switch src.Op { @@ -879,7 +853,7 @@ case OCALLMETH, OCALLFUNC, OCALLINTER: - for ll = src.Escretval; ll != nil; ll = ll.Next { + for ll := src.Escretval; ll != nil; ll = ll.Next { escflows(e, dst, ll.N) } @@ -945,7 +919,6 @@ func escassignfromtag(e *EscState, note *Strlit, dsts *NodeList, src *Node) int { var em int - var em0 int em = parsetag(note) @@ -964,7 +937,7 @@ escassign(e, &e.funcParam, src) } - em0 = em + em0 := em for em >>= EscReturnBits; em != 0 && dsts != nil; (func() { em >>= 1; dsts = dsts.Next })() { if em&1 != 0 { escassign(e, dsts.N, src) @@ -986,15 +959,9 @@ func esccall(e *EscState, n *Node, up *Node) { var ll *NodeList var lr *NodeList - var a *Node - var fn *Node - var src *Node - var t *Type var fntype *Type - var buf string - var i int - fn = nil + fn := (*Node)(nil) switch n.Op { default: Fatal("esccall") @@ -1017,7 +984,7 @@ ll = n.List if n.List != nil && n.List.Next == nil { - a = n.List.N + a := n.List.N if a.Type.Etype == TSTRUCT && a.Type.Funarg != 0 { // f(g()). ll = a.Escretval } @@ -1040,6 +1007,7 @@ escassign(e, fn.Ntype.Left.Left, n.Left.Left) } + var src *Node for lr = fn.Ntype.List; ll != nil && lr != nil; (func() { ll = ll.Next; lr = lr.Next })() { src = ll.N if lr.N.Isddd != 0 && n.Isddd == 0 { @@ -1079,9 +1047,11 @@ } // set up out list on this call node with dummy auto ONAMES in the current (calling) function. - i = 0 + i := 0 - for t = getoutargx(fntype).Type; t != nil; t = t.Down { + var src *Node + var buf string + for t := getoutargx(fntype).Type; t != nil; t = t.Down { src = Nod(ONAME, nil, nil) buf = fmt.Sprintf(".dum%d", i) i++ @@ -1099,14 +1069,15 @@ // Receiver. if n.Op != OCALLFUNC { - t = getthisx(fntype).Type - src = n.Left.Left + t := getthisx(fntype).Type + src := n.Left.Left if haspointers(t.Type) { escassignfromtag(e, t.Note, n.Escretval, src) } } - for t = getinargx(fntype).Type; ll != nil; ll = ll.Next { + var a *Node + for t := getinargx(fntype).Type; ll != nil; ll = ll.Next { src = ll.N if t.Isddd != 0 && n.Isddd == 0 { // Introduce ODDDARG node to represent ... allocation. @@ -1197,8 +1168,6 @@ // Once an object has been moved to the heap, all of it's upstream should be considered // escaping to the global scope. func escflood(e *EscState, dst *Node) { - var l *NodeList - switch dst.Op { case ONAME, OCLOSURE: @@ -1218,7 +1187,7 @@ fmt.Printf("\nescflood:%d: dst %v scope:%v[%d]\n", walkgen, Nconv(dst, obj.FmtShort), Sconv(tmp, 0), dst.Escloopdepth) } - for l = dst.Escflowsrc; l != nil; l = l.Next { + for l := dst.Escflowsrc; l != nil; l = l.Next { walkgen++ escwalk(e, 0, dst, l.N) } @@ -1240,10 +1209,6 @@ ) func escwalk(e *EscState, level int, dst *Node, src *Node) { - var ll *NodeList - var leaks bool - var newlevel int - if src.Walkgen == walkgen && src.Esclevel <= int32(level) { return } @@ -1263,6 +1228,7 @@ e.pdepth++ // Input parameter flowing to output parameter? + var leaks bool if dst.Op == ONAME && dst.Class == PPARAMOUT && dst.Vargen <= 20 { if src.Op == ONAME && src.Class == PPARAM && src.Curfn == dst.Curfn && src.Esc != EscScope && src.Esc != EscHeap { if level == 0 { @@ -1320,7 +1286,7 @@ } } - newlevel = level + newlevel := level if level > MinLevel { newlevel-- } @@ -1373,7 +1339,7 @@ case ODOTPTR, OINDEXMAP, OIND: - newlevel = level + newlevel := level if level > MinLevel { newlevel++ @@ -1382,7 +1348,7 @@ } recurse: - for ll = src.Escflowsrc; ll != nil; ll = ll.Next { + for ll := src.Escflowsrc; ll != nil; ll = ll.Next { escwalk(e, level, dst, ll.N) } @@ -1390,17 +1356,13 @@ } func esctag(e *EscState, func_ *Node) { - var savefn *Node - var ll *NodeList - var t *Type - func_.Esc = EscFuncTagged // External functions are assumed unsafe, // unless //go:noescape is given before the declaration. if func_.Nbody == nil { if func_.Noescape { - for t = getinargx(func_.Type).Type; t != nil; t = t.Down { + for t := getinargx(func_.Type).Type; t != nil; t = t.Down { if haspointers(t.Type) { t.Note = mktag(EscNone) } @@ -1410,10 +1372,10 @@ return } - savefn = Curfn + savefn := Curfn Curfn = func_ - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { if ll.N.Op != ONAME || ll.N.Class != PPARAM { continue }
diff --git a/src/cmd/internal/gc/export.go b/src/cmd/internal/gc/export.go index b0c5931..2467086 100644 --- a/src/cmd/internal/gc/export.go +++ b/src/cmd/internal/gc/export.go
@@ -79,13 +79,11 @@ } func dumppkg(p *Pkg) { - var suffix string - if p == nil || p == localpkg || p.Exported != 0 || p == builtinpkg { return } p.Exported = 1 - suffix = "" + suffix := "" if p.Direct == 0 { suffix = " // indirect" } @@ -100,8 +98,6 @@ } func reexportdep(n *Node) { - var t *Type - if n == nil { return } @@ -135,7 +131,7 @@ // Local variables in the bodies need their type. case ODCL: - t = n.Left.Type + t := n.Left.Type if t != Types[t.Etype] && t != idealbool && t != idealstring { if Isptr[t.Etype] != 0 { @@ -150,7 +146,7 @@ } case OLITERAL: - t = n.Type + t := n.Type if t != Types[n.Type.Etype] && t != idealbool && t != idealstring { if Isptr[t.Etype] != 0 { t = t.Type @@ -190,7 +186,7 @@ OMAKEMAP, OMAKESLICE, OMAKECHAN: - t = n.Type + t := n.Type if t.Sym == nil && t.Type != nil { t = t.Type @@ -215,16 +211,13 @@ } func dumpexportconst(s *Sym) { - var n *Node - var t *Type - - n = s.Def + n := s.Def typecheck(&n, Erv) if n == nil || n.Op != OLITERAL { Fatal("dumpexportconst: oconst nil: %v", Sconv(s, 0)) } - t = n.Type // may or may not be specified + t := n.Type // may or may not be specified dumpexporttype(t) if t != nil && !isideal(t) { @@ -235,17 +228,14 @@ } func dumpexportvar(s *Sym) { - var n *Node - var t *Type - - n = s.Def + n := s.Def typecheck(&n, Erv|Ecall) if n == nil || n.Type == nil { Yyerror("variable exported but not defined: %v", Sconv(s, 0)) return } - t = n.Type + t := n.Type dumpexporttype(t) if t.Etype == TFUNC && n.Class == PFUNC { @@ -279,20 +269,12 @@ } func (x methodbyname) Less(i, j int) bool { - var a *Type - var b *Type - - a = x[i] - b = x[j] + a := x[i] + b := x[j] return stringsCompare(a.Sym.Name, b.Sym.Name) < 0 } func dumpexporttype(t *Type) { - var f *Type - var m []*Type - var i int - var n int - if t == nil { return } @@ -312,22 +294,23 @@ return } - n = 0 - for f = t.Method; f != nil; f = f.Down { + n := 0 + for f := t.Method; f != nil; f = f.Down { dumpexporttype(f) n++ } - m = make([]*Type, n) - i = 0 - for f = t.Method; f != nil; f = f.Down { + m := make([]*Type, n) + i := 0 + for f := t.Method; f != nil; f = f.Down { m[i] = f i++ } sort.Sort(methodbyname(m[:n])) fmt.Fprintf(bout, "\ttype %v %v\n", Sconv(t.Sym, obj.FmtSharp), Tconv(t, obj.FmtSharp|obj.FmtLong)) - for i = 0; i < n; i++ { + var f *Type + for i := 0; i < n; i++ { f = m[i] if f.Nointerface { fmt.Fprintf(bout, "\t//go:nointerface\n") @@ -381,12 +364,7 @@ } func dumpexport() { - var l *NodeList - var i int32 - var lno int32 - var p *Pkg - - lno = lineno + lno := lineno fmt.Fprintf(bout, "\n$$\npackage %s", localpkg.Name) if safemode != 0 { @@ -394,7 +372,8 @@ } fmt.Fprintf(bout, "\n") - for i = 0; i < int32(len(phash)); i++ { + var p *Pkg + for i := int32(0); i < int32(len(phash)); i++ { for p = phash[i]; p != nil; p = p.Link { if p.Direct != 0 { dumppkg(p) @@ -402,7 +381,7 @@ } } - for l = exportlist; l != nil; l = l.Next { + for l := exportlist; l != nil; l = l.Next { lineno = l.N.Lineno dumpsym(l.N.Sym) } @@ -419,10 +398,8 @@ * return the sym for ss, which should match lexical */ func importsym(s *Sym, op int) *Sym { - var pkgstr string - if s.Def != nil && int(s.Def.Op) != op { - pkgstr = fmt.Sprintf("during import \"%v\"", Zconv(importpkg.Path, 0)) + pkgstr := fmt.Sprintf("during import \"%v\"", Zconv(importpkg.Path, 0)) redeclare(s, pkgstr) } @@ -442,11 +419,9 @@ * return the type pkg.name, forward declaring if needed */ func pkgtype(s *Sym) *Type { - var t *Type - importsym(s, OTYPE) if s.Def == nil || s.Def.Op != OTYPE { - t = typ(TFORW) + t := typ(TFORW) t.Sym = s s.Def = typenod(t) } @@ -461,12 +436,11 @@ // Informational: record package name // associated with import path, for use in // human-readable messages. - var p *Pkg if isbadimport(z) { errorexit() } - p = mkpkg(z) + p := mkpkg(z) if p.Name == "" { p.Name = s.Name Pkglookup(s.Name, nil).Npkg++ @@ -481,8 +455,6 @@ } func importconst(s *Sym, t *Type, n *Node) { - var n1 *Node - importsym(s, OLITERAL) Convlit(&n, t) @@ -496,7 +468,7 @@ } if n.Sym != nil { - n1 = Nod(OXXX, nil, nil) + n1 := Nod(OXXX, nil, nil) *n1 = *n n = n1 } @@ -511,8 +483,6 @@ } func importvar(s *Sym, t *Type) { - var n *Node - importsym(s, ONAME) if s.Def != nil && s.Def.Op == ONAME { if Eqtype(t, s.Def.Type) { @@ -521,7 +491,7 @@ Yyerror("inconsistent definition for var %v during import\n\t%v (in \"%v\")\n\t%v (in \"%v\")", Sconv(s, 0), Tconv(s.Def.Type, 0), Zconv(s.Importdef.Path, 0), Tconv(t, 0), Zconv(importpkg.Path, 0)) } - n = newname(s) + n := newname(s) s.Importdef = importpkg n.Type = t declare(n, PEXTERN) @@ -532,8 +502,6 @@ } func importtype(pt *Type, t *Type) { - var n *Node - // override declaration in unsafe.go for Pointer. // there is no way in Go code to define unsafe.Pointer // so we have to supply it. @@ -542,7 +510,7 @@ } if pt.Etype == TFORW { - n = pt.Nod + n := pt.Nod copytype(pt.Nod, t) pt.Nod = n // unzero nod pt.Sym.Importdef = importpkg @@ -560,16 +528,15 @@ func dumpasmhdr() { var b *obj.Biobuf - var l *NodeList - var n *Node - var t *Type b, err := obj.Bopenw(asmhdr) if err != nil { Fatal("%v", err) } fmt.Fprintf(b, "// generated by %cg -asmhdr from package %s\n\n", Thearch.Thechar, localpkg.Name) - for l = asmlist; l != nil; l = l.Next { + var n *Node + var t *Type + for l := asmlist; l != nil; l = l.Next { n = l.N if isblanksym(n.Sym) { continue
diff --git a/src/cmd/internal/gc/fmt.go b/src/cmd/internal/gc/fmt.go index b155f78..ce73676 100644 --- a/src/cmd/internal/gc/fmt.go +++ b/src/cmd/internal/gc/fmt.go
@@ -88,9 +88,7 @@ // func setfmode(flags *int) int { - var fm int - - fm = fmtmode + fm := fmtmode if *flags&obj.FmtSign != 0 { fmtmode = FDbg } else if *flags&obj.FmtSharp != 0 { @@ -170,20 +168,21 @@ // Fmt "%O": Node opcodes func Oconv(o int, flag int) string { - var fp string - if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode != FDbg { if o >= 0 && o < len(goopnames) && goopnames[o] != "" { + var fp string fp += goopnames[o] return fp } } if o >= 0 && o < len(opnames) && opnames[o] != "" { + var fp string fp += opnames[o] return fp } + var fp string fp += fmt.Sprintf("O-%d", o) return fp } @@ -202,10 +201,7 @@ func Jconv(n *Node, flag int) string { var fp string - var s string - var c int - - c = flag & obj.FmtShort + c := flag & obj.FmtShort if c == 0 && n.Ullman != 0 { fp += fmt.Sprintf(" u(%d)", n.Ullman) @@ -228,7 +224,7 @@ } if n.Class != 0 { - s = "" + s := "" if n.Class&PHEAP != 0 { s = ",heap" } @@ -309,98 +305,111 @@ // Fmt "%V": Values func Vconv(v *Val, flag int) string { - var fp string - - var x int64 - switch v.Ctype { case CTINT: if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp { + var fp string fp += fmt.Sprintf("%v", Bconv(v.U.Xval, obj.FmtSharp)) return fp } + var fp string fp += fmt.Sprintf("%v", Bconv(v.U.Xval, 0)) return fp case CTRUNE: - x = Mpgetfix(v.U.Xval) + x := Mpgetfix(v.U.Xval) if ' ' <= x && x < 0x80 && x != '\\' && x != '\'' { + var fp string fp += fmt.Sprintf("'%c'", int(x)) return fp } if 0 <= x && x < 1<<16 { + var fp string fp += fmt.Sprintf("'\\u%04x'", uint(int(x))) return fp } if 0 <= x && x <= utf8.MaxRune { + var fp string fp += fmt.Sprintf("'\\U%08x'", uint64(x)) return fp } + var fp string fp += fmt.Sprintf("('\\x00' + %v)", Bconv(v.U.Xval, 0)) return fp case CTFLT: if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp { + var fp string fp += fmt.Sprintf("%v", Fconv(v.U.Fval, 0)) return fp } + var fp string fp += fmt.Sprintf("%v", Fconv(v.U.Fval, obj.FmtSharp)) return fp case CTCPLX: if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp { + var fp string fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, 0), Fconv(&v.U.Cval.Imag, 0)) return fp } if mpcmpfltc(&v.U.Cval.Real, 0) == 0 { + var fp string fp += fmt.Sprintf("%vi", Fconv(&v.U.Cval.Imag, obj.FmtSharp)) return fp } if mpcmpfltc(&v.U.Cval.Imag, 0) == 0 { + var fp string fp += fmt.Sprintf("%v", Fconv(&v.U.Cval.Real, obj.FmtSharp)) return fp } if mpcmpfltc(&v.U.Cval.Imag, 0) < 0 { + var fp string fp += fmt.Sprintf("(%v%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp)) return fp } + var fp string fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp)) return fp case CTSTR: + var fp string fp += fmt.Sprintf("\"%v\"", Zconv(v.U.Sval, 0)) return fp case CTBOOL: if v.U.Bval != 0 { + var fp string fp += "true" return fp } + var fp string fp += "false" return fp case CTNIL: + var fp string fp += "nil" return fp } + var fp string fp += fmt.Sprintf("<ctype=%d>", v.Ctype) return fp } // Fmt "%Z": escaped string literals func Zconv(sp *Strlit, flag int) string { - var fp string - var s string - var n int - if sp == nil { + var fp string fp += "<nil>" return fp } // NOTE: Keep in sync with ../ld/go.c:/^Zconv. - s = sp.S + s := sp.S + var n int + var fp string for i := 0; i < len(s); i += n { var r rune r, n = utf8.DecodeRuneInString(s[i:]) @@ -481,47 +490,49 @@ // Fmt "%E": etype func Econv(et int, flag int) string { - var fp string - if et >= 0 && et < len(etnames) && etnames[et] != "" { + var fp string fp += etnames[et] return fp } + var fp string fp += fmt.Sprintf("E-%d", et) return fp } // Fmt "%S": syms func symfmt(s *Sym, flag int) string { - var fp string - - var p string - if s.Pkg != nil && flag&obj.FmtShort == 0 /*untyped*/ { switch fmtmode { case FErr: // This is for the user if s.Pkg == localpkg { + var fp string fp += s.Name return fp } // If the name was used by multiple packages, display the full path, if s.Pkg.Name != "" && Pkglookup(s.Pkg.Name, nil).Npkg > 1 { + var fp string fp += fmt.Sprintf("\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name) return fp } + var fp string fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name) return fp case FDbg: + var fp string fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name) return fp case FTypeId: if flag&obj.FmtUnsigned != 0 /*untyped*/ { + var fp string fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name) return fp // dcommontype, typehash } + var fp string fp += fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name) return fp // (methodsym), typesym, weaksym @@ -530,6 +541,7 @@ Fatal("exporting synthetic symbol %s", s.Name) } if s.Pkg != builtinpkg { + var fp string fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name) return fp } @@ -539,21 +551,24 @@ if flag&obj.FmtByte != 0 /*untyped*/ { // FmtByte (hh) implies FmtShort (h) // skip leading "type." in method name - p = s.Name + p := s.Name if i := strings.LastIndex(s.Name, "."); i >= 0 { p = s.Name[i+1:] } // exportname needs to see the name without the prefix too. if (fmtmode == FExp && !exportname(p)) || fmtmode == FDbg { + var fp string fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), p) return fp } + var fp string fp += p return fp } + var fp string fp += s.Name return fp } @@ -583,12 +598,8 @@ } func typefmt(t *Type, flag int) string { - var fp string - - var t1 *Type - var s *Sym - if t == nil { + var fp string fp += "<T>" return fp } @@ -596,6 +607,7 @@ if t == bytetype || t == runetype { // in %-T mode collapse rune and byte with their originals. if fmtmode != FTypeId { + var fp string fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort)) return fp } @@ -603,6 +615,7 @@ } if t == errortype { + var fp string fp += "error" return fp } @@ -613,14 +626,17 @@ case FTypeId: if flag&obj.FmtShort != 0 /*untyped*/ { if t.Vargen != 0 { + var fp string fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, obj.FmtShort), t.Vargen) return fp } + var fp string fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort)) return fp } if flag&obj.FmtUnsigned != 0 /*untyped*/ { + var fp string fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtUnsigned)) return fp } @@ -629,15 +645,18 @@ // fallthrough case FExp: if t.Sym.Pkg == localpkg && t.Vargen != 0 { + var fp string fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, 0), t.Vargen) return fp } } + var fp string fp += fmt.Sprintf("%v", Sconv(t.Sym, 0)) return fp } + var fp string if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" { if fmtmode == FErr && (t == idealbool || t == idealstring) { fp += "untyped " @@ -696,7 +715,7 @@ case TINTER: fp += "interface {" - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if exportname(t1.Sym.Name) { if t1.Down != nil { fp += fmt.Sprintf(" %v%v;", Sconv(t1.Sym, obj.FmtShort), Tconv(t1.Type, obj.FmtShort)) @@ -769,7 +788,7 @@ if t.Funarg != 0 { fp += "(" if fmtmode == FTypeId || fmtmode == FErr { // no argument names on function signature, and no "noescape"/"nosplit" tags - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if t1.Down != nil { fp += fmt.Sprintf("%v, ", Tconv(t1, obj.FmtShort)) } else { @@ -777,7 +796,7 @@ } } } else { - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if t1.Down != nil { fp += fmt.Sprintf("%v, ", Tconv(t1, 0)) } else { @@ -789,7 +808,7 @@ fp += ")" } else { fp += "struct {" - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if t1.Down != nil { fp += fmt.Sprintf(" %v;", Tconv(t1, obj.FmtLong)) } else { @@ -803,7 +822,7 @@ case TFIELD: if flag&obj.FmtShort == 0 /*untyped*/ { - s = t.Sym + s := t.Sym // Take the name from the original, lest we substituted it with ~r%d or ~b%d. // ~r%d is a (formerly) unnamed result. @@ -896,23 +915,19 @@ func stmtfmt(n *Node) string { var f string - var complexinit bool - var simpleinit bool - var extrablock bool - // some statements allow for an init, but at most one, // but we may have an arbitrary number added, eg by typecheck // and inlining. If it doesn't fit the syntax, emit an enclosing // block starting with the init statements. // if we can just say "for" n->ninit; ... then do so - simpleinit = n.Ninit != nil && n.Ninit.Next == nil && n.Ninit.N.Ninit == nil && stmtwithinit(int(n.Op)) + simpleinit := n.Ninit != nil && n.Ninit.Next == nil && n.Ninit.N.Ninit == nil && stmtwithinit(int(n.Op)) // otherwise, print the inits as separate statements - complexinit = n.Ninit != nil && !simpleinit && (fmtmode != FErr) + complexinit := n.Ninit != nil && !simpleinit && (fmtmode != FErr) // but if it was for if/for/switch, put in an extra surrounding block to limit the scope - extrablock = complexinit && stmtwithinit(int(n.Op)) + extrablock := complexinit && stmtwithinit(int(n.Op)) if extrablock { f += "{" @@ -1208,50 +1223,51 @@ } func exprfmt(n *Node, prec int) string { - var f string - - var nprec int - var ptrlit bool - var l *NodeList - for n != nil && n.Implicit != 0 && (n.Op == OIND || n.Op == OADDR) { n = n.Left } if n == nil { + var f string f += "<N>" return f } - nprec = opprec[n.Op] + nprec := opprec[n.Op] if n.Op == OTYPE && n.Sym != nil { nprec = 8 } if prec > nprec { + var f string f += fmt.Sprintf("(%v)", Nconv(n, 0)) return f } switch n.Op { case OPAREN: + var f string f += fmt.Sprintf("(%v)", Nconv(n.Left, 0)) return f case ODDDARG: + var f string f += fmt.Sprintf("... argument") return f case OREGISTER: + var f string f += fmt.Sprintf("%v", Ctxt.Rconv(int(n.Val.U.Reg))) return f case OLITERAL: // this is a bit of a mess if fmtmode == FErr && n.Sym != nil { + var f string f += fmt.Sprintf("%v", Sconv(n.Sym, 0)) return f } if n.Val.Ctype == CTNIL && n.Orig != nil && n.Orig != n { + var f string f += exprfmt(n.Orig, prec) return f } @@ -1259,14 +1275,17 @@ // Need parens when type begins with what might // be misinterpreted as a unary operator: * or <-. if Isptr[n.Type.Etype] != 0 || (n.Type.Etype == TCHAN && n.Type.Chan == Crecv) { + var f string f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0)) return f } else { + var f string f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0)) return f } } + var f string f += fmt.Sprintf("%v", Vconv(&n.Val, 0)) return f @@ -1274,10 +1293,12 @@ // _ becomes ~b%d internally; print as _ for export case ONAME: if fmtmode == FExp && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' { + var f string f += fmt.Sprintf("_") return f } if fmtmode == FExp && n.Sym != nil && !isblank(n) && n.Vargen > 0 { + var f string f += fmt.Sprintf("%v·%d", Sconv(n.Sym, 0), n.Vargen) return f } @@ -1287,9 +1308,11 @@ // These nodes have the special property that they are names with a left OTYPE and a right ONAME. if fmtmode == FExp && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME { if Isptr[n.Left.Type.Etype] != 0 { + var f string f += fmt.Sprintf("(%v).%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte)) return f } else { + var f string f += fmt.Sprintf("%v.%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte)) return f } @@ -1299,44 +1322,54 @@ //fallthrough case OPACK, ONONAME: + var f string f += fmt.Sprintf("%v", Sconv(n.Sym, 0)) return f case OTYPE: if n.Type == nil && n.Sym != nil { + var f string f += fmt.Sprintf("%v", Sconv(n.Sym, 0)) return f } + var f string f += fmt.Sprintf("%v", Tconv(n.Type, 0)) return f case OTARRAY: if n.Left != nil { + var f string f += fmt.Sprintf("[]%v", Nconv(n.Left, 0)) return f } + var f string f += fmt.Sprintf("[]%v", Nconv(n.Right, 0)) return f // happens before typecheck case OTMAP: + var f string f += fmt.Sprintf("map[%v]%v", Nconv(n.Left, 0), Nconv(n.Right, 0)) return f case OTCHAN: switch n.Etype { case Crecv: + var f string f += fmt.Sprintf("<-chan %v", Nconv(n.Left, 0)) return f case Csend: + var f string f += fmt.Sprintf("chan<- %v", Nconv(n.Left, 0)) return f default: if n.Left != nil && n.Left.Op == OTCHAN && n.Left.Sym == nil && n.Left.Etype == Crecv { + var f string f += fmt.Sprintf("chan (%v)", Nconv(n.Left, 0)) return f } else { + var f string f += fmt.Sprintf("chan %v", Nconv(n.Left, 0)) return f } @@ -1344,71 +1377,85 @@ fallthrough case OTSTRUCT: + var f string f += fmt.Sprintf("<struct>") return f case OTINTER: + var f string f += fmt.Sprintf("<inter>") return f case OTFUNC: + var f string f += fmt.Sprintf("<func>") return f case OCLOSURE: if fmtmode == FErr { + var f string f += "func literal" return f } if n.Nbody != nil { + var f string f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Nbody, 0)) return f } + var f string f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Closure.Nbody, 0)) return f case OCOMPLIT: - ptrlit = n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype] != 0 + ptrlit := n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype] != 0 if fmtmode == FErr { if n.Right != nil && n.Right.Type != nil && n.Implicit == 0 { if ptrlit { + var f string f += fmt.Sprintf("&%v literal", Tconv(n.Right.Type.Type, 0)) return f } else { + var f string f += fmt.Sprintf("%v literal", Tconv(n.Right.Type, 0)) return f } } + var f string f += "composite literal" return f } if fmtmode == FExp && ptrlit { // typecheck has overwritten OIND by OTYPE with pointer type. + var f string f += fmt.Sprintf("(&%v{ %v })", Tconv(n.Right.Type.Type, 0), Hconv(n.List, obj.FmtComma)) return f } + var f string f += fmt.Sprintf("(%v{ %v })", Nconv(n.Right, 0), Hconv(n.List, obj.FmtComma)) return f case OPTRLIT: if fmtmode == FExp && n.Left.Implicit != 0 { + var f string f += fmt.Sprintf("%v", Nconv(n.Left, 0)) return f } + var f string f += fmt.Sprintf("&%v", Nconv(n.Left, 0)) return f case OSTRUCTLIT: if fmtmode == FExp { // requires special handling of field names + var f string if n.Implicit != 0 { f += "{" } else { f += fmt.Sprintf("(%v{", Tconv(n.Type, 0)) } - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { f += fmt.Sprintf(" %v:%v", Sconv(l.N.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(l.N.Right, 0)) if l.Next != nil { @@ -1432,13 +1479,16 @@ case OARRAYLIT, OMAPLIT: if fmtmode == FErr { + var f string f += fmt.Sprintf("%v literal", Tconv(n.Type, 0)) return f } if fmtmode == FExp && n.Implicit != 0 { + var f string f += fmt.Sprintf("{ %v }", Hconv(n.List, obj.FmtComma)) return f } + var f string f += fmt.Sprintf("(%v{ %v })", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma)) return f @@ -1446,22 +1496,27 @@ if n.Left != nil && n.Right != nil { if fmtmode == FExp && n.Left.Type != nil && n.Left.Type.Etype == TFIELD { // requires special handling of field names + var f string f += fmt.Sprintf("%v:%v", Sconv(n.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(n.Right, 0)) return f } else { + var f string f += fmt.Sprintf("%v:%v", Nconv(n.Left, 0), Nconv(n.Right, 0)) return f } } if n.Left == nil && n.Right != nil { + var f string f += fmt.Sprintf(":%v", Nconv(n.Right, 0)) return f } if n.Left != nil && n.Right == nil { + var f string f += fmt.Sprintf("%v:", Nconv(n.Left, 0)) return f } + var f string f += ":" return f @@ -1471,6 +1526,7 @@ ODOTINTER, ODOTMETH, OCALLPART: + var f string f += exprfmt(n.Left, nprec) if n.Right == nil || n.Right.Sym == nil { f += ".<nil>" @@ -1481,6 +1537,7 @@ case ODOTTYPE, ODOTTYPE2: + var f string f += exprfmt(n.Left, nprec) if n.Right != nil { f += fmt.Sprintf(".(%v)", Nconv(n.Right, 0)) @@ -1496,12 +1553,14 @@ OSLICEARR, OSLICE3, OSLICE3ARR: + var f string f += exprfmt(n.Left, nprec) f += fmt.Sprintf("[%v]", Nconv(n.Right, 0)) return f case OCOPY, OCOMPLEX: + var f string f += fmt.Sprintf("%v(%v, %v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0), Nconv(n.Right, 0)) return f @@ -1514,13 +1573,16 @@ OSTRARRAYRUNE, ORUNESTR: if n.Type == nil || n.Type.Sym == nil { + var f string f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0)) return f } if n.Left != nil { + var f string f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0)) return f } + var f string f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma)) return f @@ -1538,13 +1600,16 @@ OPRINT, OPRINTN: if n.Left != nil { + var f string f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0)) return f } if n.Isddd != 0 { + var f string f += fmt.Sprintf("%v(%v...)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma)) return f } + var f string f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma)) return f @@ -1552,6 +1617,7 @@ OCALLFUNC, OCALLINTER, OCALLMETH: + var f string f += exprfmt(n.Left, nprec) if n.Isddd != 0 { f += fmt.Sprintf("(%v...)", Hconv(n.List, obj.FmtComma)) @@ -1564,17 +1630,21 @@ OMAKECHAN, OMAKESLICE: if n.List != nil { // pre-typecheck + var f string f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma)) return f } if n.Right != nil { + var f string f += fmt.Sprintf("make(%v, %v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0), Nconv(n.Right, 0)) return f } if n.Left != nil { + var f string f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0)) return f } + var f string f += fmt.Sprintf("make(%v)", Tconv(n.Type, 0)) return f @@ -1586,6 +1656,7 @@ OIND, ONOT, ORECV: + var f string if n.Left.Op == n.Op { f += fmt.Sprintf("%v ", Oconv(int(n.Op), obj.FmtSharp)) } else { @@ -1615,6 +1686,7 @@ OSEND, OSUB, OXOR: + var f string f += exprfmt(n.Left, nprec) f += fmt.Sprintf(" %v ", Oconv(int(n.Op), obj.FmtSharp)) @@ -1622,7 +1694,8 @@ return f case OADDSTR: - for l = n.List; l != nil; l = l.Next { + var f string + for l := n.List; l != nil; l = l.Next { if l != n.List { f += fmt.Sprintf(" + ") } @@ -1633,22 +1706,20 @@ case OCMPSTR, OCMPIFACE: + var f string f += exprfmt(n.Left, nprec) f += fmt.Sprintf(" %v ", Oconv(int(n.Etype), obj.FmtSharp)) f += exprfmt(n.Right, nprec+1) return f } + var f string f += fmt.Sprintf("<node %v>", Oconv(int(n.Op), 0)) return f } func nodefmt(n *Node, flag int) string { - var f string - - var t *Type - - t = n.Type + t := n.Type // we almost always want the original, except in export mode for literals // this saves the importer some work, and avoids us having to redo some @@ -1659,9 +1730,11 @@ if flag&obj.FmtLong != 0 /*untyped*/ && t != nil { if t.Etype == TNIL { + var f string f += fmt.Sprintf("nil") return f } else { + var f string f += fmt.Sprintf("%v (type %v)", Nconv(n, 0), Tconv(t, 0)) return f } @@ -1673,6 +1746,7 @@ return stmtfmt(n) } + var f string f += exprfmt(n, 0) return f } @@ -1684,16 +1758,14 @@ } func nodedump(n *Node, flag int) string { - var fp string - - var recur bool - if n == nil { + var fp string return fp } - recur = flag&obj.FmtShort == 0 /*untyped*/ + recur := flag&obj.FmtShort == 0 /*untyped*/ + var fp string if recur { fp = indent(fp) if dumpdepth > 10 { @@ -1795,28 +1867,25 @@ // Fmt "%S": syms // Flags: "%hS" suppresses qualifying with package func Sconv(s *Sym, flag int) string { - var fp string - - var r int - var sm int - var sf int - if flag&obj.FmtLong != 0 /*untyped*/ { panic("linksymfmt") } if s == nil { + var fp string fp += "<S>" return fp } if s.Name == "_" { + var fp string fp += "_" return fp } - sf = flag - sm = setfmode(&flag) + sf := flag + sm := setfmode(&flag) + var r int _ = r str := symfmt(s, flag) flag = sf @@ -1829,25 +1898,21 @@ // 'h' omit 'func' and receiver from function types, short type names // 'u' package name, not prefix (FTypeId mode, sticky) func Tconv(t *Type, flag int) string { - var fp string - - var r int - var sm int - var sf int - if t == nil { + var fp string fp += "<T>" return fp } if t.Trecur > 4 { + var fp string fp += "<...>" return fp } t.Trecur++ - sf = flag - sm = setfmode(&flag) + sf := flag + sm := setfmode(&flag) if fmtmode == FTypeId && (sf&obj.FmtUnsigned != 0) { fmtpkgpfx++ @@ -1856,6 +1921,7 @@ flag |= obj.FmtUnsigned } + var r int _ = r str := typefmt(t, flag) @@ -1873,19 +1939,15 @@ // Flags: 'l' suffix with "(type %T)" where possible // '+h' in debug mode, don't recurse, no multiline output func Nconv(n *Node, flag int) string { - var fp string - - var r int - var sm int - var sf int - if n == nil { + var fp string fp += "<N>" return fp } - sf = flag - sm = setfmode(&flag) + sf := flag + sm := setfmode(&flag) + var r int _ = r var str string switch fmtmode { @@ -1910,28 +1972,24 @@ // Fmt '%H': NodeList. // Flags: all those of %N plus ',': separate with comma's instead of semicolons. func Hconv(l *NodeList, flag int) string { - var fp string - - var r int - var sm int - var sf int - var sep string - if l == nil && fmtmode == FDbg { + var fp string fp += "<nil>" return fp } - sf = flag - sm = setfmode(&flag) + sf := flag + sm := setfmode(&flag) + var r int _ = r - sep = "; " + sep := "; " if fmtmode == FDbg { sep = "\n" } else if flag&obj.FmtComma != 0 /*untyped*/ { sep = ", " } + var fp string for ; l != nil; l = l.Next { fp += fmt.Sprintf("%v", Nconv(l.N, 0)) if l.Next != nil {
diff --git a/src/cmd/internal/gc/gen.go b/src/cmd/internal/gc/gen.go index 9d41b6f..079158a 100644 --- a/src/cmd/internal/gc/gen.go +++ b/src/cmd/internal/gc/gen.go
@@ -18,9 +18,7 @@ var lastlabel *Label func Sysfunc(name string) *Node { - var n *Node - - n = newname(Pkglookup(name, Runtimepkg)) + n := newname(Pkglookup(name, Runtimepkg)) n.Class = PFUNC return n } @@ -31,9 +29,6 @@ * as needing to move to the heap. */ func addrescapes(n *Node) { - var buf string - var oldfn *Node - switch n.Op { // probably a type error already. // dump("addrescapes", n); @@ -84,11 +79,11 @@ n.Xoffset = 0 // create stack variable to hold pointer to heap - oldfn = Curfn + oldfn := Curfn Curfn = n.Curfn n.Heapaddr = temp(Ptrto(n.Type)) - buf = fmt.Sprintf("&%v", Sconv(n.Sym, 0)) + buf := fmt.Sprintf("&%v", Sconv(n.Sym, 0)) n.Heapaddr.Sym = Lookup(buf) n.Heapaddr.Orig.Sym = n.Heapaddr.Sym n.Esc = EscHeap @@ -116,9 +111,7 @@ } func clearlabels() { - var l *Label - - for l = labellist; l != nil; l = l.Link { + for l := labellist; l != nil; l = l.Link { l.Sym.Label = nil } @@ -127,11 +120,8 @@ } func newlab(n *Node) *Label { - var s *Sym - var lab *Label - - s = n.Left.Sym - lab = s.Label + s := n.Left.Sym + lab := s.Label if lab == nil { lab = new(Label) if lastlabel == nil { @@ -158,41 +148,33 @@ } func checkgoto(from *Node, to *Node) { - var nf int - var nt int - var block *Sym - var dcl *Sym - var fs *Sym - var ts *Sym - var lno int - if from.Sym == to.Sym { return } - nf = 0 - for fs = from.Sym; fs != nil; fs = fs.Link { + nf := 0 + for fs := from.Sym; fs != nil; fs = fs.Link { nf++ } - nt = 0 - for fs = to.Sym; fs != nil; fs = fs.Link { + nt := 0 + for fs := to.Sym; fs != nil; fs = fs.Link { nt++ } - fs = from.Sym + fs := from.Sym for ; nf > nt; nf-- { fs = fs.Link } if fs != to.Sym { - lno = int(lineno) + lno := int(lineno) setlineno(from) // decide what to complain about. // prefer to complain about 'into block' over declarations, // so scan backward to find most recent block or else dcl. - block = nil + block := (*Sym)(nil) - dcl = nil - ts = to.Sym + dcl := (*Sym)(nil) + ts := to.Sym for ; nt > nf; nt-- { if ts.Pkg == nil { block = ts @@ -222,10 +204,8 @@ } func stmtlabel(n *Node) *Label { - var lab *Label - if n.Sym != nil { - lab = n.Sym.Label + lab := n.Sym.Label if lab != nil { if lab.Def != nil { if lab.Def.Defn == n { @@ -295,8 +275,6 @@ * generate discard of value */ func cgen_discard(nr *Node) { - var tmp Node - if nr == nil { return } @@ -342,6 +320,7 @@ // special enough to just evaluate default: + var tmp Node Tempname(&tmp, nr.Type) Cgen_as(&tmp, nr) @@ -353,10 +332,7 @@ * clearslim generates code to zero a slim node. */ func Clearslim(n *Node) { - var z Node - var zero Mpflt - - z = Node{} + z := Node{} z.Op = OLITERAL z.Type = n.Type z.Addable = 1 @@ -370,6 +346,7 @@ case TFLOAT32, TFLOAT64: + var zero Mpflt Mpmovecflt(&zero, 0.0) z.Val.Ctype = CTFLT z.Val.U.Fval = &zero @@ -410,20 +387,17 @@ * n->right is data */ func Cgen_eface(n *Node, res *Node) { - var dst Node /* * the right node of an eface may contain function calls that uses res as an argument, * so it's important that it is done first */ - var tmp *Node - - tmp = temp(Types[Tptr]) + tmp := temp(Types[Tptr]) Thearch.Cgen(n.Right, tmp) Gvardef(res) - dst = *res + dst := *res dst.Type = Types[Tptr] dst.Xoffset += int64(Widthptr) Thearch.Cgen(tmp, &dst) @@ -442,23 +416,9 @@ * called for OSLICE, OSLICE3, OSLICEARR, OSLICE3ARR, OSLICESTR. */ func Cgen_slice(n *Node, res *Node) { - var src Node - var dst Node - var cap *Node - var len *Node - var offs *Node - var add *Node - var base *Node - var tmpcap *Node - var tmplen *Node - var cmp *Node - var con Node - var p1 *obj.Prog - var p2 *obj.Prog - - cap = n.List.N - len = n.List.Next.N - offs = nil + cap := n.List.N + len := n.List.Next.N + offs := (*Node)(nil) if n.List.Next.Next != nil { offs = n.List.Next.Next.N } @@ -470,15 +430,17 @@ // might cause preemption or garbage collection. // this makes the whole slice update atomic as far as the // garbage collector can see. - base = temp(Types[TUINTPTR]) + base := temp(Types[TUINTPTR]) - tmplen = temp(Types[TINT]) + tmplen := temp(Types[TINT]) + var tmpcap *Node if n.Op != OSLICESTR { tmpcap = temp(Types[TINT]) } else { tmpcap = tmplen } + var src Node if isnil(n.Left) { Tempname(&src, n.Left.Type) Thearch.Cgen(n.Left, &src) @@ -519,16 +481,17 @@ // In essence we are replacing x[i:j:k] where i == j == k // or x[i:j] where i == j == cap(x) with x[0:0:0]. if offs != nil { - p1 = gjmp(nil) - p2 = gjmp(nil) + p1 := gjmp(nil) + p2 := gjmp(nil) Patch(p1, Pc) + var con Node Nodconst(&con, tmpcap.Type, 0) - cmp = Nod(OEQ, tmpcap, &con) + cmp := Nod(OEQ, tmpcap, &con) typecheck(&cmp, Erv) Thearch.Bgen(cmp, true, -1, p2) - add = Nod(OADD, base, offs) + add := Nod(OADD, base, offs) typecheck(&add, Erv) Thearch.Cgen(add, base) @@ -536,7 +499,7 @@ } // dst.array = src.array [ + lo *width ] - dst = *res + dst := *res dst.Xoffset += int64(Array_array) dst.Type = Types[Tptr] @@ -616,9 +579,6 @@ * make a new off the books */ func Tempname(nn *Node, t *Type) { - var n *Node - var s *Sym - if Curfn == nil { Fatal("no curfn for tempname") } @@ -633,8 +593,8 @@ namebuf = fmt.Sprintf("autotmp_%.4d", statuniqgen) statuniqgen++ - s = Lookup(namebuf) - n = Nod(ONAME, nil, nil) + s := Lookup(namebuf) + n := Nod(ONAME, nil, nil) n.Sym = s s.Def = n n.Type = t @@ -651,26 +611,16 @@ } func temp(t *Type) *Node { - var n *Node - - n = Nod(OXXX, nil, nil) + n := Nod(OXXX, nil, nil) Tempname(n, t) n.Sym.Def.Used = 1 return n.Orig } func gen(n *Node) { - var lno int32 - var scontin *obj.Prog - var sbreak *obj.Prog - var p1 *obj.Prog - var p2 *obj.Prog - var p3 *obj.Prog - var lab *Label - //dump("gen", n); - lno = setlineno(n) + lno := setlineno(n) wasregalloc := Thearch.Anyregalloc() @@ -708,10 +658,11 @@ break } - lab = newlab(n) + lab := newlab(n) // if there are pending gotos, resolve them all to the current pc. - for p1 = lab.Gotopc; p1 != nil; p1 = p2 { + var p2 *obj.Prog + for p1 := lab.Gotopc; p1 != nil; p1 = p2 { p2 = unpatch(p1) Patch(p1, Pc) } @@ -739,7 +690,7 @@ // to the same label. we'll unwind it when we learn the pc // of the label in the OLABEL case above.) case OGOTO: - lab = newlab(n) + lab := newlab(n) if lab.Labelpc != nil { gjmp(lab.Labelpc) @@ -749,7 +700,7 @@ case OBREAK: if n.Left != nil { - lab = n.Left.Sym.Label + lab := n.Left.Sym.Label if lab == nil { Yyerror("break label not defined: %v", Sconv(n.Left.Sym, 0)) break @@ -774,7 +725,7 @@ case OCONTINUE: if n.Left != nil { - lab = n.Left.Sym.Label + lab := n.Left.Sym.Label if lab == nil { Yyerror("continue label not defined: %v", Sconv(n.Left.Sym, 0)) break @@ -798,14 +749,14 @@ gjmp(continpc) case OFOR: - sbreak = breakpc - p1 = gjmp(nil) // goto test + sbreak := breakpc + p1 := gjmp(nil) // goto test breakpc = gjmp(nil) // break: goto done - scontin = continpc + scontin := continpc continpc = Pc // define break and continue labels - lab = stmtlabel(n) + lab := stmtlabel(n) if lab != nil { lab.Breakpc = breakpc lab.Continpc = continpc @@ -825,23 +776,23 @@ } case OIF: - p1 = gjmp(nil) // goto test - p2 = gjmp(nil) // p2: goto else + p1 := gjmp(nil) // goto test + p2 := gjmp(nil) // p2: goto else Patch(p1, Pc) // test: Thearch.Bgen(n.Ntest, false, int(-n.Likely), p2) // if(!test) goto p2 Genlist(n.Nbody) // then - p3 = gjmp(nil) // goto done + p3 := gjmp(nil) // goto done Patch(p2, Pc) // else: Genlist(n.Nelse) // else Patch(p3, Pc) // done: case OSWITCH: - sbreak = breakpc - p1 = gjmp(nil) // goto test + sbreak := breakpc + p1 := gjmp(nil) // goto test breakpc = gjmp(nil) // break: goto done // define break label - lab = stmtlabel(n) + lab := stmtlabel(n) if lab != nil { lab.Breakpc = breakpc } @@ -855,12 +806,12 @@ } case OSELECT: - sbreak = breakpc - p1 = gjmp(nil) // goto test + sbreak := breakpc + p1 := gjmp(nil) // goto test breakpc = gjmp(nil) // break: goto done // define break label - lab = stmtlabel(n) + lab := stmtlabel(n) if lab != nil { lab.Breakpc = breakpc } @@ -918,8 +869,6 @@ } func Cgen_as(nl *Node, nr *Node) { - var tl *Type - if Debug['g'] != 0 { Dump("cgen_as", nl) Dump("cgen_as = ", nr) @@ -940,7 +889,7 @@ return } - tl = nl.Type + tl := nl.Type if tl == nil { return } @@ -956,7 +905,7 @@ return } - tl = nl.Type + tl := nl.Type if tl == nil { return } @@ -965,19 +914,16 @@ } func Cgen_callmeth(n *Node, proc int) { - var n2 Node - var l *Node - // generate a rewrite in n2 for the method call // (p.f)(...) goes to (f)(p,...) - l = n.Left + l := n.Left if l.Op != ODOTMETH { Fatal("cgen_callmeth: not dotmethod: %v") } - n2 = *n + n2 := *n n2.Op = OCALLFUNC n2.Left = l.Right n2.Left.Type = l.Type @@ -989,10 +935,9 @@ } func checklabels() { - var lab *Label var l *NodeList - for lab = labellist; lab != nil; lab = lab.Link { + for lab := labellist; lab != nil; lab = lab.Link { if lab.Def == nil { for l = lab.Use; l != nil; l = l.Next { yyerrorl(int(l.N.Lineno), "label %v not defined", Sconv(lab.Sym, 0))
diff --git a/src/cmd/internal/gc/gsubr.go b/src/cmd/internal/gc/gsubr.go index 6fd6057..ad5e494 100644 --- a/src/cmd/internal/gc/gsubr.go +++ b/src/cmd/internal/gc/gsubr.go
@@ -80,9 +80,7 @@ * gsubr.c */ func Gbranch(as int, t *Type, likely int) *obj.Prog { - var p *obj.Prog - - p = Prog(as) + p := Prog(as) p.To.Type = obj.TYPE_BRANCH p.To.U.Branch = nil if as != obj.AJMP && likely != 0 && Thearch.Thechar != '9' { @@ -170,9 +168,7 @@ } func fixautoused(p *obj.Prog) { - var lp **obj.Prog - - for lp = &p; ; { + for lp := &p; ; { p = *lp if p == nil { break @@ -205,9 +201,7 @@ } func ggloblnod(nam *Node) { - var p *obj.Prog - - p = Thearch.Gins(obj.AGLOBL, nam, nil) + p := Thearch.Gins(obj.AGLOBL, nam, nil) p.Lineno = nam.Lineno p.From.Sym.Gotype = Linksym(ngotype(nam)) p.To.Sym = nil @@ -222,9 +216,7 @@ } func ggloblsym(s *Sym, width int32, flags int8) { - var p *obj.Prog - - p = Thearch.Gins(obj.AGLOBL, nil, nil) + p := Thearch.Gins(obj.AGLOBL, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Sym = Linksym(s) @@ -234,9 +226,7 @@ } func gjmp(to *obj.Prog) *obj.Prog { - var p *obj.Prog - - p = Gbranch(obj.AJMP, nil, 0) + p := Gbranch(obj.AJMP, nil, 0) if to != nil { Patch(p, to) } @@ -244,9 +234,7 @@ } func gtrack(s *Sym) { - var p *obj.Prog - - p = Thearch.Gins(obj.AUSEFIELD, nil, nil) + p := Thearch.Gins(obj.AUSEFIELD, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Sym = Linksym(s) @@ -287,8 +275,6 @@ } func Naddr(n *Node, a *obj.Addr, canemitcode int) { - var s *Sym - *a = obj.Addr{} if n == nil { return @@ -361,7 +347,7 @@ a.Etype = Simtype[n.Type.Etype] } a.Offset = n.Xoffset - s = n.Sym + s := n.Sym a.Node = n.Orig //if(a->node >= (Node*)&n) @@ -502,9 +488,7 @@ } func newplist() *obj.Plist { - var pl *obj.Plist - - pl = obj.Linknewplist(Ctxt) + pl := obj.Linknewplist(Ctxt) Pc = Ctxt.NewProg() Clearp(Pc) @@ -515,16 +499,14 @@ func nodarg(t *Type, fp int) *Node { var n *Node - var l *NodeList - var first *Type - var savet Iter // entire argument struct, not just one arg if t.Etype == TSTRUCT && t.Funarg != 0 { n = Nod(ONAME, nil, nil) n.Sym = Lookup(".args") n.Type = t - first = Structfirst(&savet, &t) + var savet Iter + first := Structfirst(&savet, &t) if first == nil { Fatal("nodarg: bad struct") } @@ -541,7 +523,8 @@ } if fp == 1 { - for l = Curfn.Dcl; l != nil; l = l.Next { + var n *Node + for l := Curfn.Dcl; l != nil; l = l.Next { n = l.N if (n.Class == PPARAM || n.Class == PPARAMOUT) && !isblanksym(t.Sym) && n.Sym == t.Sym { return n @@ -604,12 +587,10 @@ } func unpatch(p *obj.Prog) *obj.Prog { - var q *obj.Prog - if p.To.Type != obj.TYPE_BRANCH { Fatal("unpatch: not a branch") } - q = p.To.U.Branch + q := p.To.U.Branch p.To.U.Branch = nil p.To.Offset = 0 return q
diff --git a/src/cmd/internal/gc/init.go b/src/cmd/internal/gc/init.go index 9202ac5..a7d4fbd 100644 --- a/src/cmd/internal/gc/init.go +++ b/src/cmd/internal/gc/init.go
@@ -54,12 +54,8 @@ * } */ func anyinit(n *NodeList) bool { - var h uint32 - var s *Sym - var l *NodeList - // are there any interesting init statements - for l = n; l != nil; l = l.Next { + for l := n; l != nil; l = l.Next { switch l.N.Op { case ODCLFUNC, ODCLCONST, @@ -85,14 +81,14 @@ } // is there an explicit init function - s = Lookup("init.1") + s := Lookup("init.1") if s.Def != nil { return true } // are there any imported init functions - for h = 0; h < NHASH; h++ { + for h := uint32(0); h < NHASH; h++ { for s = hash[h]; s != nil; s = s.Link { if s.Name[0] != 'i' || s.Name != "init" { continue @@ -109,16 +105,6 @@ } func fninit(n *NodeList) { - var i int - var gatevar *Node - var a *Node - var b *Node - var fn *Node - var r *NodeList - var h uint32 - var s *Sym - var initsym *Sym - if Debug['A'] != 0 { // sys.go or unsafe.go during compiler build return @@ -129,12 +115,12 @@ return } - r = nil + r := (*NodeList)(nil) // (1) namebuf = fmt.Sprintf("initdone·") - gatevar = newname(Lookup(namebuf)) + gatevar := newname(Lookup(namebuf)) addvar(gatevar, Types[TUINT8], PEXTERN) // (2) @@ -142,8 +128,8 @@ namebuf = fmt.Sprintf("init") - fn = Nod(ODCLFUNC, nil, nil) - initsym = Lookup(namebuf) + fn := Nod(ODCLFUNC, nil, nil) + initsym := Lookup(namebuf) fn.Nname = newname(initsym) fn.Nname.Defn = fn fn.Nname.Ntype = Nod(OTFUNC, nil, nil) @@ -151,13 +137,13 @@ funchdr(fn) // (3) - a = Nod(OIF, nil, nil) + a := Nod(OIF, nil, nil) a.Ntest = Nod(ONE, gatevar, Nodintconst(0)) r = list(r, a) // (4) - b = Nod(OIF, nil, nil) + b := Nod(OIF, nil, nil) b.Ntest = Nod(OEQ, gatevar, Nodintconst(2)) b.Nbody = list1(Nod(ORETURN, nil, nil)) @@ -175,7 +161,8 @@ r = list(r, a) // (7) - for h = 0; h < NHASH; h++ { + var s *Sym + for h := uint32(0); h < NHASH; h++ { for s = hash[h]; s != nil; s = s.Link { if s.Name[0] != 'i' || s.Name != "init" { continue @@ -199,7 +186,7 @@ // (9) // could check that it is fn of no args/returns - for i = 1; ; i++ { + for i := 1; ; i++ { namebuf = fmt.Sprintf("init.%d", i) s = Lookup(namebuf) if s.Def == nil {
diff --git a/src/cmd/internal/gc/inl.go b/src/cmd/internal/gc/inl.go index 73d6481..8b088a7 100644 --- a/src/cmd/internal/gc/inl.go +++ b/src/cmd/internal/gc/inl.go
@@ -47,11 +47,9 @@ // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods // the ->sym can be re-used in the local package, so peel it off the receiver's type. func fnpkg(fn *Node) *Pkg { - var rcvr *Type - if fn.Type.Thistuple != 0 { // method - rcvr = getthisx(fn.Type).Type.Type + rcvr := getthisx(fn.Type).Type.Type if Isptr[rcvr.Etype] != 0 { rcvr = rcvr.Type @@ -69,18 +67,13 @@ // Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck // because they're a copy of an already checked body. func typecheckinl(fn *Node) { - var savefn *Node - var pkg *Pkg - var save_safemode int - var lno int - - lno = int(setlineno(fn)) + lno := int(setlineno(fn)) // typecheckinl is only for imported functions; // their bodies may refer to unsafe as long as the package // was marked safe during import (which was checked then). // the ->inl of a local function has been typechecked before caninl copied it. - pkg = fnpkg(fn) + pkg := fnpkg(fn) if pkg == localpkg || pkg == nil { return // typecheckinl on local function @@ -90,10 +83,10 @@ fmt.Printf("typecheck import [%v] %v { %v }\n", Sconv(fn.Sym, 0), Nconv(fn, obj.FmtLong), Hconv(fn.Inl, obj.FmtSharp)) } - save_safemode = safemode + save_safemode := safemode safemode = 0 - savefn = Curfn + savefn := Curfn Curfn = fn typechecklist(fn.Inl, Etop) Curfn = savefn @@ -107,10 +100,6 @@ // If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy. // fn and ->nbody will already have been typechecked. func caninl(fn *Node) { - var savefn *Node - var t *Type - var budget int - if fn.Op != ODCLFUNC { Fatal("caninl %v", Nconv(fn, 0)) } @@ -129,19 +118,19 @@ // can't handle ... args yet if Debug['l'] < 3 { - for t = fn.Type.Type.Down.Down.Type; t != nil; t = t.Down { + for t := fn.Type.Type.Down.Down.Type; t != nil; t = t.Down { if t.Isddd != 0 { return } } } - budget = 40 // allowed hairyness + budget := 40 // allowed hairyness if ishairylist(fn.Nbody, &budget) { return } - savefn = Curfn + savefn := Curfn Curfn = fn fn.Nname.Inl = fn.Nbody @@ -211,9 +200,7 @@ // Any name-like node of non-local class is marked for re-export by adding it to // the exportlist. func inlcopylist(ll *NodeList) *NodeList { - var l *NodeList - - l = nil + l := (*NodeList)(nil) for ; ll != nil; ll = ll.Next { l = list(l, inlcopy(ll.N)) } @@ -221,8 +208,6 @@ } func inlcopy(n *Node) *Node { - var m *Node - if n == nil { return nil } @@ -234,7 +219,7 @@ return n } - m = Nod(OXXX, nil, nil) + m := Nod(OXXX, nil, nil) *m = *n m.Inl = nil m.Left = inlcopy(n.Left) @@ -253,9 +238,7 @@ // Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any // calls made to inlineable functions. This is the external entry point. func inlcalls(fn *Node) { - var savefn *Node - - savefn = Curfn + savefn := Curfn Curfn = fn inlnode(&fn) if fn != Curfn { @@ -277,10 +260,8 @@ // Turn an OINLCALL into a single valued expression. func inlconv2expr(np **Node) { - var n *Node - var r *Node - n = *np - r = n.Rlist.N + n := *np + r := n.Rlist.N addinit(&r, concat(n.Ninit, n.Nbody)) *np = r } @@ -291,13 +272,11 @@ // order will be preserved Used in return, oas2func and call // statements. func inlconv2list(n *Node) *NodeList { - var l *NodeList - if n.Op != OINLCALL || n.Rlist == nil { Fatal("inlconv2list %v\n", Nconv(n, obj.FmtSign)) } - l = n.Rlist + l := n.Rlist addinit(&l.N, concat(n.Ninit, n.Nbody)) return l } @@ -320,15 +299,11 @@ // but then you may as well do it here. so this is cleaner and // shorter and less complicated. func inlnode(np **Node) { - var n *Node - var l *NodeList - var lno int - if *np == nil { return } - n = *np + n := *np switch n.Op { // inhibit inlining of their argument @@ -347,10 +322,10 @@ return } - lno = int(setlineno(n)) + lno := int(setlineno(n)) inlnodelist(n.Ninit) - for l = n.Ninit; l != nil; l = l.Next { + for l := n.Ninit; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2stmt(l.N) } @@ -369,7 +344,7 @@ inlnodelist(n.List) switch n.Op { case OBLOCK: - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2stmt(l.N) } @@ -391,7 +366,7 @@ // fallthrough default: - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2expr(&l.N) } @@ -412,7 +387,7 @@ // fallthrough default: - for l = n.Rlist; l != nil; l = l.Next { + for l := n.Rlist; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2expr(&l.N) } @@ -430,14 +405,14 @@ } inlnodelist(n.Nbody) - for l = n.Nbody; l != nil; l = l.Next { + for l := n.Nbody; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2stmt(l.N) } } inlnodelist(n.Nelse) - for l = n.Nelse; l != nil; l = l.Next { + for l := n.Nelse; l != nil; l = l.Next { if l.N.Op == OINLCALL { inlconv2stmt(l.N) } @@ -488,14 +463,11 @@ } func mkinlcall(np **Node, fn *Node, isddd int) { - var save_safemode int - var pkg *Pkg - - save_safemode = safemode + save_safemode := safemode // imported functions may refer to unsafe as long as the // package was marked safe during import (already checked). - pkg = fnpkg(fn) + pkg := fnpkg(fn) if pkg != localpkg && pkg != nil { safemode = 0 @@ -523,26 +495,6 @@ // inlined function body and list, rlist contain the input, output // parameters. func mkinlcall1(np **Node, fn *Node, isddd int) { - var i int - var chkargcount bool - var n *Node - var call *Node - var saveinlfn *Node - var as *Node - var m *Node - var dcl *NodeList - var ll *NodeList - var ninit *NodeList - var body *NodeList - var t *Type - var variadic bool - var varargcount int - var multiret int - var vararg *Node - var varargs *NodeList - var varargtype *Type - var vararrtype *Type - // For variadic fn. if fn.Inl == nil { return @@ -556,7 +508,7 @@ typecheckinl(fn) } - n = *np + n := *np // Bingo, we have a function node, and it has an inlineable body if Debug['m'] > 1 { @@ -569,13 +521,14 @@ fmt.Printf("%v: Before inlining: %v\n", n.Line(), Nconv(n, obj.FmtSign)) } - saveinlfn = inlfn + saveinlfn := inlfn inlfn = fn - ninit = n.Ninit + ninit := n.Ninit //dumplist("ninit pre", ninit); + var dcl *NodeList if fn.Defn != nil { // local function dcl = fn.Inldcl // imported function } else { @@ -583,10 +536,10 @@ } inlretvars = nil - i = 0 + i := 0 // Make temp names to use instead of the originals - for ll = dcl; ll != nil; ll = ll.Next { + for ll := dcl; ll != nil; ll = ll.Next { if ll.N.Class == PPARAMOUT { // return values handled below. continue } @@ -603,7 +556,8 @@ } // temporaries for return values. - for t = getoutargx(fn.Type).Type; t != nil; t = t.Down { + var m *Node + for t := getoutargx(fn.Type).Type; t != nil; t = t.Down { if t != nil && t.Nname != nil && !isblank(t.Nname) { m = inlvar(t.Nname) typecheck(&m, Erv) @@ -619,9 +573,10 @@ } // assign receiver. + var as *Node if fn.Type.Thistuple != 0 && n.Left.Op == ODOTMETH { // method call with a receiver. - t = getthisx(fn.Type).Type + t := getthisx(fn.Type).Type if t != nil && t.Nname != nil && !isblank(t.Nname) && t.Nname.Inlvar == nil { Fatal("missing inlvar for %v\n", Nconv(t.Nname, 0)) @@ -640,11 +595,11 @@ } // check if inlined function is variadic. - variadic = false + variadic := false - varargtype = nil - varargcount = 0 - for t = fn.Type.Type.Down.Down.Type; t != nil; t = t.Down { + varargtype := (*Type)(nil) + varargcount := 0 + for t := fn.Type.Type.Down.Down.Type; t != nil; t = t.Down { if t.Isddd != 0 { variadic = true varargtype = t.Type @@ -657,7 +612,7 @@ } // check if argument is actually a returned tuple from call. - multiret = 0 + multiret := 0 if n.List != nil && n.List.Next == nil { switch n.List.N.Op { @@ -683,7 +638,7 @@ as = Nod(OAS2, nil, nil) as.Rlist = n.List - ll = n.List + ll := n.List // TODO: if len(nlist) == 1 but multiple args, check that n->list->n is a call? if fn.Type.Thistuple != 0 && n.Left.Op != ODOTMETH { @@ -693,7 +648,7 @@ } // append receiver inlvar to LHS. - t = getthisx(fn.Type).Type + t := getthisx(fn.Type).Type if t != nil && t.Nname != nil && !isblank(t.Nname) && t.Nname.Inlvar == nil { Fatal("missing inlvar for %v\n", Nconv(t.Nname, 0)) @@ -706,13 +661,14 @@ } // append ordinary arguments to LHS. - chkargcount = n.List != nil && n.List.Next != nil + chkargcount := n.List != nil && n.List.Next != nil - vararg = nil // the slice argument to a variadic call - varargs = nil // the list of LHS names to put in vararg. + vararg := (*Node)(nil) // the slice argument to a variadic call + varargs := (*NodeList)(nil) // the list of LHS names to put in vararg. if !chkargcount { // 0 or 1 expression on RHS. - for t = getinargx(fn.Type).Type; t != nil; t = t.Down { + var i int + for t := getinargx(fn.Type).Type; t != nil; t = t.Down { if variadic && t.Isddd != 0 { vararg = tinlvar(t) for i = 0; i < varargcount && ll != nil; i++ { @@ -728,6 +684,7 @@ } } else { // match arguments except final variadic (unless the call is dotted itself) + var t *Type for t = getinargx(fn.Type).Type; t != nil; { if ll == nil { break @@ -743,6 +700,7 @@ // match varargcount arguments with variadic parameters. if variadic && t != nil && t.Isddd != 0 { vararg = tinlvar(t) + var i int for i = 0; i < varargcount && ll != nil; i++ { m = argvar(varargtype, i) varargs = list(varargs, m) @@ -772,7 +730,7 @@ as.Right = nodnil() as.Right.Type = varargtype } else { - vararrtype = typ(TARRAY) + vararrtype := typ(TARRAY) vararrtype.Type = varargtype.Type vararrtype.Bound = int64(varargcount) @@ -786,7 +744,7 @@ } // zero the outparams - for ll = inlretvars; ll != nil; ll = ll.Next { + for ll := inlretvars; ll != nil; ll = ll.Next { as = Nod(OAS, ll.N, nil) typecheck(&as, Etop) ninit = list(ninit, as) @@ -794,7 +752,7 @@ inlretlabel = newlabel_inl() inlgen++ - body = inlsubstlist(fn.Inl) + body := inlsubstlist(fn.Inl) body = list(body, Nod(OGOTO, inlretlabel, nil)) // avoid 'not used' when function doesnt have return body = list(body, Nod(OLABEL, inlretlabel, nil)) @@ -803,7 +761,7 @@ //dumplist("ninit post", ninit); - call = Nod(OINLCALL, nil, nil) + call := Nod(OINLCALL, nil, nil) call.Ninit = ninit call.Nbody = body @@ -824,10 +782,10 @@ // either supporting exporting statemetns with complex ninits // or saving inl and making inlinl if Debug['l'] >= 5 { - body = fn.Inl + body := fn.Inl fn.Inl = nil // prevent infinite recursion inlnodelist(call.Nbody) - for ll = call.Nbody; ll != nil; ll = ll.Next { + for ll := call.Nbody; ll != nil; ll = ll.Next { if ll.N.Op == OINLCALL { inlconv2stmt(ll.N) } @@ -844,13 +802,11 @@ // PAUTO's in the calling functions, and link them off of the // PPARAM's, PAUTOS and PPARAMOUTs of the called function. func inlvar(var_ *Node) *Node { - var n *Node - if Debug['m'] > 3 { fmt.Printf("inlvar %v\n", Nconv(var_, obj.FmtSign)) } - n = newname(var_.Sym) + n := newname(var_.Sym) n.Type = var_.Type n.Class = PAUTO n.Used = 1 @@ -872,10 +828,8 @@ // Synthesize a variable to store the inlined function's results in. func retvar(t *Type, i int) *Node { - var n *Node - namebuf = fmt.Sprintf("~r%d", i) - n = newname(Lookup(namebuf)) + n := newname(Lookup(namebuf)) n.Type = t.Type n.Class = PAUTO n.Used = 1 @@ -887,10 +841,8 @@ // Synthesize a variable to store the inlined function's arguments // when they come from a multiple return call. func argvar(t *Type, i int) *Node { - var n *Node - namebuf = fmt.Sprintf("~arg%d", i) - n = newname(Lookup(namebuf)) + n := newname(Lookup(namebuf)) n.Type = t.Type n.Class = PAUTO n.Used = 1 @@ -902,11 +854,9 @@ var newlabel_inl_label int func newlabel_inl() *Node { - var n *Node - newlabel_inl_label++ namebuf = fmt.Sprintf(".inlret%.6d", newlabel_inl_label) - n = newname(Lookup(namebuf)) + n := newname(Lookup(namebuf)) n.Etype = 1 // flag 'safe' for escape analysis (no backjumps) return n } @@ -916,9 +866,7 @@ // to input/output parameters with ones to the tmpnames, and // substituting returns with assignments to the output. func inlsubstlist(ll *NodeList) *NodeList { - var l *NodeList - - l = nil + l := (*NodeList)(nil) for ; ll != nil; ll = ll.Next { l = list(l, inlsubst(ll.N)) } @@ -926,11 +874,6 @@ } func inlsubst(n *Node) *Node { - var p string - var m *Node - var as *Node - var ll *NodeList - if n == nil { return nil } @@ -957,15 +900,15 @@ // dump("Return before substitution", n); case ORETURN: - m = Nod(OGOTO, inlretlabel, nil) + m := Nod(OGOTO, inlretlabel, nil) m.Ninit = inlsubstlist(n.Ninit) if inlretvars != nil && n.List != nil { - as = Nod(OAS2, nil, nil) + as := Nod(OAS2, nil, nil) // shallow copy or OINLCALL->rlist will be the same list, and later walk and typecheck may clobber that. - for ll = inlretvars; ll != nil; ll = ll.Next { + for ll := inlretvars; ll != nil; ll = ll.Next { as.List = list(as.List, ll.N) } as.Rlist = inlsubstlist(n.List) @@ -981,16 +924,16 @@ case OGOTO, OLABEL: - m = Nod(OXXX, nil, nil) + m := Nod(OXXX, nil, nil) *m = *n m.Ninit = nil - p = fmt.Sprintf("%s·%d", n.Left.Sym.Name, inlgen) + p := fmt.Sprintf("%s·%d", n.Left.Sym.Name, inlgen) m.Left = newname(Lookup(p)) return m } - m = Nod(OXXX, nil, nil) + m := Nod(OXXX, nil, nil) *m = *n m.Ninit = nil
diff --git a/src/cmd/internal/gc/lex.go b/src/cmd/internal/gc/lex.go index 26f2eff..9627337 100644 --- a/src/cmd/internal/gc/lex.go +++ b/src/cmd/internal/gc/lex.go
@@ -88,14 +88,11 @@ } func doversion() { - var p string - var sep string - - p = obj.Expstring() + p := obj.Expstring() if p == "X:none" { p = "" } - sep = "" + sep := "" if p != "" { sep = " " } @@ -105,12 +102,10 @@ func Main() { defer hidePanic() - var l *NodeList - var p string // Allow GOARCH=thearch.thestring or GOARCH=thearch.thestringsuffix, // but not other values. - p = obj.Getgoarch() + p := obj.Getgoarch() if !strings.HasPrefix(p, Thearch.Thestring) { log.Fatalf("cannot use %cg with GOARCH=%s", Thearch.Thechar, p) @@ -276,7 +271,7 @@ } if Thearch.Thechar == '8' { - p = obj.Getgo386() + p := obj.Getgo386() if p == "387" { Use_sse = 0 } else if p == "sse2" { @@ -355,7 +350,7 @@ // and methods but doesn't depend on any of it. defercheckwidth() - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op != ODCL && l.N.Op != OAS { typecheck(&l.N, Etop) } @@ -363,7 +358,7 @@ // Phase 2: Variable assignments. // To check interface assignments, depends on phase 1. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCL || l.N.Op == OAS { typecheck(&l.N, Etop) } @@ -371,7 +366,7 @@ resumecheckwidth() // Phase 3: Type check function bodies. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC || l.N.Op == OCLOSURE { Curfn = l.N decldepth = 1 @@ -387,7 +382,7 @@ // Phase 4: Decide how to capture closed variables. // This needs to run before escape analysis, // because variables captured by value do not escape. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC && l.N.Closure != nil { Curfn = l.N capturevars(l.N) @@ -404,7 +399,7 @@ if Debug['l'] > 1 { // Typecheck imported function bodies if debug['l'] > 1, // otherwise lazily when used or re-exported. - for l = importlist; l != nil; l = l.Next { + for l := importlist; l != nil; l = l.Next { if l.N.Inl != nil { saveerrors() typecheckinl(l.N) @@ -418,14 +413,14 @@ if Debug['l'] != 0 { // Find functions that can be inlined and clone them before walk expands them. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { caninl(l.N) } } // Expand inlineable calls in all functions - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { inlcalls(l.N) } @@ -447,7 +442,7 @@ // Phase 7: Transform closure bodies to properly reference captured variables. // This needs to happen before walk, because closures must be transformed // before walk reaches a call of a closure. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC && l.N.Closure != nil { Curfn = l.N transformclosure(l.N) @@ -457,7 +452,7 @@ Curfn = nil // Phase 8: Compile top level functions. - for l = xtop; l != nil; l = l.Next { + for l := xtop; l != nil; l = l.Next { if l.N.Op == ODCLFUNC { funccompile(l.N) } @@ -468,7 +463,7 @@ } // Phase 9: Check external declarations. - for l = externdcl; l != nil; l = l.Next { + for l := externdcl; l != nil; l = l.Next { if l.N.Op == ONAME { typecheck(&l.N, Erv) } @@ -511,11 +506,8 @@ } func skiptopkgdef(b *obj.Biobuf) bool { - var p string - var sz int - /* archive header */ - p = obj.Brdline(b, '\n') + p := obj.Brdline(b, '\n') if p == "" { return false } @@ -527,7 +519,7 @@ } /* symbol table may be first; skip it */ - sz = arsize(b, "__.GOSYMDEF") + sz := arsize(b, "__.GOSYMDEF") if sz >= 0 { obj.Bseek(b, int64(sz), 1) @@ -545,12 +537,11 @@ } func addidir(dir string) { - var pp **Idir - if dir == "" { return } + var pp **Idir for pp = &idirs; *pp != nil; pp = &(*pp).link { } *pp = new(Idir) @@ -567,11 +558,6 @@ } func findpkg(name *Strlit) bool { - var p *Idir - var q string - var suffix string - var suffixsep string - if islocalname(name) { if safemode != 0 || nolocalimports != 0 { return false @@ -595,13 +581,14 @@ // local imports should be canonicalized already. // don't want to see "encoding/../encoding/base64" // as different from "encoding/base64". + var q string _ = q if path.Clean(name.S) != name.S { Yyerror("non-canonical import path %v (should be %s)", Zconv(name, 0), q) return false } - for p = idirs; p != nil; p = p.link { + for p := idirs; p != nil; p = p.link { namebuf = fmt.Sprintf("%s/%v.a", p.dir, Zconv(name, 0)) if obj.Access(namebuf, 0) >= 0 { return true @@ -613,8 +600,8 @@ } if goroot != "" { - suffix = "" - suffixsep = "" + suffix := "" + suffixsep := "" if flag_installsuffix != "" { suffixsep = "_" suffix = flag_installsuffix @@ -642,17 +629,6 @@ } func importfile(f *Val, line int) { - var imp *obj.Biobuf - var file string - var p string - var q string - var tag string - var c int32 - var n int - var path_ *Strlit - var cleanbuf string - var prefix string - if f.Ctype != CTSTR { Yyerror("import statement not a string") fakeimport() @@ -696,7 +672,7 @@ return } - path_ = f.U.Sval + path_ := f.U.Sval if islocalname(path_) { if path_.S[0] == '/' { Yyerror("import path cannot be absolute path") @@ -704,11 +680,11 @@ return } - prefix = Ctxt.Pathname + prefix := Ctxt.Pathname if localimport != "" { prefix = localimport } - cleanbuf = prefix + cleanbuf := prefix cleanbuf += "/" cleanbuf += path_.S cleanbuf = path.Clean(cleanbuf) @@ -730,13 +706,13 @@ // If we already saw that package, feed a dummy statement // to the lexer to avoid parsing export data twice. if importpkg.Imported != 0 { - file = namebuf - tag = "" + file := namebuf + tag := "" if importpkg.Safe { tag = "safe" } - p = fmt.Sprintf("package %s %s\n$$\n", importpkg.Name, tag) + p := fmt.Sprintf("package %s %s\n$$\n", importpkg.Name, tag) cannedimports(file, p) return } @@ -744,15 +720,16 @@ importpkg.Imported = 1 var err error + var imp *obj.Biobuf imp, err = obj.Bopenr(namebuf) if err != nil { Yyerror("can't open import: \"%v\": %v", Zconv(f.U.Sval, 0), err) errorexit() } - file = namebuf + file := namebuf - n = len(namebuf) + n := len(namebuf) if n > 2 && namebuf[n-2] == '.' && namebuf[n-1] == 'a' { if !skiptopkgdef(imp) { Yyerror("import %s: not a package file", file) @@ -761,7 +738,7 @@ } // check object header - p = obj.Brdstr(imp, '\n', 1) + p := obj.Brdstr(imp, '\n', 1) if p != "empty archive" { if !strings.HasPrefix(p, "go object ") { @@ -769,7 +746,7 @@ errorexit() } - q = fmt.Sprintf("%s %s %s %s", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion(), obj.Expstring()) + q := fmt.Sprintf("%s %s %s %s", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion(), obj.Expstring()) if p[10:] != q { Yyerror("import %s: object is [%s] expected [%s]", file, p[10:], q) errorexit() @@ -793,6 +770,7 @@ curio.nlsemi = 0 typecheckok = 1 + var c int32 for { c = int32(getc()) if c == EOF { @@ -951,7 +929,6 @@ cp.Reset() for { - if escchar('"', &escflag, &v) { break } @@ -974,7 +951,6 @@ cp.Reset() for { - c = int(getr()) if c == '\r' { continue @@ -1014,9 +990,7 @@ case '/': c1 = getc() if c1 == '*' { - var nl int - - nl = 0 + nl := 0 for { c = int(getr()) if c == '\n' { @@ -1297,7 +1271,6 @@ */ talph: for { - if c >= utf8.RuneSelf { ungetc(c) rune_ = uint(getr()) @@ -1339,7 +1312,6 @@ cp.Reset() if c != '0' { for { - cp.WriteByte(byte(c)) c = getc() if yy_isdigit(c) { @@ -1353,7 +1325,6 @@ c = getc() if c == 'x' || c == 'X' { for { - cp.WriteByte(byte(c)) c = getc() if yy_isdigit(c) { @@ -1381,7 +1352,6 @@ c1 = 0 for { - if !yy_isdigit(c) { break } @@ -1436,7 +1406,6 @@ casedot: for { - cp.WriteByte(byte(c)) c = getc() if !yy_isdigit(c) { @@ -1463,7 +1432,6 @@ Yyerror("malformed fp constant exponent") } for yy_isdigit(c) { - cp.WriteByte(byte(c)) c = getc() } @@ -1533,21 +1501,18 @@ */ func getlinepragma() int { var cmd, verb, name string - var i int - var c int var n int var cp *bytes.Buffer var linep int - var h *obj.Hist - c = int(getr()) + c := int(getr()) if c == 'g' { goto go_ } if c != 'l' { goto out } - for i = 1; i < 5; i++ { + for i := 1; i < 5; i++ { c = int(getr()) if c != int("line "[i]) { goto out @@ -1597,7 +1562,7 @@ // try to avoid allocating file name over and over name = lexbuf.String()[:linep-1] - for h = Ctxt.Hist; h != nil; h = h.Link { + for h := Ctxt.Hist; h != nil; h = h.Link { if h.Name != "" && h.Name == name { linehist(h.Name, int32(n), 0) goto out @@ -1708,20 +1673,17 @@ // Copied nearly verbatim from the C compiler's #pragma parser. // TODO: Rewrite more cleanly once the compiler is written in Go. func pragcgo(text string) { - var local string - var remote string - var p string var q string - var verb string if i := strings.Index(text, " "); i >= 0 { text, q = text[:i], text[i:] } - verb = text[3:] // skip "go:" + verb := text[3:] // skip "go:" if verb == "cgo_dynamic_linker" || verb == "dynlinker" { var ok bool + var p string p, ok = getquoted(&q) if !ok { goto err1 @@ -1738,7 +1700,8 @@ verb = "cgo_export_dynamic" } if verb == "cgo_export_static" || verb == "cgo_export_dynamic" { - local = getimpsym(&q) + local := getimpsym(&q) + var remote string if local == "" { goto err2 } @@ -1761,7 +1724,9 @@ if verb == "cgo_import_dynamic" || verb == "dynimport" { var ok bool - local = getimpsym(&q) + local := getimpsym(&q) + var p string + var remote string if local == "" { goto err3 } @@ -1792,7 +1757,7 @@ } if verb == "cgo_import_static" { - local = getimpsym(&q) + local := getimpsym(&q) if local == "" || more(&q) { goto err4 } @@ -1806,6 +1771,7 @@ if verb == "cgo_ldflag" { var ok bool + var p string p, ok = getquoted(&q) if !ok { goto err5 @@ -1847,9 +1813,7 @@ } func yylex(yylval *yySymType) int32 { - var lx int - - lx = int(_yylex(yylval)) + lx := int(_yylex(yylval)) if curio.nlsemi != 0 && lx == EOF { // Treat EOF as "end of line" for the purposes @@ -1883,11 +1847,7 @@ } func getc() int { - var c int - var c1 int - var c2 int - - c = curio.peekc + c := curio.peekc if c != 0 { curio.peekc = curio.peekc1 curio.peekc1 = 0 @@ -1902,6 +1862,8 @@ curio.cp = curio.cp[1:] } } else { + var c1 int + var c2 int loop: c = obj.Bgetc(curio.bin) if c == 0xef { @@ -1974,14 +1936,9 @@ } func escchar(e int, escflg *int, val *int64) bool { - var i int - var u int - var c int - var l int64 - *escflg = 0 - c = int(getr()) + c := int(getr()) switch c { case EOF: Yyerror("eof in string") @@ -2002,8 +1959,10 @@ return false } - u = 0 + u := 0 c = int(getr()) + var l int64 + var i int switch c { case 'x': *escflg = 1 // it's a byte @@ -2091,7 +2050,7 @@ oct: l = int64(c) - '0' - for i = 2; i > 0; i-- { + for i := 2; i > 0; i-- { c = getc() if c >= '0' && c <= '7' { l = l*8 + int64(c) - '0' @@ -2482,19 +2441,17 @@ } func lexinit() { - var i int var lex int var s *Sym var s1 *Sym var t *Type var etype int - var v Val /* * initialize basic types array * initialize known symbols */ - for i = 0; i < len(syms); i++ { + for i := 0; i < len(syms); i++ { lex = syms[i].lexical s = Lookup(syms[i].name) s.Lexical = uint16(lex) @@ -2568,33 +2525,26 @@ Types[TNIL] = typ(TNIL) s = Pkglookup("nil", builtinpkg) + var v Val v.Ctype = CTNIL s.Def = nodlit(v) s.Def.Sym = s } func lexinit1() { - var s *Sym - var s1 *Sym - var t *Type - var f *Type - var rcvr *Type - var in *Type - var out *Type - // t = interface { Error() string } - rcvr = typ(TSTRUCT) + rcvr := typ(TSTRUCT) rcvr.Type = typ(TFIELD) rcvr.Type.Type = Ptrto(typ(TSTRUCT)) rcvr.Funarg = 1 - in = typ(TSTRUCT) + in := typ(TSTRUCT) in.Funarg = 1 - out = typ(TSTRUCT) + out := typ(TSTRUCT) out.Type = typ(TFIELD) out.Type.Type = Types[TSTRING] out.Funarg = 1 - f = typ(TFUNC) + f := typ(TFUNC) *getthis(f) = rcvr *Getoutarg(f) = out *getinarg(f) = in @@ -2602,16 +2552,16 @@ f.Intuple = 0 f.Outnamed = 0 f.Outtuple = 1 - t = typ(TINTER) + t := typ(TINTER) t.Type = typ(TFIELD) t.Type.Sym = Lookup("Error") t.Type.Type = f // error type - s = Lookup("error") + s := Lookup("error") s.Lexical = LNAME - s1 = Pkglookup("error", builtinpkg) + s1 := Pkglookup("error", builtinpkg) errortype = t errortype.Sym = s1 s1.Lexical = LNAME @@ -2643,7 +2593,6 @@ var lex int var etype int var i int - var v Val for i = 0; i < len(syms); i++ { lex = syms[i].lexical @@ -2701,6 +2650,7 @@ s = Lookup("nil") if s.Def == nil { + var v Val v.Ctype = CTNIL s.Def = nodlit(v) s.Def.Sym = s @@ -2920,9 +2870,7 @@ var lexname_buf string func lexname(lex int) string { - var i int - - for i = 0; i < len(lexn); i++ { + for i := 0; i < len(lexn); i++ { if lexn[i].lex == lex { return lexn[i].name } @@ -3131,15 +3079,13 @@ } func pkgnotused(lineno int, path_ *Strlit, name string) { - var elem string - // If the package was imported with a name other than the final // import path element, show it explicitly in the error message. // Note that this handles both renamed imports and imports of // packages containing unconventional package declarations. // Note that this uses / always, even on Windows, because Go import // paths always use forward slashes. - elem = path_.S + elem := path_.S if i := strings.LastIndex(elem, "/"); i >= 0 { elem = elem[i+1:] } @@ -3151,10 +3097,6 @@ } func mkpackage(pkgname string) { - var s *Sym - var h int32 - var p string - if localpkg.Name == "" { if pkgname == "_" { Yyerror("invalid package name _") @@ -3164,7 +3106,8 @@ if pkgname != localpkg.Name { Yyerror("package %s; expected %s", pkgname, localpkg.Name) } - for h = 0; h < NHASH; h++ { + var s *Sym + for h := int32(0); h < NHASH; h++ { for s = hash[h]; s != nil; s = s.Link { if s.Def == nil || s.Pkg != localpkg { continue @@ -3198,7 +3141,7 @@ } if outfile == "" { - p = infile + p := infile if i := strings.LastIndex(p, "/"); i >= 0 { p = p[i+1:] }
diff --git a/src/cmd/internal/gc/md5.go b/src/cmd/internal/gc/md5.go index 862fdd5..3b51900 100644 --- a/src/cmd/internal/gc/md5.go +++ b/src/cmd/internal/gc/md5.go
@@ -39,16 +39,13 @@ } func md5write(d *MD5, p []byte, nn int) { - var i int - var n int - d.len += uint64(nn) if d.nx > 0 { - n = nn + n := nn if n > _Chunk-d.nx { n = _Chunk - d.nx } - for i = 0; i < n; i++ { + for i := 0; i < n; i++ { d.x[d.nx+i] = uint8(p[i]) } d.nx += n @@ -61,11 +58,11 @@ nn -= n } - n = md5block(d, p, nn) + n := md5block(d, p, nn) p = p[n:] nn -= n if nn > 0 { - for i = 0; i < nn; i++ { + for i := 0; i < nn; i++ { d.x[i] = uint8(p[i]) } d.nx = nn @@ -73,14 +70,10 @@ } func md5sum(d *MD5, hi *uint64) uint64 { - var tmp [64]uint8 - var i int - var len uint64 - // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - len = d.len + len := d.len - tmp = [64]uint8{} + tmp := [64]uint8{} tmp[0] = 0x80 if len%64 < 56 { md5write(d, tmp[:], int(56-len%64)) @@ -91,7 +84,7 @@ // Length in bits. len <<= 3 - for i = 0; i < 8; i++ { + for i := 0; i < 8; i++ { tmp[i] = uint8(len >> uint(8*i)) } md5write(d, tmp[:], 8) @@ -194,24 +187,19 @@ var shift4 = []uint32{6, 10, 15, 21} func md5block(dig *MD5, p []byte, nn int) int { - var a uint32 - var b uint32 - var c uint32 - var d uint32 var aa uint32 var bb uint32 var cc uint32 var dd uint32 var i int var j int - var n int var X [16]uint32 - a = dig.s[0] - b = dig.s[1] - c = dig.s[2] - d = dig.s[3] - n = 0 + a := dig.s[0] + b := dig.s[1] + c := dig.s[2] + d := dig.s[3] + n := 0 for nn >= _Chunk { aa = a @@ -226,14 +214,10 @@ // Round 1. for i = 0; i < 16; i++ { - var x uint32 - var t uint32 - var s uint32 - var f uint32 - x = uint32(i) - t = uint32(i) - s = shift1[i%4] - f = ((c ^ d) & b) ^ d + x := uint32(i) + t := uint32(i) + s := shift1[i%4] + f := ((c ^ d) & b) ^ d a += f + X[x] + table[t] a = a<<s | a>>(32-s) a += b @@ -247,15 +231,10 @@ // Round 2. for i = 0; i < 16; i++ { - var x uint32 - var t uint32 - var s uint32 - var g uint32 - - x = (1 + 5*uint32(i)) % 16 - t = 16 + uint32(i) - s = shift2[i%4] - g = ((b ^ c) & d) ^ c + x := (1 + 5*uint32(i)) % 16 + t := 16 + uint32(i) + s := shift2[i%4] + g := ((b ^ c) & d) ^ c a += g + X[x] + table[t] a = a<<s | a>>(32-s) a += b @@ -269,15 +248,10 @@ // Round 3. for i = 0; i < 16; i++ { - var x uint32 - var t uint32 - var s uint32 - var h uint32 - - x = (5 + 3*uint32(i)) % 16 - t = 32 + uint32(i) - s = shift3[i%4] - h = b ^ c ^ d + x := (5 + 3*uint32(i)) % 16 + t := 32 + uint32(i) + s := shift3[i%4] + h := b ^ c ^ d a += h + X[x] + table[t] a = a<<s | a>>(32-s) a += b @@ -291,15 +265,10 @@ // Round 4. for i = 0; i < 16; i++ { - var x uint32 - var s uint32 - var t uint32 - var ii uint32 - - x = (7 * uint32(i)) % 16 - s = shift4[i%4] - t = 48 + uint32(i) - ii = c ^ (b | ^d) + x := (7 * uint32(i)) % 16 + s := shift4[i%4] + t := 48 + uint32(i) + ii := c ^ (b | ^d) a += ii + X[x] + table[t] a = a<<s | a>>(32-s) a += b
diff --git a/src/cmd/internal/gc/mparith1.go b/src/cmd/internal/gc/mparith1.go index 14b8620..454b688 100644 --- a/src/cmd/internal/gc/mparith1.go +++ b/src/cmd/internal/gc/mparith1.go
@@ -13,19 +13,17 @@ /// uses arithmetic func mpcmpfixflt(a *Mpint, b *Mpflt) int { - var buf string var c Mpflt - buf = fmt.Sprintf("%v", Bconv(a, 0)) + buf := fmt.Sprintf("%v", Bconv(a, 0)) mpatoflt(&c, buf) return mpcmpfltflt(&c, b) } func mpcmpfltfix(a *Mpflt, b *Mpint) int { - var buf string var c Mpflt - buf = fmt.Sprintf("%v", Bconv(b, 0)) + buf := fmt.Sprintf("%v", Bconv(b, 0)) mpatoflt(&c, buf) return mpcmpfltflt(a, &c) } @@ -133,11 +131,10 @@ // convert (truncate) b to a. // return -1 (but still convert) if b was non-integer. func mpexactfltfix(a *Mpint, b *Mpflt) int { - var f Mpflt - *a = b.Val Mpshiftfix(a, int(b.Exp)) if b.Exp < 0 { + var f Mpflt f.Val = *a f.Exp = 0 mpnorm(&f) @@ -150,15 +147,12 @@ } func mpmovefltfix(a *Mpint, b *Mpflt) int { - var f Mpflt - var i int - if mpexactfltfix(a, b) == 0 { return 0 } // try rounding down a little - f = *b + f := *b f.Val.A[0] = 0 if mpexactfltfix(a, &f) == 0 { @@ -166,7 +160,7 @@ } // try rounding up a little - for i = 1; i < Mpprec; i++ { + for i := 1; i < Mpprec; i++ { f.Val.A[i]++ if f.Val.A[i] != Mpbase { break @@ -209,12 +203,6 @@ } func mphextofix(a *Mpint, s string) { - var c int8 - var d int - var bit int - var hexdigitp int - var end int - for s != "" && s[0] == '0' { s = s[1:] } @@ -225,8 +213,11 @@ return } - end = len(s) - 1 - for hexdigitp = end; hexdigitp >= 0; hexdigitp-- { + end := len(s) - 1 + var c int8 + var d int + var bit int + for hexdigitp := end; hexdigitp >= 0; hexdigitp-- { c = int8(s[hexdigitp]) if c >= '0' && c <= '9' { d = int(c) - '0' @@ -252,25 +243,14 @@ // required syntax is [+-]d*[.]d*[e[+-]d*] or [+-]0xH*[e[+-]d*] // func mpatoflt(a *Mpflt, as string) { - var b Mpflt - var dp int - var c int - var f int - var ef int - var ex int - var eb int - var base int - var s string - var start string - for as[0] == ' ' || as[0] == '\t' { as = as[1:] } /* determine base */ - s = as + s := as - base = -1 + base := -1 for base == -1 { if s == "" { base = 10 @@ -296,14 +276,17 @@ } s = as - dp = 0 /* digits after decimal point */ - f = 0 /* sign */ - ex = 0 /* exponent */ - eb = 0 /* binary point */ + dp := 0 /* digits after decimal point */ + f := 0 /* sign */ + ex := 0 /* exponent */ + eb := 0 /* binary point */ Mpmovecflt(a, 0.0) + var ef int + var c int if base == 16 { - start = "" + start := "" + var c int for { c, _ = intstarstringplusplus(s) if c == '-' { @@ -437,6 +420,7 @@ } if mpcmpfltc(a, 0.0) != 0 { if ex >= dp { + var b Mpflt mppow10flt(&b, ex-dp) mpmulfltflt(a, &b) } else { @@ -444,6 +428,7 @@ if dp-ex >= 1<<(32-3) || int(int16(4*(dp-ex))) != 4*(dp-ex) { Mpmovecflt(a, 0.0) } else { + var b Mpflt mppow10flt(&b, dp-ex) mpdivfltflt(a, &b) } @@ -466,12 +451,10 @@ // func mpatofix(a *Mpint, as string) { var c int - var f int - var s string var s0 string - s = as - f = 0 + s := as + f := 0 Mpmovecfix(a, 0) c, s = intstarstringplusplus(s) @@ -555,29 +538,24 @@ } func Bconv(xval *Mpint, flag int) string { - var buf [500]byte - var p int - var fp string - var q Mpint - var r Mpint - var ten Mpint - var sixteen Mpint - var f int - var digit int mpmovefixfix(&q, xval) - f = 0 + f := 0 if mptestfix(&q) < 0 { f = 1 mpnegfix(&q) } - p = len(buf) + var buf [500]byte + p := len(buf) + var r Mpint if flag&obj.FmtSharp != 0 /*untyped*/ { // Hexadecimal + var sixteen Mpint Mpmovecfix(&sixteen, 16) + var digit int for { mpdivmodfixfix(&q, &r, &q, &sixteen) digit = int(Mpgetfix(&r)) @@ -599,6 +577,7 @@ buf[p] = '0' } else { // Decimal + var ten Mpint Mpmovecfix(&ten, 10) for { @@ -615,26 +594,20 @@ p-- buf[p] = '-' } + var fp string fp += string(buf[p:]) return fp } func Fconv(fvp *Mpflt, flag int) string { - var buf string - var fp string - - var fv Mpflt - var d float64 - var dexp float64 - var exp int - if flag&obj.FmtSharp != 0 /*untyped*/ { // alternate form - decimal for error messages. // for well in range, convert to double and use print's %g - exp = int(fvp.Exp) + sigfig(fvp)*Mpscale + exp := int(fvp.Exp) + sigfig(fvp)*Mpscale + var fp string if -900 < exp && exp < 900 { - d = mpgetflt(fvp) + d := mpgetflt(fvp) if d >= 0 && (flag&obj.FmtSign != 0 /*untyped*/) { fp += fmt.Sprintf("+") } @@ -644,15 +617,15 @@ // very out of range. compute decimal approximation by hand. // decimal exponent - dexp = float64(fvp.Exp) * 0.301029995663981195 // log_10(2) + dexp := float64(fvp.Exp) * 0.301029995663981195 // log_10(2) exp = int(dexp) // decimal mantissa - fv = *fvp + fv := *fvp fv.Val.Neg = 0 fv.Exp = 0 - d = mpgetflt(&fv) + d := mpgetflt(&fv) d *= math.Pow(10, dexp-float64(exp)) for d >= 9.99995 { d /= 10 @@ -668,6 +641,8 @@ return fp } + var fv Mpflt + var buf string if sigfig(fvp) == 0 { buf = fmt.Sprintf("0p+0") goto out @@ -693,6 +668,7 @@ buf = fmt.Sprintf("%vp-%d", Bconv(&fv.Val, obj.FmtSharp), -fv.Exp) out: + var fp string fp += buf return fp }
diff --git a/src/cmd/internal/gc/mparith2.go b/src/cmd/internal/gc/mparith2.go index 057585c..c9c9230 100644 --- a/src/cmd/internal/gc/mparith2.go +++ b/src/cmd/internal/gc/mparith2.go
@@ -9,11 +9,8 @@ // words of the argument // func mplen(a *Mpint) int { - var i int - var n int - - n = -1 - for i = 0; i < Mpprec; i++ { + n := -1 + for i := 0; i < Mpprec; i++ { if a.A[i] != 0 { n = i } @@ -28,11 +25,9 @@ // func mplsh(a *Mpint, quiet int) { var x int - var i int - var c int - c = 0 - for i = 0; i < Mpprec; i++ { + c := 0 + for i := 0; i < Mpprec; i++ { x = (a.A[i] << 1) + c c = 0 if x >= Mpbase { @@ -54,9 +49,7 @@ // ignores sign // func mplshw(a *Mpint, quiet int) { - var i int - - i = Mpprec - 1 + i := Mpprec - 1 if a.A[i] != 0 { a.Ovf = 1 if quiet == 0 { @@ -76,13 +69,10 @@ // func mprsh(a *Mpint) { var x int - var lo int - var i int - var c int - c = 0 - lo = a.A[0] & 1 - for i = Mpprec - 1; i >= 0; i-- { + c := 0 + lo := a.A[0] & 1 + for i := Mpprec - 1; i >= 0; i-- { x = a.A[i] a.A[i] = (x + c) >> 1 c = 0 @@ -101,10 +91,9 @@ // ignores sign and overflow // func mprshw(a *Mpint) { - var lo int var i int - lo = a.A[0] + lo := a.A[0] for i = 0; i < Mpprec-1; i++ { a.A[i] = a.A[i+1] } @@ -119,9 +108,6 @@ // return the sign of (abs(a)-abs(b)) // func mpcmp(a *Mpint, b *Mpint) int { - var x int - var i int - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in cmp") @@ -129,7 +115,8 @@ return 0 } - for i = Mpprec - 1; i >= 0; i-- { + var x int + for i := Mpprec - 1; i >= 0; i-- { x = a.A[i] - b.A[i] if x > 0 { return +1 @@ -148,11 +135,9 @@ // func mpneg(a *Mpint) { var x int - var i int - var c int - c = 0 - for i = 0; i < Mpprec; i++ { + c := 0 + for i := 0; i < Mpprec; i++ { x = -a.A[i] - c c = 0 if x < 0 { @@ -193,10 +178,6 @@ /// implements fix arihmetic func mpaddfixfix(a *Mpint, b *Mpint, quiet int) { - var i int - var c int - var x int - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mpaddxx") @@ -205,13 +186,14 @@ return } - c = 0 + c := 0 + var x int if a.Neg != b.Neg { goto sub } // perform a+b - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { x = a.A[i] + b.A[i] + c c = 0 if x >= Mpbase { @@ -236,7 +218,8 @@ Mpmovecfix(a, 0) case 1: - for i = 0; i < Mpprec; i++ { + var x int + for i := 0; i < Mpprec; i++ { x = a.A[i] - b.A[i] - c c = 0 if x < 0 { @@ -249,7 +232,8 @@ case -1: a.Neg ^= 1 - for i = 0; i < Mpprec; i++ { + var x int + for i := 0; i < Mpprec; i++ { x = b.A[i] - a.A[i] - c c = 0 if x < 0 { @@ -263,15 +247,6 @@ } func mpmulfixfix(a *Mpint, b *Mpint) { - var i int - var j int - var na int - var nb int - var x int - var s Mpint - var q Mpint - var c *Mpint - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mpmulfixfix") @@ -282,9 +257,11 @@ // pick the smaller // to test for bits - na = mplen(a) + na := mplen(a) - nb = mplen(b) + nb := mplen(b) + var s Mpint + var c *Mpint if na > nb { mpmovefixfix(&s, a) c = b @@ -296,8 +273,11 @@ s.Neg = 0 + var q Mpint Mpmovecfix(&q, 0) - for i = 0; i < na; i++ { + var j int + var x int + for i := 0; i < na; i++ { x = c.A[i] for j = 0; j < Mpscale; j++ { if x&1 != 0 { @@ -326,12 +306,6 @@ } func mpmulfract(a *Mpint, b *Mpint) { - var i int - var j int - var x int - var s Mpint - var q Mpint - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mpmulflt") @@ -340,16 +314,19 @@ return } + var s Mpint mpmovefixfix(&s, b) s.Neg = 0 + var q Mpint Mpmovecfix(&q, 0) - i = Mpprec - 1 - x = a.A[i] + i := Mpprec - 1 + x := a.A[i] if x != 0 { Yyerror("mpmulfract not normal") } + var j int for i--; i >= 0; i-- { x = a.A[i] if x == 0 { @@ -374,10 +351,7 @@ } func mporfixfix(a *Mpint, b *Mpint) { - var i int - var x int - - x = 0 + x := 0 if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mporfixfix") @@ -396,7 +370,7 @@ mpneg(b) } - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { x = a.A[i] | b.A[i] a.A[i] = x } @@ -411,10 +385,7 @@ } func mpandfixfix(a *Mpint, b *Mpint) { - var i int - var x int - - x = 0 + x := 0 if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mpandfixfix") @@ -433,7 +404,7 @@ mpneg(b) } - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { x = a.A[i] & b.A[i] a.A[i] = x } @@ -448,10 +419,7 @@ } func mpandnotfixfix(a *Mpint, b *Mpint) { - var i int - var x int - - x = 0 + x := 0 if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mpandnotfixfix") @@ -470,7 +438,7 @@ mpneg(b) } - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { x = a.A[i] &^ b.A[i] a.A[i] = x } @@ -485,10 +453,7 @@ } func mpxorfixfix(a *Mpint, b *Mpint) { - var i int - var x int - - x = 0 + x := 0 if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mporfixfix") @@ -507,7 +472,7 @@ mpneg(b) } - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { x = a.A[i] ^ b.A[i] a.A[i] = x } @@ -522,8 +487,6 @@ } func mplshfixfix(a *Mpint, b *Mpint) { - var s int64 - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mporfixfix") @@ -533,7 +496,7 @@ return } - s = Mpgetfix(b) + s := Mpgetfix(b) if s < 0 || s >= Mpprec*Mpscale { Yyerror("stupid shift: %d", s) Mpmovecfix(a, 0) @@ -544,8 +507,6 @@ } func mprshfixfix(a *Mpint, b *Mpint) { - var s int64 - if a.Ovf != 0 || b.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("ovf in mprshfixfix") @@ -555,7 +516,7 @@ return } - s = Mpgetfix(b) + s := Mpgetfix(b) if s < 0 || s >= Mpprec*Mpscale { Yyerror("stupid shift: %d", s) if a.Neg != 0 { @@ -574,8 +535,6 @@ } func Mpgetfix(a *Mpint) int64 { - var v int64 - if a.Ovf != 0 { if nsavederrors+nerrors == 0 { Yyerror("constant overflow") @@ -583,7 +542,7 @@ return 0 } - v = int64(uint64(a.A[0])) + v := int64(uint64(a.A[0])) v |= int64(uint64(a.A[1]) << Mpscale) v |= int64(uint64(a.A[2]) << (Mpscale + Mpscale)) if a.Neg != 0 { @@ -593,19 +552,16 @@ } func Mpmovecfix(a *Mpint, c int64) { - var i int - var x int64 - a.Neg = 0 a.Ovf = 0 - x = c + x := c if x < 0 { a.Neg = 1 x = int64(-uint64(x)) } - for i = 0; i < Mpprec; i++ { + for i := 0; i < Mpprec; i++ { a.A[i] = int(x & Mpmask) x >>= Mpscale } @@ -613,11 +569,9 @@ func mpdivmodfixfix(q *Mpint, r *Mpint, n *Mpint, d *Mpint) { var i int - var ns int - var ds int - ns = int(n.Neg) - ds = int(d.Neg) + ns := int(n.Neg) + ds := int(d.Neg) n.Neg = 0 d.Neg = 0 @@ -664,9 +618,7 @@ } func mpiszero(a *Mpint) bool { - var i int - - for i = Mpprec - 1; i >= 0; i-- { + for i := Mpprec - 1; i >= 0; i-- { if a.A[i] != 0 { return false } @@ -677,19 +629,17 @@ func mpdivfract(a *Mpint, b *Mpint) { var n Mpint var d Mpint - var i int var j int - var neg int var x int mpmovefixfix(&n, a) // numerator mpmovefixfix(&d, b) // denominator - neg = int(n.Neg) ^ int(d.Neg) + neg := int(n.Neg) ^ int(d.Neg) n.Neg = 0 d.Neg = 0 - for i = Mpprec - 1; i >= 0; i-- { + for i := Mpprec - 1; i >= 0; i-- { x = 0 for j = 0; j < Mpscale; j++ { x <<= 1 @@ -711,10 +661,9 @@ func mptestfix(a *Mpint) int { var b Mpint - var r int Mpmovecfix(&b, 0) - r = mpcmp(a, &b) + r := mpcmp(a, &b) if a.Neg != 0 { if r > 0 { return -1
diff --git a/src/cmd/internal/gc/mparith3.go b/src/cmd/internal/gc/mparith3.go index 61bf9e9..103c53d 100644 --- a/src/cmd/internal/gc/mparith3.go +++ b/src/cmd/internal/gc/mparith3.go
@@ -49,11 +49,7 @@ * word of the number to Mpnorm */ func mpnorm(a *Mpflt) { - var s int - var os int - var x int - - os = sigfig(a) + os := sigfig(a) if os == 0 { // zero a.Exp = 0 @@ -63,9 +59,9 @@ } // this will normalize to the nearest word - x = a.Val.A[os-1] + x := a.Val.A[os-1] - s = (Mpnorm - os) * Mpscale + s := (Mpnorm - os) * Mpscale // further normalize to the nearest bit for { @@ -91,16 +87,13 @@ /// implements float arihmetic func mpaddfltflt(a *Mpflt, b *Mpflt) { - var sa int - var sb int - var s int - var c Mpflt - if Mpdebug != 0 /*TypeKind(100016)*/ { fmt.Printf("\n%v + %v", Fconv(a, 0), Fconv(b, 0)) } - sa = sigfig(a) + sa := sigfig(a) + var s int + var sb int if sa == 0 { mpmovefltflt(a, b) goto out @@ -114,6 +107,7 @@ s = int(a.Exp) - int(b.Exp) if s > 0 { // a is larger, shift b right + var c Mpflt mpmovefltflt(&c, b) Mpshiftfix(&c.Val, -s) @@ -140,14 +134,11 @@ } func mpmulfltflt(a *Mpflt, b *Mpflt) { - var sa int - var sb int - if Mpdebug != 0 /*TypeKind(100016)*/ { fmt.Printf("%v\n * %v\n", Fconv(a, 0), Fconv(b, 0)) } - sa = sigfig(a) + sa := sigfig(a) if sa == 0 { // zero a.Exp = 0 @@ -156,7 +147,7 @@ return } - sb = sigfig(b) + sb := sigfig(b) if sb == 0 { // zero mpmovefltflt(a, b) @@ -174,15 +165,11 @@ } func mpdivfltflt(a *Mpflt, b *Mpflt) { - var sa int - var sb int - var c Mpflt - if Mpdebug != 0 /*TypeKind(100016)*/ { fmt.Printf("%v\n / %v\n", Fconv(a, 0), Fconv(b, 0)) } - sb = sigfig(b) + sb := sigfig(b) if sb == 0 { // zero and ovfl a.Exp = 0 @@ -193,7 +180,7 @@ return } - sa = sigfig(a) + sa := sigfig(a) if sa == 0 { // zero a.Exp = 0 @@ -203,6 +190,7 @@ } // adjust b to top + var c Mpflt mpmovefltflt(&c, b) Mpshiftfix(&c.Val, Mpscale) @@ -219,18 +207,11 @@ } func mpgetfltN(a *Mpflt, prec int, bias int) float64 { - var s int - var i int - var e int - var minexp int - var v uint64 - var f float64 - if a.Val.Ovf != 0 && nsavederrors+nerrors == 0 { Yyerror("mpgetflt ovf") } - s = sigfig(a) + s := sigfig(a) if s == 0 { return 0 } @@ -252,7 +233,8 @@ // pick up the mantissa, a rounding bit, and a tie-breaking bit in a uvlong s = prec + 2 - v = 0 + v := uint64(0) + var i int for i = Mpnorm - 1; s >= Mpscale; i-- { v = v<<Mpscale | uint64(a.Val.A[i]) s -= Mpscale @@ -273,11 +255,11 @@ } // gradual underflow - e = Mpnorm*Mpscale + int(a.Exp) - prec + e := Mpnorm*Mpscale + int(a.Exp) - prec - minexp = bias + 1 - prec + 1 + minexp := bias + 1 - prec + 1 if e < minexp { - s = minexp - e + s := minexp - e if s > prec+1 { s = prec + 1 } @@ -294,7 +276,7 @@ v += v & 1 v >>= 2 - f = float64(v) + f := float64(v) f = math.Ldexp(f, e) if a.Val.Neg != 0 { @@ -313,15 +295,14 @@ } func Mpmovecflt(a *Mpflt, c float64) { - var i int - var f float64 - var l int - if Mpdebug != 0 /*TypeKind(100016)*/ { fmt.Printf("\nconst %g", c) } Mpmovecfix(&a.Val, 0) a.Exp = 0 + var f float64 + var l int + var i int if c == 0 { goto out } @@ -333,7 +314,7 @@ f, i = math.Frexp(c) a.Exp = int16(i) - for i = 0; i < 10; i++ { + for i := 0; i < 10; i++ { f = f * Mpbase l = int(math.Floor(f)) f = f - float64(l) @@ -357,12 +338,10 @@ } func mptestflt(a *Mpflt) int { - var s int - if Mpdebug != 0 /*TypeKind(100016)*/ { fmt.Printf("\n%v?", Fconv(a, 0)) } - s = sigfig(a) + s := sigfig(a) if s != 0 { s = +1 if a.Val.Neg != 0 {
diff --git a/src/cmd/internal/gc/obj.go b/src/cmd/internal/gc/obj.go index afaf87c..27a1811 100644 --- a/src/cmd/internal/gc/obj.go +++ b/src/cmd/internal/gc/obj.go
@@ -21,13 +21,6 @@ } func dumpobj() { - var externs *NodeList - var tmp *NodeList - var arhdr [ArhdrSize]byte - var startobj int64 - var size int64 - var zero *Sym - var err error bout, err = obj.Bopenw(outfile) if err != nil { @@ -36,7 +29,8 @@ errorexit() } - startobj = 0 + startobj := int64(0) + var arhdr [ArhdrSize]byte if writearchive != 0 { obj.Bwritestring(bout, "!<arch>\n") arhdr = [ArhdrSize]byte{} @@ -49,7 +43,7 @@ if writearchive != 0 { obj.Bflush(bout) - size = obj.Boffset(bout) - startobj + size := obj.Boffset(bout) - startobj if size&1 != 0 { obj.Bputc(bout, 0) } @@ -77,7 +71,7 @@ fmt.Fprintf(bout, "\n!\n") - externs = nil + externs := (*NodeList)(nil) if externdcl != nil { externs = externdcl.End } @@ -86,7 +80,7 @@ dumptypestructs() // Dump extra globals. - tmp = externdcl + tmp := externdcl if externs != nil { externdcl = externs.Next @@ -94,7 +88,7 @@ dumpglobls() externdcl = tmp - zero = Pkglookup("zerovalue", Runtimepkg) + zero := Pkglookup("zerovalue", Runtimepkg) ggloblsym(zero, int32(zerosize), obj.DUPOK|obj.RODATA) dumpdata() @@ -102,7 +96,7 @@ if writearchive != 0 { obj.Bflush(bout) - size = obj.Boffset(bout) - startobj + size := obj.Boffset(bout) - startobj if size&1 != 0 { obj.Bputc(bout, 0) } @@ -117,10 +111,9 @@ func dumpglobls() { var n *Node - var l *NodeList // add globals - for l = externdcl; l != nil; l = l.Next { + for l := externdcl; l != nil; l = l.Next { n = l.N if n.Op != ONAME { continue @@ -140,7 +133,7 @@ ggloblnod(n) } - for l = funcsyms; l != nil; l = l.Next { + for l := funcsyms; l != nil; l = l.Next { n = l.N dsymptr(n.Sym, 0, n.Sym.Def.Shortname.Sym, 0) ggloblsym(n.Sym, int32(Widthptr), obj.DUPOK|obj.RODATA) @@ -156,8 +149,6 @@ } func Linksym(s *Sym) *obj.LSym { - var p string - if s == nil { return nil } @@ -169,7 +160,7 @@ } else if s.Linkname != "" { s.Lsym = obj.Linklookup(Ctxt, s.Linkname, 0) } else { - p = fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name) + p := fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name) s.Lsym = obj.Linklookup(Ctxt, p, 0) } @@ -208,10 +199,6 @@ var stringsym_gen int func stringsym(s string) *Sym { - var sym *Sym - var off int - var n int - var m int var tmp struct { lit Strlit buf string @@ -233,7 +220,7 @@ pkg = gostringpkg } - sym = Pkglookup(namebuf, pkg) + sym := Pkglookup(namebuf, pkg) // SymUniq flag indicates that data is generated already if sym.Flags&SymUniq != 0 { @@ -242,14 +229,15 @@ sym.Flags |= SymUniq sym.Def = newname(sym) - off = 0 + off := 0 // string header off = dsymptr(sym, off, sym, Widthptr+Widthint) off = duintxx(sym, off, uint64(len(s)), Widthint) // string data - for n = 0; n < len(s); n += m { + var m int + for n := 0; n < len(s); n += m { m = 8 if m > len(s)-n { m = len(s) - n @@ -267,18 +255,15 @@ var slicebytes_gen int func slicebytes(nam *Node, s string, len int) { - var off int - var n int var m int - var sym *Sym slicebytes_gen++ namebuf = fmt.Sprintf(".gobytes.%d", slicebytes_gen) - sym = Pkglookup(namebuf, localpkg) + sym := Pkglookup(namebuf, localpkg) sym.Def = newname(sym) - off = 0 - for n = 0; n < len; n += m { + off := 0 + for n := 0; n < len; n += m { m = 8 if m > len-n { m = len - n @@ -298,10 +283,8 @@ } func dstringptr(s *Sym, off int, str string) int { - var p *obj.Prog - off = int(Rnd(int64(off), int64(Widthptr))) - p = Thearch.Gins(obj.ADATA, nil, nil) + p := Thearch.Gins(obj.ADATA, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Sym = Linksym(s) @@ -321,9 +304,7 @@ * gobj.c */ func Datastring(s string, a *obj.Addr) { - var sym *Sym - - sym = stringsym(s) + sym := stringsym(s) a.Type = obj.TYPE_MEM a.Name = obj.NAME_EXTERN a.Sym = Linksym(sym) @@ -333,9 +314,7 @@ } func datagostring(sval *Strlit, a *obj.Addr) { - var sym *Sym - - sym = stringsym(sval.S) + sym := stringsym(sval.S) a.Type = obj.TYPE_MEM a.Name = obj.NAME_EXTERN a.Sym = Linksym(sym) @@ -345,29 +324,24 @@ } func dgostringptr(s *Sym, off int, str string) int { - var n int - var lit *Strlit - if str == "" { return duintptr(s, off, 0) } - n = len(str) - lit = new(Strlit) + n := len(str) + lit := new(Strlit) lit.S = str lit.S = lit.S[:n] return dgostrlitptr(s, off, lit) } func dgostrlitptr(s *Sym, off int, lit *Strlit) int { - var p *obj.Prog - if lit == nil { return duintptr(s, off, 0) } off = int(Rnd(int64(off), int64(Widthptr))) - p = Thearch.Gins(obj.ADATA, nil, nil) + p := Thearch.Gins(obj.ADATA, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Sym = Linksym(s) @@ -383,9 +357,7 @@ } func dsname(s *Sym, off int, t string) int { - var p *obj.Prog - - p = Thearch.Gins(obj.ADATA, nil, nil) + p := Thearch.Gins(obj.ADATA, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Offset = int64(off) @@ -399,11 +371,9 @@ } func dsymptr(s *Sym, off int, x *Sym, xoff int) int { - var p *obj.Prog - off = int(Rnd(int64(off), int64(Widthptr))) - p = Thearch.Gins(obj.ADATA, nil, nil) + p := Thearch.Gins(obj.ADATA, nil, nil) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN p.From.Sym = Linksym(s) @@ -420,8 +390,6 @@ } func gdata(nam *Node, nr *Node, wid int) { - var p *obj.Prog - if nr.Op == OLITERAL { switch nr.Val.Ctype { case CTCPLX: @@ -434,19 +402,16 @@ } } - p = Thearch.Gins(obj.ADATA, nam, nr) + p := Thearch.Gins(obj.ADATA, nam, nr) p.From3.Type = obj.TYPE_CONST p.From3.Offset = int64(wid) } func gdatacomplex(nam *Node, cval *Mpcplx) { - var p *obj.Prog - var w int - - w = cplxsubtype(int(nam.Type.Etype)) + w := cplxsubtype(int(nam.Type.Etype)) w = int(Types[w].Width) - p = Thearch.Gins(obj.ADATA, nam, nil) + p := Thearch.Gins(obj.ADATA, nam, nil) p.From3.Type = obj.TYPE_CONST p.From3.Offset = int64(w) p.To.Type = obj.TYPE_FCONST @@ -461,10 +426,9 @@ } func gdatastring(nam *Node, sval *Strlit) { - var p *obj.Prog var nod1 Node - p = Thearch.Gins(obj.ADATA, nam, nil) + p := Thearch.Gins(obj.ADATA, nam, nil) Datastring(sval.S, &p.To) p.From3.Type = obj.TYPE_CONST p.From3.Offset = Types[Tptr].Width
diff --git a/src/cmd/internal/gc/order.go b/src/cmd/internal/gc/order.go index 743ca80..e8744d7 100644 --- a/src/cmd/internal/gc/order.go +++ b/src/cmd/internal/gc/order.go
@@ -49,10 +49,8 @@ // Order rewrites fn->nbody to apply the ordering constraints // described in the comment at the top of the file. func order(fn *Node) { - var s string - if Debug['W'] > 1 { - s = fmt.Sprintf("\nbefore order %v", Sconv(fn.Nname.Sym, 0)) + s := fmt.Sprintf("\nbefore order %v", Sconv(fn.Nname.Sym, 0)) dumplist(s, fn.Nbody) } @@ -63,18 +61,14 @@ // pushes it onto the temp stack, and returns it. // If clear is true, ordertemp emits code to zero the temporary. func ordertemp(t *Type, order *Order, clear bool) *Node { - var var_ *Node - var a *Node - var l *NodeList - - var_ = temp(t) + var_ := temp(t) if clear { - a = Nod(OAS, var_, nil) + a := Nod(OAS, var_, nil) typecheck(&a, Etop) order.out = list(order.out, a) } - l = order.free + l := order.free if l == nil { l = new(NodeList) } @@ -98,11 +92,8 @@ // returns a pointer to the result data instead of taking a pointer // to be filled in.) func ordercopyexpr(n *Node, t *Type, order *Order, clear int) *Node { - var a *Node - var var_ *Node - - var_ = ordertemp(t, order, clear != 0) - a = Nod(OAS, var_, n) + var_ := ordertemp(t, order, clear != 0) + a := Nod(OAS, var_, n) typecheck(&a, Etop) order.out = list(order.out, a) return var_ @@ -130,21 +121,17 @@ // // The intended use is to apply to x when rewriting x += y into x = x + y. func ordersafeexpr(n *Node, order *Order) *Node { - var l *Node - var r *Node - var a *Node - switch n.Op { case ONAME, OLITERAL: return n case ODOT: - l = ordersafeexpr(n.Left, order) + l := ordersafeexpr(n.Left, order) if l == n.Left { return n } - a = Nod(OXXX, nil, nil) + a := Nod(OXXX, nil, nil) *a = *n a.Orig = a a.Left = l @@ -153,11 +140,11 @@ case ODOTPTR, OIND: - l = ordercheapexpr(n.Left, order) + l := ordercheapexpr(n.Left, order) if l == n.Left { return n } - a = Nod(OXXX, nil, nil) + a := Nod(OXXX, nil, nil) *a = *n a.Orig = a a.Left = l @@ -166,16 +153,17 @@ case OINDEX, OINDEXMAP: + var l *Node if Isfixedarray(n.Left.Type) { l = ordersafeexpr(n.Left, order) } else { l = ordercheapexpr(n.Left, order) } - r = ordercheapexpr(n.Right, order) + r := ordercheapexpr(n.Right, order) if l == n.Left && r == n.Right { return n } - a = Nod(OXXX, nil, nil) + a := Nod(OXXX, nil, nil) *a = *n a.Orig = a a.Left = l @@ -210,9 +198,7 @@ // If the original argument *np is not okay, orderaddrtemp creates a tmp, emits // tmp = *np, and then sets *np to the tmp variable. func orderaddrtemp(np **Node, order *Order) { - var n *Node - - n = *np + n := *np if isaddrokay(n) { return } @@ -244,10 +230,9 @@ // above the mark on the temporary stack, but it does not pop them // from the stack. func cleantempnopop(mark *NodeList, order *Order, out **NodeList) { - var l *NodeList var kill *Node - for l = order.temp; l != mark; l = l.Next { + for l := order.temp; l != mark; l = l.Next { kill = Nod(OVARKILL, l.N, nil) typecheck(&kill, Etop) *out = list(*out, kill) @@ -271,11 +256,8 @@ // Orderblock orders the block of statements *l onto a new list, // and then replaces *l with that list. func orderblock(l **NodeList) { - var order Order - var mark *NodeList - - order = Order{} - mark = marktemp(&order) + order := Order{} + mark := marktemp(&order) orderstmtlist(*l, &order) cleantemp(mark, &order) *l = order.out @@ -284,18 +266,14 @@ // Orderexprinplace orders the side effects in *np and // leaves them as the init list of the final *np. func orderexprinplace(np **Node, outer *Order) { - var n *Node - var lp **NodeList - var order Order - - n = *np - order = Order{} + n := *np + order := Order{} orderexpr(&n, &order) addinit(&n, order.out) // insert new temporaries from order // at head of outer list. - lp = &order.temp + lp := &order.temp for *lp != nil { lp = &(*lp).Next @@ -309,13 +287,9 @@ // Orderstmtinplace orders the side effects of the single statement *np // and replaces it with the resulting statement list. func orderstmtinplace(np **Node) { - var n *Node - var order Order - var mark *NodeList - - n = *np - order = Order{} - mark = marktemp(&order) + n := *np + order := Order{} + mark := marktemp(&order) orderstmt(n, &order) cleantemp(mark, &order) *np = liststmt(order.out) @@ -330,13 +304,11 @@ // Ismulticall reports whether the list l is f() for a multi-value function. // Such an f() could appear as the lone argument to a multi-arg function. func ismulticall(l *NodeList) bool { - var n *Node - // one arg only if l == nil || l.Next != nil { return false } - n = l.N + n := l.N // must be call switch n.Op { @@ -356,26 +328,21 @@ // Copyret emits t1, t2, ... = n, where n is a function call, // and then returns the list t1, t2, .... func copyret(n *Node, order *Order) *NodeList { - var t *Type - var tmp *Node - var as *Node - var l1 *NodeList - var l2 *NodeList - var tl Iter - if n.Type.Etype != TSTRUCT || n.Type.Funarg == 0 { Fatal("copyret %v %d", Tconv(n.Type, 0), n.Left.Type.Outtuple) } - l1 = nil - l2 = nil - for t = Structfirst(&tl, &n.Type); t != nil; t = structnext(&tl) { + l1 := (*NodeList)(nil) + l2 := (*NodeList)(nil) + var tl Iter + var tmp *Node + for t := Structfirst(&tl, &n.Type); t != nil; t = structnext(&tl) { tmp = temp(t.Type) l1 = list(l1, tmp) l2 = list(l2, tmp) } - as = Nod(OAS2, nil, nil) + as := Nod(OAS2, nil, nil) as.List = l1 as.Rlist = list1(n) typecheck(&as, Etop) @@ -426,11 +393,6 @@ // Ordermapassign also inserts these temporaries if needed for // calling writebarrierfat with a pointer to n->right. func ordermapassign(n *Node, order *Order) { - var m *Node - var a *Node - var l *NodeList - var post *NodeList - switch n.Op { default: Fatal("ordermapassign %v", Oconv(int(n.Op), 0)) @@ -440,9 +402,9 @@ // We call writebarrierfat only for values > 4 pointers long. See walk.c. if (n.Left.Op == OINDEXMAP || (needwritebarrier(n.Left, n.Right) && n.Left.Type.Width > int64(4*Widthptr))) && !isaddrokay(n.Right) { - m = n.Left + m := n.Left n.Left = ordertemp(m.Type, order, false) - a = Nod(OAS, m, n.Left) + a := Nod(OAS, m, n.Left) typecheck(&a, Etop) order.out = list(order.out, a) } @@ -451,8 +413,10 @@ OAS2DOTTYPE, OAS2MAPR, OAS2FUNC: - post = nil - for l = n.List; l != nil; l = l.Next { + post := (*NodeList)(nil) + var m *Node + var a *Node + for l := n.List; l != nil; l = l.Next { if l.N.Op == OINDEXMAP { m = l.N if !istemp(m.Left) { @@ -477,22 +441,11 @@ // Temporaries created during the statement are cleaned // up using VARKILL instructions as possible. func orderstmt(n *Node, order *Order) { - var lno int - var l *NodeList - var t *NodeList - var t1 *NodeList - var r *Node - var tmp1 *Node - var tmp2 *Node - var np **Node - var ch *Type - var typ *Type - if n == nil { return } - lno = int(setlineno(n)) + lno := int(setlineno(n)) orderinit(n, order) @@ -511,7 +464,7 @@ OPRINTN, ORECOVER, ORECV: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Left, order) orderexpr(&n.Right, order) orderexprlist(n.List, order) @@ -534,11 +487,11 @@ // out map read from map write when l is // a map index expression. case OASOP: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Left, order) n.Left = ordersafeexpr(n.Left, order) - tmp1 = treecopy(n.Left) + tmp1 := treecopy(n.Left) if tmp1.Op == OINDEXMAP { tmp1.Etype = 0 // now an rvalue not an lvalue } @@ -554,10 +507,10 @@ // Special: make sure key is addressable, // and make sure OINDEXMAP is not copied out. case OAS2MAPR: - t = marktemp(order) + t := marktemp(order) orderexprlist(n.List, order) - r = n.Rlist.N + r := n.Rlist.N orderexpr(&r.Left, order) orderexpr(&r.Right, order) @@ -571,7 +524,7 @@ // Special: avoid copy of func call n->rlist->n. case OAS2FUNC: - t = marktemp(order) + t := marktemp(order) orderexprlist(n.List, order) ordercall(n.Rlist.N, order) @@ -582,17 +535,17 @@ // so that assertI2Tetc can take address of temporary. // No temporary for blank assignment. case OAS2DOTTYPE: - t = marktemp(order) + t := marktemp(order) orderexprlist(n.List, order) orderexpr(&n.Rlist.N.Left, order) // i in i.(T) if isblank(n.List.N) { order.out = list(order.out, n) } else { - typ = n.Rlist.N.Type - tmp1 = ordertemp(typ, order, haspointers(typ)) + typ := n.Rlist.N.Type + tmp1 := ordertemp(typ, order, haspointers(typ)) order.out = list(order.out, n) - r = Nod(OAS, n.List.N, tmp1) + r := Nod(OAS, n.List.N, tmp1) typecheck(&r, Etop) ordermapassign(r, order) n.List = list(list1(tmp1), n.List.Next.N) @@ -603,19 +556,20 @@ // Special: use temporary variables to hold result, // so that chanrecv can take address of temporary. case OAS2RECV: - t = marktemp(order) + t := marktemp(order) orderexprlist(n.List, order) orderexpr(&n.Rlist.N.Left, order) // arg to recv - ch = n.Rlist.N.Left.Type - tmp1 = ordertemp(ch.Type, order, haspointers(ch.Type)) + ch := n.Rlist.N.Left.Type + tmp1 := ordertemp(ch.Type, order, haspointers(ch.Type)) + var tmp2 *Node if !isblank(n.List.Next.N) { tmp2 = ordertemp(n.List.Next.N.Type, order, false) } else { tmp2 = ordertemp(Types[TBOOL], order, false) } order.out = list(order.out, n) - r = Nod(OAS, n.List.N, tmp1) + r := Nod(OAS, n.List.N, tmp1) typecheck(&r, Etop) ordermapassign(r, order) r = Nod(OAS, n.List.Next.N, tmp2) @@ -646,7 +600,7 @@ case OCALLFUNC, OCALLINTER, OCALLMETH: - t = marktemp(order) + t := marktemp(order) ordercall(n, order) order.out = list(order.out, n) @@ -655,7 +609,7 @@ // Special: order arguments to inner call but not call itself. case ODEFER, OPROC: - t = marktemp(order) + t := marktemp(order) switch n.Left.Op { // Delete will take the address of the key. @@ -664,8 +618,8 @@ case ODELETE: orderexprlist(n.Left.List, order) - t1 = marktemp(order) - np = &n.Left.List.Next.N // map key + t1 := marktemp(order) + np := &n.Left.List.Next.N // map key *np = ordercopyexpr(*np, (*np).Type, order, 0) poptemp(t1, order) @@ -677,7 +631,7 @@ cleantemp(t, order) case ODELETE: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.List.N, order) orderexpr(&n.List.Next.N, order) orderaddrtemp(&n.List.Next.N, order) // map key @@ -687,10 +641,10 @@ // Clean temporaries from condition evaluation at // beginning of loop body and after for statement. case OFOR: - t = marktemp(order) + t := marktemp(order) orderexprinplace(&n.Ntest, order) - l = nil + l := (*NodeList)(nil) cleantempnopop(t, order, &l) n.Nbody = concat(l, n.Nbody) orderblock(&n.Nbody) @@ -701,10 +655,10 @@ // Clean temporaries from condition at // beginning of both branches. case OIF: - t = marktemp(order) + t := marktemp(order) orderexprinplace(&n.Ntest, order) - l = nil + l := (*NodeList)(nil) cleantempnopop(t, order, &l) n.Nbody = concat(l, n.Nbody) l = nil @@ -718,7 +672,7 @@ // Special: argument will be converted to interface using convT2E // so make sure it is an addressable temporary. case OPANIC: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Left, order) if !Isinter(n.Left.Type) { @@ -736,7 +690,7 @@ // which must make a copy to avoid seeing updates made during // the range body. Ranging over an array value is uncommon though. case ORANGE: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Right, order) switch n.Type.Etype { @@ -761,7 +715,7 @@ // fall through case TCHAN, TSTRING: - r = n.Right + r := n.Right if r.Type.Etype == TSTRING && r.Type != Types[TSTRING] { r = Nod(OCONV, r, nil) @@ -775,7 +729,7 @@ // TODO(rsc): Make tmp = literal expressions reuse tmp. // For maps tmp is just one word so it hardly matters. case TMAP: - r = n.Right + r := n.Right n.Right = ordercopyexpr(r, r.Type, order, 0) @@ -783,7 +737,7 @@ n.Alloc = ordertemp(Types[TUINT8], order, true) } - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { orderexprinplace(&l.N, order) } orderblock(&n.Nbody) @@ -804,9 +758,12 @@ // case (if p were nil, then the timing of the fault would // give this away). case OSELECT: - t = marktemp(order) + t := marktemp(order) - for l = n.List; l != nil; l = l.Next { + var tmp1 *Node + var tmp2 *Node + var r *Node + for l := n.List; l != nil; l = l.Next { if l.N.Op != OXCASE { Fatal("order select case %v", Oconv(int(l.N.Op), 0)) } @@ -931,7 +888,7 @@ // Now that we have accumulated all the temporaries, clean them. // Also insert any ninit queued during the previous loop. // (The temporary cleaning must follow that ninit work.) - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { cleantempnopop(t, order, &l.N.Ninit) l.N.Nbody = concat(l.N.Ninit, l.N.Nbody) l.N.Ninit = nil @@ -942,7 +899,7 @@ // Special: value being sent is passed as a pointer; make it addressable. case OSEND: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Left, order) orderexpr(&n.Right, order) @@ -958,10 +915,10 @@ // For now just clean all the temporaries at the end. // In practice that's fine. case OSWITCH: - t = marktemp(order) + t := marktemp(order) orderexpr(&n.Ntest, order) - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if l.N.Op != OXCASE { Fatal("order switch case %v", Oconv(int(l.N.Op), 0)) } @@ -994,20 +951,12 @@ // Orderexpr orders a single expression, appending side // effects to order->out as needed. func orderexpr(np **Node, order *Order) { - var n *Node - var mark *NodeList - var l *NodeList - var t *Type - var lno int - var haslit bool - var hasbyte bool - - n = *np + n := *np if n == nil { return } - lno = int(setlineno(n)) + lno := int(setlineno(n)) orderinit(n, order) switch n.Op { @@ -1024,7 +973,7 @@ orderexprlist(n.List, order) if count(n.List) > 5 { - t = typ(TARRAY) + t := typ(TARRAY) t.Bound = int64(count(n.List)) t.Type = Types[TSTRING] n.Alloc = ordertemp(t, order, false) @@ -1037,16 +986,16 @@ // Otherwise if all other arguments are empty strings, // concatstrings will return the reference to the temp string // to the caller. - hasbyte = false + hasbyte := false - haslit = false - for l = n.List; l != nil; l = l.Next { + haslit := false + for l := n.List; l != nil; l = l.Next { hasbyte = hasbyte || l.N.Op == OARRAYBYTESTR haslit = haslit || l.N.Op == OLITERAL && len(l.N.Val.U.Sval.S) != 0 } if haslit && hasbyte { - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if l.N.Op == OARRAYBYTESTR { l.N.Op = OARRAYBYTESTRTMP } @@ -1105,13 +1054,13 @@ case OANDAND, OOROR: - mark = marktemp(order) + mark := marktemp(order) orderexpr(&n.Left, order) // Clean temporaries from first branch at beginning of second. // Leave them on the stack so that they can be killed in the outer // context in case the short circuit is taken. - l = nil + l := (*NodeList)(nil) cleantempnopop(mark, order, &l) n.Right.Ninit = concat(l, n.Right.Ninit) @@ -1168,7 +1117,7 @@ ONE: orderexpr(&n.Left, order) orderexpr(&n.Right, order) - t = n.Left.Type + t := n.Left.Type if t.Etype == TSTRUCT || Isfixedarray(t) { // for complex comparisons, we need both args to be // addressable so we can pass them to the runtime.
diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go index c4c0dd4..cb6cb5b 100644 --- a/src/cmd/internal/gc/pgen.go +++ b/src/cmd/internal/gc/pgen.go
@@ -20,13 +20,11 @@ func makefuncdatasym(namefmt string, funcdatakind int64) *Sym { var nod Node - var pnod *Node - var sym *Sym namebuf = fmt.Sprintf(namefmt, makefuncdatasym_nsym) makefuncdatasym_nsym++ - sym = Lookup(namebuf) - pnod = newname(sym) + sym := Lookup(namebuf) + pnod := newname(sym) pnod.Class = PEXTERN Nodconst(&nod, Types[TINT32], funcdatakind) Thearch.Gins(obj.AFUNCDATA, &nod, pnod) @@ -115,9 +113,7 @@ } func removevardef(firstp *obj.Prog) { - var p *obj.Prog - - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { for p.Link != nil && (p.Link.As == obj.AVARDEF || p.Link.As == obj.AVARKILL) { p.Link = p.Link.Link } @@ -130,41 +126,31 @@ } func gcsymdup(s *Sym) { - var ls *obj.LSym - var lo uint64 - var hi uint64 - - ls = Linksym(s) + ls := Linksym(s) if len(ls.R) > 0 { Fatal("cannot rosymdup %s with relocations", ls.Name) } var d MD5 md5reset(&d) md5write(&d, ls.P, len(ls.P)) - lo = md5sum(&d, &hi) + var hi uint64 + lo := md5sum(&d, &hi) ls.Name = fmt.Sprintf("gclocals·%016x%016x", lo, hi) ls.Dupok = 1 } func emitptrargsmap() { - var nptr int - var nbitmap int - var j int - var off int - var xoffset int64 - var bv *Bvec - var sym *Sym + sym := Lookup(fmt.Sprintf("%s.args_stackmap", Curfn.Nname.Sym.Name)) - sym = Lookup(fmt.Sprintf("%s.args_stackmap", Curfn.Nname.Sym.Name)) - - nptr = int(Curfn.Type.Argwid / int64(Widthptr)) - bv = bvalloc(int32(nptr) * 2) - nbitmap = 1 + nptr := int(Curfn.Type.Argwid / int64(Widthptr)) + bv := bvalloc(int32(nptr) * 2) + nbitmap := 1 if Curfn.Type.Outtuple > 0 { nbitmap = 2 } - off = duint32(sym, 0, uint32(nbitmap)) + off := duint32(sym, 0, uint32(nbitmap)) off = duint32(sym, off, uint32(bv.n)) + var xoffset int64 if Curfn.Type.Thistuple > 0 { xoffset = 0 twobitwalktype1(getthisx(Curfn.Type), &xoffset, bv) @@ -175,13 +161,13 @@ twobitwalktype1(getinargx(Curfn.Type), &xoffset, bv) } - for j = 0; int32(j) < bv.n; j += 32 { + for j := 0; int32(j) < bv.n; j += 32 { off = duint32(sym, off, bv.b[j/32]) } if Curfn.Type.Outtuple > 0 { xoffset = 0 twobitwalktype1(getoutargx(Curfn.Type), &xoffset, bv) - for j = 0; int32(j) < bv.n; j += 32 { + for j := 0; int32(j) < bv.n; j += 32 { off = duint32(sym, off, bv.b[j/32]) } } @@ -198,9 +184,6 @@ // the top of the stack and increasing in size. // Non-autos sort on offset. func cmpstackvar(a *Node, b *Node) int { - var ap int - var bp int - if a.Class != b.Class { if a.Class == PAUTO { return +1 @@ -222,8 +205,8 @@ return int(b.Used) - int(a.Used) } - ap = bool2int(haspointers(a.Type)) - bp = bool2int(haspointers(b.Type)) + ap := bool2int(haspointers(a.Type)) + bp := bool2int(haspointers(b.Type)) if ap != bp { return bp - ap } @@ -246,10 +229,6 @@ // TODO(lvd) find out where the PAUTO/OLITERAL nodes come from. func allocauto(ptxt *obj.Prog) { - var ll *NodeList - var n *Node - var w int64 - Stksize = 0 stkptrsize = 0 @@ -258,7 +237,7 @@ } // Mark the PAUTO's unused. - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { if ll.N.Class == PAUTO { ll.N.Used = 0 } @@ -269,9 +248,9 @@ listsort(&Curfn.Dcl, cmpstackvar) // Unused autos are at the end, chop 'em off. - ll = Curfn.Dcl + ll := Curfn.Dcl - n = ll.N + n := ll.N if n.Class == PAUTO && n.Op == ONAME && n.Used == 0 { // No locals used at all Curfn.Dcl = nil @@ -280,7 +259,7 @@ return } - for ll = Curfn.Dcl; ll.Next != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll.Next != nil; ll = ll.Next { n = ll.Next.N if n.Class == PAUTO && n.Op == ONAME && n.Used == 0 { ll.Next = nil @@ -290,7 +269,8 @@ } // Reassign stack offsets of the locals that are still there. - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + var w int64 + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { n = ll.N if n.Class != PAUTO || n.Op != ONAME { continue @@ -323,7 +303,7 @@ fixautoused(ptxt) // The debug information needs accurate offsets on the symbols. - for ll = Curfn.Dcl; ll != nil; ll = ll.Next { + for ll := Curfn.Dcl; ll != nil; ll = ll.Next { if ll.N.Class != PAUTO || ll.N.Op != ONAME { continue } @@ -341,10 +321,9 @@ } func movelargefn(fn *Node) { - var l *NodeList var n *Node - for l = fn.Dcl; l != nil; l = l.Next { + for l := fn.Dcl; l != nil; l = l.Next { n = l.N if n.Class == PAUTO && n.Type != nil && n.Type.Width > MaxStackVarSize { addrescapes(n) @@ -353,8 +332,6 @@ } func Cgen_checknil(n *Node) { - var reg Node - if Disable_checknil != 0 { return } @@ -366,6 +343,7 @@ } if ((Thearch.Thechar == '5' || Thearch.Thechar == '9') && n.Op != OREGISTER) || n.Addable == 0 || n.Op == OLITERAL { + var reg Node Thearch.Regalloc(®, Types[Tptr], n) Thearch.Cgen(n, ®) Thearch.Gins(obj.ACHECKNIL, ®, nil) @@ -380,20 +358,6 @@ * ggen.c */ func compile(fn *Node) { - var pl *obj.Plist - var nod1 Node - var n *Node - var ptxt *obj.Prog - var p *obj.Prog - var lno int32 - var t *Type - var save Iter - var oldstksize int64 - var l *NodeList - var nam *Node - var gcargs *Sym - var gclocals *Sym - if Newproc == nil { Newproc = Sysfunc("newproc") Deferproc = Sysfunc("deferproc") @@ -403,11 +367,20 @@ throwreturn = Sysfunc("throwreturn") } - lno = setlineno(fn) + lno := setlineno(fn) Curfn = fn dowidth(Curfn.Type) + var oldstksize int64 + var nod1 Node + var ptxt *obj.Prog + var pl *obj.Plist + var p *obj.Prog + var n *Node + var nam *Node + var gcargs *Sym + var gclocals *Sym if fn.Nbody == nil { if pure_go != 0 || strings.HasPrefix(fn.Nname.Sym.Name, "init.") { Yyerror("missing function body", fn) @@ -428,7 +401,8 @@ if Curfn.Type.Outnamed != 0 { // add clearing of the output parameters - t = Structfirst(&save, Getoutarg(Curfn.Type)) + var save Iter + t := Structfirst(&save, Getoutarg(Curfn.Type)) for t != nil { if t.Nname != nil { @@ -501,11 +475,11 @@ gcargs = makefuncdatasym("gcargs·%d", obj.FUNCDATA_ArgsPointerMaps) gclocals = makefuncdatasym("gclocals·%d", obj.FUNCDATA_LocalsPointerMaps) - for t = Curfn.Paramfld; t != nil; t = t.Down { + for t := Curfn.Paramfld; t != nil; t = t.Down { gtrack(tracksym(t.Type)) } - for l = fn.Dcl; l != nil; l = l.Next { + for l := fn.Dcl; l != nil; l = l.Next { n = l.N if n.Op != ONAME { // might be OTYPE or OLITERAL continue
diff --git a/src/cmd/internal/gc/plive.go b/src/cmd/internal/gc/plive.go index 73f6086..99654c5 100644 --- a/src/cmd/internal/gc/plive.go +++ b/src/cmd/internal/gc/plive.go
@@ -61,9 +61,7 @@ } func xmalloc(size uint32) interface{} { - var result interface{} - - result = make([]byte, size) + result := (interface{})(make([]byte, size)) if result == nil { Fatal("malloc failed") } @@ -72,12 +70,10 @@ // Constructs a new basic block containing a single instruction. func newblock(prog *obj.Prog) *BasicBlock { - var result *BasicBlock - if prog == nil { Fatal("newblock: prog cannot be nil") } - result = new(BasicBlock) + result := new(BasicBlock) result.rpo = -1 result.mark = UNVISITED result.first = prog @@ -111,9 +107,6 @@ // stream. Any control flow, such as branches or fall throughs, that target the // existing instruction are adjusted to target the new instruction. func splicebefore(lv *Liveness, bb *BasicBlock, prev *obj.Prog, curr *obj.Prog) { - var next *obj.Prog - var tmp obj.Prog - // There may be other instructions pointing at curr, // and we want them to now point at prev. Instead of // trying to find all such instructions, swap the contents @@ -121,14 +114,14 @@ // The "opt" field is the backward link in the linked list. // Overwrite curr's data with prev, but keep the list links. - tmp = *curr + tmp := *curr *curr = *prev curr.Opt = tmp.Opt curr.Link = tmp.Link // Overwrite prev (now next) with curr's old data. - next = prev + next := prev *next = tmp next.Opt = nil @@ -151,27 +144,25 @@ // A pretty printer for basic blocks. func printblock(bb *BasicBlock) { var pred *BasicBlock - var succ *BasicBlock - var prog *obj.Prog - var i int fmt.Printf("basic block %d\n", bb.rpo) fmt.Printf("\tpred:") - for i = 0; i < len(bb.pred); i++ { + for i := 0; i < len(bb.pred); i++ { pred = bb.pred[i] fmt.Printf(" %d", pred.rpo) } fmt.Printf("\n") fmt.Printf("\tsucc:") - for i = 0; i < len(bb.succ); i++ { + var succ *BasicBlock + for i := 0; i < len(bb.succ); i++ { succ = bb.succ[i] fmt.Printf(" %d", succ.rpo) } fmt.Printf("\n") fmt.Printf("\tprog:\n") - for prog = bb.first; ; prog = prog.Link { + for prog := bb.first; ; prog = prog.Link { fmt.Printf("\t\t%v\n", prog) if prog == bb.last { break @@ -195,11 +186,8 @@ // Collects and returns and array of Node*s for functions arguments and local // variables. func getvariables(fn *Node) []*Node { - var result []*Node - var ll *NodeList - - result = make([]*Node, 0, 0) - for ll = fn.Dcl; ll != nil; ll = ll.Next { + result := make([]*Node, 0, 0) + for ll := fn.Dcl; ll != nil; ll = ll.Next { if ll.N.Op == ONAME { // In order for GODEBUG=gcdead=1 to work, each bitmap needs // to contain information about all variables covered by the bitmap. @@ -244,9 +232,8 @@ // A pretty printer for control flow graphs. Takes an array of BasicBlock*s. func printcfg(cfg []*BasicBlock) { var bb *BasicBlock - var i int32 - for i = 0; i < int32(len(cfg)); i++ { + for i := int32(0); i < int32(len(cfg)); i++ { bb = cfg[i] printblock(bb) } @@ -256,10 +243,9 @@ // standard algorithm. Unconnected blocks will not be affected. func reversepostorder(root *BasicBlock, rpo *int32) { var bb *BasicBlock - var i int root.mark = VISITED - for i = 0; i < len(root.succ); i++ { + for i := 0; i < len(root.succ); i++ { bb = root.succ[i] if bb.mark == UNVISITED { reversepostorder(bb, rpo) @@ -299,8 +285,6 @@ var isselectcommcasecall_names [5]*obj.LSym func isselectcommcasecall(prog *obj.Prog) bool { - var i int32 - if isselectcommcasecall_names[0] == nil { isselectcommcasecall_names[0] = Linksym(Pkglookup("selectsend", Runtimepkg)) isselectcommcasecall_names[1] = Linksym(Pkglookup("selectrecv", Runtimepkg)) @@ -308,7 +292,7 @@ isselectcommcasecall_names[3] = Linksym(Pkglookup("selectdefault", Runtimepkg)) } - for i = 0; isselectcommcasecall_names[i] != nil; i++ { + for i := int32(0); isselectcommcasecall_names[i] != nil; i++ { if iscall(prog, isselectcommcasecall_names[i]) { return true } @@ -352,10 +336,9 @@ // are implicit successors of the runtime·selectgo call node. The goal of this // analysis is to add these missing edges to complete the control flow graph. func addselectgosucc(selectgo *BasicBlock) { - var pred *BasicBlock var succ *BasicBlock - pred = selectgo + pred := selectgo for { if len(pred.pred) == 0 { Fatal("selectgo does not have a newselect") @@ -392,9 +375,8 @@ // array of BasicBlock*s containing selectgo calls. func fixselectgo(selectgo []*BasicBlock) { var bb *BasicBlock - var i int32 - for i = 0; i < int32(len(selectgo)); i++ { + for i := int32(0); i < int32(len(selectgo)); i++ { bb = selectgo[i] addselectgosucc(bb) } @@ -406,33 +388,25 @@ // array of BasicBlock*s in control flow graph form (basic blocks ordered by // their RPO number). func newcfg(firstp *obj.Prog) []*BasicBlock { - var p *obj.Prog - var prev *obj.Prog - var bb *BasicBlock - var cfg []*BasicBlock - var selectgo []*BasicBlock - var i int32 - var rpo int32 - // Reset the opt field of each prog to nil. In the first and second // passes, instructions that are labels temporarily use the opt field to // point to their basic block. In the third pass, the opt field reset // to point to the predecessor of an instruction in its basic block. - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { p.Opt = nil } // Allocate an array to remember where we have seen selectgo calls. // These blocks will be revisited to add successor control flow edges. - selectgo = make([]*BasicBlock, 0, 0) + selectgo := make([]*BasicBlock, 0, 0) // Loop through all instructions identifying branch targets // and fall-throughs and allocate basic blocks. - cfg = make([]*BasicBlock, 0, 0) + cfg := make([]*BasicBlock, 0, 0) - bb = newblock(firstp) + bb := newblock(firstp) cfg = append(cfg, bb) - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.To.Type == obj.TYPE_BRANCH { if p.To.U.Branch == nil { Fatal("prog branch to nil") @@ -458,7 +432,8 @@ // Loop through all basic blocks maximally growing the list of // contained instructions until a label is reached. Add edges // for branches and fall-through instructions. - for i = 0; i < int32(len(cfg)); i++ { + var p *obj.Prog + for i := int32(0); i < int32(len(cfg)); i++ { bb = cfg[i] for p = bb.last; p != nil; p = p.Link { if p.Opt != nil && p != bb.last { @@ -492,7 +467,8 @@ // Add back links so the instructions in a basic block can be traversed // backward. This is the final state of the instruction opt field. - for i = 0; i < int32(len(cfg)); i++ { + var prev *obj.Prog + for i := int32(0); i < int32(len(cfg)); i++ { bb = cfg[i] p = bb.first prev = nil @@ -513,13 +489,13 @@ // Find a depth-first order and assign a depth-first number to // all basic blocks. - for i = 0; i < int32(len(cfg)); i++ { + for i := int32(0); i < int32(len(cfg)); i++ { bb = cfg[i] bb.mark = UNVISITED } bb = cfg[0] - rpo = int32(len(cfg)) + rpo := int32(len(cfg)) reversepostorder(bb, &rpo) // Sort the basic blocks by their depth first number. The @@ -544,20 +520,15 @@ // Frees a control flow graph (an array of BasicBlock*s) and all of its leaf // data structures. func freecfg(cfg []*BasicBlock) { - var bb *BasicBlock - var bb0 *BasicBlock - var p *obj.Prog - var i int32 - var n int32 - - n = int32(len(cfg)) + n := int32(len(cfg)) if n > 0 { - bb0 = cfg[0] - for p = bb0.first; p != nil; p = p.Link { + bb0 := cfg[0] + for p := bb0.first; p != nil; p = p.Link { p.Opt = nil } - for i = 0; i < n; i++ { + var bb *BasicBlock + for i := int32(0); i < n; i++ { bb = cfg[i] freeblock(bb) } @@ -586,10 +557,6 @@ // initialization. func progeffects(prog *obj.Prog, vars []*Node, uevar *Bvec, varkill *Bvec, avarinit *Bvec) { var info ProgInfo - var from *obj.Addr - var to *obj.Addr - var node *Node - var i int32 bvresetall(uevar) bvresetall(varkill) @@ -607,7 +574,8 @@ // all the parameters for correctness, and similarly it must not // read the out arguments - they won't be set until the new // function runs. - for i = 0; i < int32(len(vars)); i++ { + var node *Node + for i := int32(0); i < int32(len(vars)); i++ { node = vars[i] switch node.Class &^ PHEAP { case PPARAM: @@ -634,7 +602,8 @@ if prog.As == obj.ATEXT { // A text instruction marks the entry point to a function and // the definition point of all in arguments. - for i = 0; i < int32(len(vars)); i++ { + var node *Node + for i := int32(0); i < int32(len(vars)); i++ { node = vars[i] switch node.Class &^ PHEAP { case PPARAM: @@ -649,7 +618,7 @@ } if info.Flags&(LeftRead|LeftWrite|LeftAddr) != 0 { - from = &prog.From + from := &prog.From if from.Node != nil && from.Sym != nil && ((from.Node).(*Node)).Curfn == Curfn { switch ((from.Node).(*Node)).Class &^ PHEAP { case PAUTO, @@ -680,7 +649,7 @@ Next: if info.Flags&(RightRead|RightWrite|RightAddr) != 0 { - to = &prog.To + to := &prog.To if to.Node != nil && to.Sym != nil && ((to.Node).(*Node)).Curfn == Curfn { switch ((to.Node).(*Node)).Class &^ PHEAP { case PAUTO, @@ -729,18 +698,13 @@ // liveness computation. The cfg argument is an array of BasicBlock*s and the // vars argument is an array of Node*s. func newliveness(fn *Node, ptxt *obj.Prog, cfg []*BasicBlock, vars []*Node) *Liveness { - var result *Liveness - var i int32 - var nblocks int32 - var nvars int32 - - result = new(Liveness) + result := new(Liveness) result.fn = fn result.ptxt = ptxt result.cfg = cfg result.vars = vars - nblocks = int32(len(cfg)) + nblocks := int32(len(cfg)) result.uevar = make([]*Bvec, nblocks) result.varkill = make([]*Bvec, nblocks) result.livein = make([]*Bvec, nblocks) @@ -749,8 +713,8 @@ result.avarinitany = make([]*Bvec, nblocks) result.avarinitall = make([]*Bvec, nblocks) - nvars = int32(len(vars)) - for i = 0; i < nblocks; i++ { + nvars := int32(len(vars)) + for i := int32(0); i < nblocks; i++ { result.uevar[i] = bvalloc(nvars) result.varkill[i] = bvalloc(nvars) result.livein[i] = bvalloc(nvars) @@ -767,19 +731,17 @@ // Frees the liveness structure and all of its leaf data structures. func freeliveness(lv *Liveness) { - var i int32 - if lv == nil { Fatal("freeliveness: cannot free nil") } - for i = 0; i < int32(len(lv.livepointers)); i++ { + for i := int32(0); i < int32(len(lv.livepointers)); i++ { } - for i = 0; i < int32(len(lv.argslivepointers)); i++ { + for i := int32(0); i < int32(len(lv.argslivepointers)); i++ { } - for i = 0; i < int32(len(lv.cfg)); i++ { + for i := int32(0); i < int32(len(lv.cfg)); i++ { } } @@ -798,14 +760,11 @@ // addresses to avoid confusing the C like conventions used in the node variable // names. func printnode(node *Node) { - var p string - var a string - - p = "" + p := "" if haspointers(node.Type) { p = "^" } - a = "" + a := "" if node.Addrtaken != 0 { a = "@" } @@ -814,10 +773,8 @@ // Pretty print a list of variables. The vars argument is an array of Node*s. func printvars(name string, bv *Bvec, vars []*Node) { - var i int32 - fmt.Printf("%s:", name) - for i = 0; i < int32(len(vars)); i++ { + for i := int32(0); i < int32(len(vars)); i++ { if bvget(bv, i) != 0 { printnode(vars[i]) } @@ -829,16 +786,11 @@ // analysis. func livenessprintblock(lv *Liveness, bb *BasicBlock) { var pred *BasicBlock - var succ *BasicBlock - var prog *obj.Prog - var live *Bvec - var i int - var pos int32 fmt.Printf("basic block %d\n", bb.rpo) fmt.Printf("\tpred:") - for i = 0; i < len(bb.pred); i++ { + for i := 0; i < len(bb.pred); i++ { pred = bb.pred[i] fmt.Printf(" %d", pred.rpo) } @@ -846,7 +798,8 @@ fmt.Printf("\n") fmt.Printf("\tsucc:") - for i = 0; i < len(bb.succ); i++ { + var succ *BasicBlock + for i := 0; i < len(bb.succ); i++ { succ = bb.succ[i] fmt.Printf(" %d", succ.rpo) } @@ -862,7 +815,9 @@ printvars("\tavarinitall", lv.avarinitall[bb.rpo], []*Node(lv.vars)) fmt.Printf("\tprog:\n") - for prog = bb.first; ; prog = prog.Link { + var live *Bvec + var pos int32 + for prog := bb.first; ; prog = prog.Link { fmt.Printf("\t\t%v", prog) if prog.As == obj.APCDATA && prog.From.Offset == obj.PCDATA_StackMapIndex { pos = int32(prog.To.Offset) @@ -882,18 +837,15 @@ // liveness analysis. func livenessprintcfg(lv *Liveness) { var bb *BasicBlock - var i int32 - for i = 0; i < int32(len(lv.cfg)); i++ { + for i := int32(0); i < int32(len(lv.cfg)); i++ { bb = lv.cfg[i] livenessprintblock(lv, bb) } } func checkauto(fn *Node, p *obj.Prog, n *Node) { - var l *NodeList - - 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 == PAUTO && l.N == n { return } @@ -905,21 +857,19 @@ } fmt.Printf("checkauto %v: %v (%p; class=%d) not found in %v\n", Nconv(Curfn, 0), Nconv(n, 0), n, n.Class, p) - for l = fn.Dcl; l != nil; l = l.Next { + for l := fn.Dcl; l != nil; l = l.Next { fmt.Printf("\t%v (%p; class=%d)\n", Nconv(l.N, 0), l.N, l.N.Class) } Yyerror("checkauto: invariant lost") } func checkparam(fn *Node, p *obj.Prog, n *Node) { - var l *NodeList - var a *Node - var class int - if isfunny(n) { return } - for l = fn.Dcl; l != nil; l = l.Next { + var a *Node + var class int + for l := fn.Dcl; l != nil; l = l.Next { a = l.N class = int(a.Class) &^ PHEAP if a.Op == ONAME && (class == PPARAM || class == PPARAMOUT) && a == n { @@ -928,7 +878,7 @@ } fmt.Printf("checkparam %v: %v (%p; class=%d) not found in %v\n", Nconv(Curfn, 0), Nconv(n, 0), n, n.Class, p) - for l = fn.Dcl; l != nil; l = l.Next { + for l := fn.Dcl; l != nil; l = l.Next { fmt.Printf("\t%v (%p; class=%d)\n", Nconv(l.N, 0), l.N, l.N.Class) } Yyerror("checkparam: invariant lost") @@ -955,13 +905,11 @@ // nodes and there are special cases to skip over that stuff. The analysis will // fail if this invariant blindly changes. func checkptxt(fn *Node, firstp *obj.Prog) { - var p *obj.Prog - if debuglive == 0 { return } - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if false { fmt.Printf("analyzing '%v'\n", p) } @@ -976,11 +924,6 @@ // the same type t. On https://rsc.googlecode.com/hg/testdata/slow.go, twobitwalktype1 // accounts for 40% of the 6g execution time. func twobitwalktype1(t *Type, xoffset *int64, bv *Bvec) { - var fieldoffset int64 - var i int64 - var o int64 - var t1 *Type - if t.Align > 0 && *xoffset&int64(t.Align-1) != 0 { Fatal("twobitwalktype1: invalid initial alignment, %v", Tconv(t, 0)) } @@ -1002,7 +945,7 @@ TFLOAT64, TCOMPLEX64, TCOMPLEX128: - for i = 0; i < t.Width; i++ { + for i := int64(0); i < t.Width; i++ { bvset(bv, int32(((*xoffset+i)/int64(Widthptr))*obj.BitsPerPointer)) // 1 = live scalar (BitsScalar) } @@ -1053,14 +996,15 @@ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+1)) // 2 = live ptr in first slot (BitsPointer) *xoffset += t.Width } else { - for i = 0; i < t.Bound; i++ { + for i := int64(0); i < t.Bound; i++ { twobitwalktype1(t.Type, xoffset, bv) } } case TSTRUCT: - o = 0 - for t1 = t.Type; t1 != nil; t1 = t1.Down { + o := int64(0) + var fieldoffset int64 + for t1 := t.Type; t1 != nil; t1 = t1.Down { fieldoffset = t1.Width *xoffset += fieldoffset - o twobitwalktype1(t1.Type, xoffset, bv) @@ -1089,12 +1033,9 @@ // argument is an array of Node*s. func twobitlivepointermap(lv *Liveness, liveout *Bvec, vars []*Node, args *Bvec, locals *Bvec) { var node *Node - var thisargtype *Type - var inargtype *Type var xoffset int64 - var i int32 - for i = 0; ; i++ { + for i := int32(0); ; i++ { i = int32(bvnext(liveout, i)) if i < 0 { break @@ -1116,14 +1057,14 @@ // If the receiver or arguments are unnamed, they will be omitted // from the list above. Preserve those values - even though they are unused - // in order to keep their addresses live for use in stack traces. - thisargtype = getthisx(lv.fn.Type) + thisargtype := getthisx(lv.fn.Type) if thisargtype != nil { xoffset = 0 twobitwalktype1(thisargtype, &xoffset, args) } - inargtype = getinargx(lv.fn.Type) + inargtype := getinargx(lv.fn.Type) if inargtype != nil { xoffset = 0 twobitwalktype1(inargtype, &xoffset, args) @@ -1132,9 +1073,7 @@ // Construct a disembodied instruction. func unlinkedprog(as int) *obj.Prog { - var p *obj.Prog - - p = Ctxt.NewProg() + p := Ctxt.NewProg() Clearp(p) p.As = int16(as) return p @@ -1145,11 +1084,10 @@ func newpcdataprog(prog *obj.Prog, index int32) *obj.Prog { var from Node var to Node - var pcdata *obj.Prog Nodconst(&from, Types[TINT32], obj.PCDATA_StackMapIndex) Nodconst(&to, Types[TINT32], int64(index)) - pcdata = unlinkedprog(obj.APCDATA) + pcdata := unlinkedprog(obj.APCDATA) pcdata.Lineno = prog.Lineno Naddr(&from, &pcdata.From, 0) Naddr(&to, &pcdata.To, 0) @@ -1167,18 +1105,13 @@ // block func livenessprologue(lv *Liveness) { var bb *BasicBlock - var uevar *Bvec - var varkill *Bvec - var avarinit *Bvec var p *obj.Prog - var i int32 - var nvars int32 - nvars = int32(len(lv.vars)) - uevar = bvalloc(nvars) - varkill = bvalloc(nvars) - avarinit = bvalloc(nvars) - for i = 0; i < int32(len(lv.cfg)); i++ { + nvars := int32(len(lv.vars)) + uevar := bvalloc(nvars) + varkill := bvalloc(nvars) + avarinit := bvalloc(nvars) + for i := int32(0); i < int32(len(lv.cfg)); i++ { bb = lv.cfg[i] // Walk the block instructions backward and update the block @@ -1214,29 +1147,20 @@ // Solve the liveness dataflow equations. func livenesssolve(lv *Liveness) { var bb *BasicBlock - var succ *BasicBlock - var pred *BasicBlock - var newlivein *Bvec - var newliveout *Bvec - var any *Bvec - var all *Bvec var rpo int32 - var i int32 - var j int32 - var change int32 // These temporary bitvectors exist to avoid successive allocations and // frees within the loop. - newlivein = bvalloc(int32(len(lv.vars))) + newlivein := bvalloc(int32(len(lv.vars))) - newliveout = bvalloc(int32(len(lv.vars))) - any = bvalloc(int32(len(lv.vars))) - all = bvalloc(int32(len(lv.vars))) + newliveout := bvalloc(int32(len(lv.vars))) + any := bvalloc(int32(len(lv.vars))) + all := bvalloc(int32(len(lv.vars))) // Push avarinitall, avarinitany forward. // avarinitall says the addressed var is initialized along all paths reaching the block exit. // avarinitany says the addressed var is initialized along some path reaching the block exit. - for i = 0; i < int32(len(lv.cfg)); i++ { + for i := int32(0); i < int32(len(lv.cfg)); i++ { bb = lv.cfg[i] rpo = int32(bb.rpo) if i == 0 { @@ -1249,7 +1173,10 @@ bvcopy(lv.avarinitany[rpo], lv.avarinit[rpo]) } - change = 1 + change := int32(1) + var j int32 + var i int32 + var pred *BasicBlock for change != 0 { change = 0 for i = 0; i < int32(len(lv.cfg)); i++ { @@ -1289,6 +1216,7 @@ // so low that it hardly seems to be worth the complexity. change = 1 + var succ *BasicBlock for change != 0 { change = 0 @@ -1328,19 +1256,17 @@ // This function is slow but it is only used for generating debug prints. // Check whether n is marked live in args/locals. func islive(n *Node, args *Bvec, locals *Bvec) bool { - var i int - switch n.Class { case PPARAM, PPARAMOUT: - for i = 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ { + for i := 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ { if bvget(args, int32(n.Xoffset/int64(Widthptr)*obj.BitsPerPointer+int64(i))) != 0 { return true } } case PAUTO: - for i = 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ { + for i := 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ { if bvget(locals, int32((n.Xoffset+stkptrsize)/int64(Widthptr)*obj.BitsPerPointer+int64(i))) != 0 { return true } @@ -1355,44 +1281,28 @@ func livenessepilogue(lv *Liveness) { var bb *BasicBlock var pred *BasicBlock - var ambig *Bvec - var livein *Bvec - var liveout *Bvec - var uevar *Bvec - var varkill *Bvec var args *Bvec var locals *Bvec - var avarinit *Bvec - var any *Bvec - var all *Bvec var n *Node var p *obj.Prog - var next *obj.Prog - var i int32 var j int32 - var numlive int32 - var startmsg int32 - var nmsg int32 - var nvars int32 var pos int32 var xoffset int64 - var msg []string - var fmt_ string - nvars = int32(len(lv.vars)) - livein = bvalloc(nvars) - liveout = bvalloc(nvars) - uevar = bvalloc(nvars) - varkill = bvalloc(nvars) - avarinit = bvalloc(nvars) - any = bvalloc(nvars) - all = bvalloc(nvars) - ambig = bvalloc(localswords() * obj.BitsPerPointer) - msg = nil - nmsg = 0 - startmsg = 0 + nvars := int32(len(lv.vars)) + livein := bvalloc(nvars) + liveout := bvalloc(nvars) + uevar := bvalloc(nvars) + varkill := bvalloc(nvars) + avarinit := bvalloc(nvars) + any := bvalloc(nvars) + all := bvalloc(nvars) + ambig := bvalloc(localswords() * obj.BitsPerPointer) + msg := []string(nil) + nmsg := int32(0) + startmsg := int32(0) - for i = 0; i < int32(len(lv.cfg)); i++ { + for i := int32(0); i < int32(len(lv.cfg)); i++ { bb = lv.cfg[i] // Compute avarinitany and avarinitall for entry to block. @@ -1481,7 +1391,10 @@ bb.lastbitmapindex = len(lv.livepointers) - 1 } - for i = 0; i < int32(len(lv.cfg)); i++ { + var fmt_ string + var next *obj.Prog + var numlive int32 + for i := int32(0); i < int32(len(lv.cfg)); i++ { bb = lv.cfg[i] if debuglive >= 1 && Curfn.Nname.Sym.Name != "init" && Curfn.Nname.Sym.Name[0] != '.' { @@ -1627,12 +1540,10 @@ ) func hashbitmap(h uint32, bv *Bvec) uint32 { - var i int - var n int var w uint32 - n = int((bv.n + 31) / 32) - for i = 0; i < n; i++ { + n := int((bv.n + 31) / 32) + for i := 0; i < n; i++ { w = bv.b[i] h = (h * Hp) ^ (w & 0xff) h = (h * Hp) ^ ((w >> 8) & 0xff) @@ -1658,45 +1569,37 @@ // PCDATA tables cost about 100k. So for now we keep using a single index for // both bitmap lists. func livenesscompact(lv *Liveness) { - var table []int - var remap []int - var i int - var j int - var n int - var tablesize int - var uniq int - var h uint32 - var local *Bvec - var arg *Bvec - var jlocal *Bvec - var jarg *Bvec - var p *obj.Prog - // Linear probing hash table of bitmaps seen so far. // The hash table has 4n entries to keep the linear // scan short. An entry of -1 indicates an empty slot. - n = len(lv.livepointers) + n := len(lv.livepointers) - tablesize = 4 * n - table = make([]int, tablesize) + tablesize := 4 * n + table := make([]int, tablesize) for i := range table { table[i] = -1 } // remap[i] = the new index of the old bit vector #i. - remap = make([]int, n) + remap := make([]int, n) for i := range remap { remap[i] = -1 } - uniq = 0 // unique tables found so far + uniq := 0 // unique tables found so far // Consider bit vectors in turn. // If new, assign next number using uniq, // record in remap, record in lv->livepointers and lv->argslivepointers // under the new index, and add entry to hash table. // If already seen, record earlier index in remap and free bitmaps. - for i = 0; i < n; i++ { + var jarg *Bvec + var j int + var h uint32 + var arg *Bvec + var jlocal *Bvec + var local *Bvec + for i := 0; i < n; i++ { local = lv.livepointers[i] arg = lv.argslivepointers[i] h = hashbitmap(hashbitmap(H0, local), arg) % uint32(tablesize) @@ -1732,13 +1635,14 @@ // we don't need anymore. Clear the pointers later in the // array so that we can tell where the coalesced bitmaps stop // and so that we don't double-free when cleaning up. - for j = uniq; j < n; j++ { + for j := uniq; j < n; j++ { lv.livepointers[j] = nil lv.argslivepointers[j] = nil } // Rewrite PCDATA instructions to use new numbering. - for p = lv.ptxt; p != nil; p = p.Link { + var i int + for p := lv.ptxt; p != nil; p = p.Link { if p.As == obj.APCDATA && p.From.Offset == obj.PCDATA_StackMapIndex { i = int(p.To.Offset) if i >= 0 { @@ -1749,12 +1653,10 @@ } func printbitset(printed int, name string, vars []*Node, bits *Bvec) int { - var i int - var started int var n *Node - started = 0 - for i = 0; i < len(vars); i++ { + started := 0 + for i := 0; i < len(vars); i++ { if bvget(bits, int32(i)) == 0 { continue } @@ -1782,27 +1684,22 @@ // This format synthesizes the information used during the multiple passes // into a single presentation. func livenessprintdebug(lv *Liveness) { - var i int var j int - var pcdata int var printed int var bb *BasicBlock var p *obj.Prog - var uevar *Bvec - var varkill *Bvec - var avarinit *Bvec var args *Bvec var locals *Bvec var n *Node fmt.Printf("liveness: %s\n", Curfn.Nname.Sym.Name) - uevar = bvalloc(int32(len(lv.vars))) - varkill = bvalloc(int32(len(lv.vars))) - avarinit = bvalloc(int32(len(lv.vars))) + uevar := bvalloc(int32(len(lv.vars))) + varkill := bvalloc(int32(len(lv.vars))) + avarinit := bvalloc(int32(len(lv.vars))) - pcdata = 0 - for i = 0; i < len(lv.cfg); i++ { + pcdata := 0 + for i := 0; i < len(lv.cfg); i++ { if i > 0 { fmt.Printf("\n") } @@ -1898,17 +1795,14 @@ // words that are followed are the raw bitmap words. The arr argument is an // array of Node*s. func twobitwritesymbol(arr []*Bvec, sym *Sym) { - var bv *Bvec - var off int var i int var j int - var n int var word uint32 - n = len(arr) - off = 0 + n := len(arr) + off := 0 off += 4 // number of bitmaps, to fill in later - bv = arr[0] + bv := arr[0] off = duint32(sym, off, uint32(bv.n)) // number of bits in each bitmap for i = 0; i < n; i++ { // bitmap words @@ -1944,14 +1838,8 @@ // the liveness of pointer variables in the function, and emits a runtime data // structure read by the garbage collector. func liveness(fn *Node, firstp *obj.Prog, argssym *Sym, livesym *Sym) { - var cfg []*BasicBlock - var vars []*Node - var lv *Liveness - var debugdelta int - var l *NodeList - // Change name to dump debugging information only for a specific function. - debugdelta = 0 + debugdelta := 0 if Curfn.Nname.Sym.Name == "!" { debugdelta = 2 @@ -1966,13 +1854,13 @@ checkptxt(fn, firstp) // Construct the global liveness state. - cfg = newcfg(firstp) + cfg := newcfg(firstp) if debuglive >= 3 { printcfg([]*BasicBlock(cfg)) } - vars = getvariables(fn) - lv = newliveness(fn, firstp, cfg, vars) + vars := getvariables(fn) + lv := newliveness(fn, firstp, cfg, vars) // Run the dataflow framework. livenessprologue(lv) @@ -2000,7 +1888,7 @@ twobitwritesymbol(lv.argslivepointers, argssym) // Free everything. - for l = fn.Dcl; l != nil; l = l.Next { + for l := fn.Dcl; l != nil; l = l.Next { if l.N != nil { l.N.Opt = nil }
diff --git a/src/cmd/internal/gc/popt.go b/src/cmd/internal/gc/popt.go index 8a3601b..756f8eb 100644 --- a/src/cmd/internal/gc/popt.go +++ b/src/cmd/internal/gc/popt.go
@@ -180,9 +180,6 @@ var noreturn_symlist [10]*Sym func Noreturn(p *obj.Prog) bool { - var s *Sym - var i int - if noreturn_symlist[0] == nil { noreturn_symlist[0] = Pkglookup("panicindex", Runtimepkg) noreturn_symlist[1] = Pkglookup("panicslice", Runtimepkg) @@ -197,11 +194,11 @@ if p.To.Node == nil { return false } - s = ((p.To.Node).(*Node)).Sym + s := ((p.To.Node).(*Node)).Sym if s == nil { return false } - for i = 0; noreturn_symlist[i] != nil; i++ { + for i := 0; noreturn_symlist[i] != nil; i++ { if s == noreturn_symlist[i] { return true } @@ -219,9 +216,7 @@ /* what instruction does a JMP to p eventually land on? */ func chasejmp(p *obj.Prog, jmploop *int) *obj.Prog { - var n int - - n = 0 + n := 0 for p != nil && p.As == obj.AJMP && p.To.Type == obj.TYPE_BRANCH { n++ if n > 10 { @@ -244,9 +239,7 @@ /* mark all code reachable from firstp as alive */ func mark(firstp *obj.Prog) { - var p *obj.Prog - - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.Opt != dead { break } @@ -261,18 +254,14 @@ } func fixjmp(firstp *obj.Prog) { - var jmploop int - var p *obj.Prog - var last *obj.Prog - if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("\nfixjmp\n") } // pass 1: resolve jump to jump, mark all code as dead. - jmploop = 0 + jmploop := 0 - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("%v\n", p) } @@ -294,9 +283,9 @@ mark(firstp) // pass 3: delete dead code (mostly JMPs). - last = nil + last := (*obj.Prog)(nil) - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { if p.Opt == dead { if p.Link == nil && p.As == obj.ARET && last != nil && last.As != obj.ARET { // This is the final ARET, and the code so far doesn't have one. @@ -326,8 +315,8 @@ // pass 4: elide JMP to next instruction. // only safe if there are no jumps to JMPs anymore. if jmploop == 0 { - last = nil - for p = firstp; p != nil; p = p.Link { + last := (*obj.Prog)(nil) + for p := firstp; p != nil; p = p.Link { if p.As == obj.AJMP && p.To.Type == obj.TYPE_BRANCH && p.To.U.Branch == p.Link { if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("del %v\n", p) @@ -346,7 +335,7 @@ if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("\n") - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { fmt.Printf("%v\n", p) } fmt.Printf("\n") @@ -374,20 +363,12 @@ // If size == 0, f->data will be nil. func Flowstart(firstp *obj.Prog, newData func() interface{}) *Graph { - var id int - var nf int - var f *Flow - var f1 *Flow - var start *Flow - var last *Flow - var graph *Graph - var p *obj.Prog var info ProgInfo // Count and mark instructions to annotate. - nf = 0 + nf := 0 - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { p.Opt = nil // should be already, but just in case Thearch.Proginfo(&info, p) if info.Flags&Skip != 0 { @@ -407,11 +388,12 @@ } // Allocate annotations and assign to instructions. - graph = new(Graph) + graph := new(Graph) ff := make([]Flow, nf) - start = &ff[0] - id = 0 - for p = firstp; p != nil; p = p.Link { + start := &ff[0] + id := 0 + var last *Flow + for p := firstp; p != nil; p = p.Link { if p.Opt == nil { continue } @@ -431,7 +413,9 @@ } // Fill in pred/succ information. - for f = start; f != nil; f = f.Link { + var f1 *Flow + var p *obj.Prog + for f := start; f != nil; f = f.Link { p = f.Prog Thearch.Proginfo(&info, p) if info.Flags&Break == 0 { @@ -465,9 +449,7 @@ } func Flowend(graph *Graph) { - var f *Flow - - for f = graph.Start; f != nil; f = f.Link { + for f := graph.Start; f != nil; f = f.Link { f.Prog.Opt = nil } } @@ -488,10 +470,8 @@ * recursively, all preds with a greater rpo number are in the loop */ func postorder(r *Flow, rpo2r []*Flow, n int32) int32 { - var r1 *Flow - r.Rpo = 1 - r1 = r.S1 + r1 := r.S1 if r1 != nil && r1.Rpo == 0 { n = postorder(r1, rpo2r, n) } @@ -505,11 +485,10 @@ } func rpolca(idom []int32, rpo1 int32, rpo2 int32) int32 { - var t int32 - if rpo1 == -1 { return rpo2 } + var t int32 for rpo1 != rpo2 { if rpo1 > rpo2 { t = rpo2 @@ -537,9 +516,7 @@ } func loophead(idom []int32, r *Flow) bool { - var src int32 - - src = r.Rpo + src := r.Rpo if r.P1 != nil && doms(idom, src, r.P1.Rpo) { return true } @@ -566,40 +543,34 @@ } func flowrpo(g *Graph) { - var r1 *Flow - var i int32 - var d int32 - var me int32 - var nr int32 - var idom []int32 - var rpo2r []*Flow - g.Rpo = make([]*Flow, g.Num) - idom = make([]int32, g.Num) + idom := make([]int32, g.Num) - for r1 = g.Start; r1 != nil; r1 = r1.Link { + for r1 := g.Start; r1 != nil; r1 = r1.Link { r1.Active = 0 } - rpo2r = g.Rpo - d = postorder(g.Start, rpo2r, 0) - nr = int32(g.Num) + rpo2r := g.Rpo + d := postorder(g.Start, rpo2r, 0) + nr := int32(g.Num) if d > nr { Fatal("too many reg nodes %d %d", d, nr) } nr = d - for i = 0; i < nr/2; i++ { + var r1 *Flow + for i := int32(0); i < nr/2; i++ { r1 = rpo2r[i] rpo2r[i] = rpo2r[nr-1-i] rpo2r[nr-1-i] = r1 } - for i = 0; i < nr; i++ { + for i := int32(0); i < nr; i++ { rpo2r[i].Rpo = i } idom[0] = 0 - for i = 0; i < nr; i++ { + var me int32 + for i := int32(0); i < nr; i++ { r1 = rpo2r[i] me = r1.Rpo d = -1 @@ -617,7 +588,7 @@ idom[i] = d } - for i = 0; i < nr; i++ { + for i := int32(0); i < nr; i++ { r1 = rpo2r[i] r1.Loop++ if r1.P2 != nil && loophead(idom, r1) { @@ -625,15 +596,13 @@ } } - for r1 = g.Start; r1 != nil; r1 = r1.Link { + for r1 := g.Start; r1 != nil; r1 = r1.Link { r1.Active = 0 } } func Uniqp(r *Flow) *Flow { - var r1 *Flow - - r1 = r.P1 + r1 := r.P1 if r1 == nil { r1 = r.P2 if r1 == nil || r1.P2link != nil { @@ -646,9 +615,7 @@ } func Uniqs(r *Flow) *Flow { - var r1 *Flow - - r1 = r.S1 + r1 := r.S1 if r1 == nil { r1 = r.S2 if r1 == nil { @@ -691,11 +658,8 @@ } func (x startcmp) Less(i, j int) bool { - var a *TempVar - var b *TempVar - - a = x[i] - b = x[j] + a := x[i] + b := x[j] if a.start < b.start { return true @@ -723,48 +687,28 @@ } func mergetemp(firstp *obj.Prog) { - var i int - var j int - var nvar int - var ninuse int - var nfree int - var nkill int - var var_ []TempVar - var v *TempVar - var v1 *TempVar - var bystart []*TempVar - var inuse []*TempVar - var f *Flow - var l *NodeList - var lp **NodeList - var n *Node - var p *obj.Prog - var p1 *obj.Prog - var t *Type - var info ProgInfo - var info1 ProgInfo - var gen int32 - var g *Graph const ( debugmerge = 1 ) - g = Flowstart(firstp, nil) + g := Flowstart(firstp, nil) if g == nil { return } // Build list of all mergeable variables. - nvar = 0 - for l = Curfn.Dcl; l != nil; l = l.Next { + nvar := 0 + for l := Curfn.Dcl; l != nil; l = l.Next { if canmerge(l.N) { nvar++ } } - var_ = make([]TempVar, nvar) + var_ := make([]TempVar, nvar) nvar = 0 - for l = Curfn.Dcl; l != nil; l = l.Next { + var n *Node + var v *TempVar + for l := Curfn.Dcl; l != nil; l = l.Next { n = l.N if canmerge(n) { v = &var_[nvar] @@ -778,7 +722,9 @@ // We assume that the earliest reference to a temporary is its definition. // This is not true of variables in general but our temporaries are all // single-use (that's why we have so many!). - for f = g.Start; f != nil; f = f.Link { + var p *obj.Prog + var info ProgInfo + for f := g.Start; f != nil; f = f.Link { p = f.Prog Thearch.Proginfo(&info, p) @@ -812,10 +758,13 @@ Dumpit("before", g.Start, 0) } - nkill = 0 + nkill := 0 // Special case. - for i = 0; i < len(var_); i++ { + var p1 *obj.Prog + var info1 ProgInfo + var f *Flow + for i := 0; i < len(var_); i++ { v = &var_[i] if v.addr != 0 { continue @@ -868,9 +817,9 @@ // Traverse live range of each variable to set start, end. // Each flood uses a new value of gen so that we don't have // to clear all the r->active words after each variable. - gen = 0 + gen := int32(0) - for i = 0; i < len(var_); i++ { + for i := 0; i < len(var_); i++ { v = &var_[i] gen++ for f = v.use; f != nil; f = f.Data.(*Flow) { @@ -885,9 +834,9 @@ } // Sort variables by start. - bystart = make([]*TempVar, len(var_)) + bystart := make([]*TempVar, len(var_)) - for i = 0; i < len(var_); i++ { + for i := 0; i < len(var_); i++ { bystart[i] = &var_[i] } sort.Sort(startcmp(bystart[:len(var_)])) @@ -898,11 +847,14 @@ // In theory we should use a sorted tree so that insertions are // guaranteed O(log n) and then the loop is guaranteed O(n log n). // In practice, it doesn't really matter. - inuse = make([]*TempVar, len(var_)) + inuse := make([]*TempVar, len(var_)) - ninuse = 0 - nfree = len(var_) - for i = 0; i < len(var_); i++ { + ninuse := 0 + nfree := len(var_) + var t *Type + var v1 *TempVar + var j int + for i := 0; i < len(var_); i++ { v = bystart[i] if debugmerge > 0 && Debug['v'] != 0 { fmt.Printf("consider %v: removed=%d\n", Nconv(v.node, obj.FmtSharp), v.removed) @@ -965,7 +917,8 @@ if debugmerge > 0 && Debug['v'] != 0 { fmt.Printf("%v [%d - %d]\n", Sconv(Curfn.Nname.Sym, 0), len(var_), nkill) - for i = 0; i < len(var_); i++ { + var v *TempVar + for i := 0; i < len(var_); i++ { v = &var_[i] fmt.Printf("var %v %v %d-%d", Nconv(v.node, obj.FmtSharp), Tconv(v.node.Type, 0), v.start, v.end) if v.addr != 0 { @@ -989,7 +942,7 @@ } // Update node references to use merged temporaries. - for f = g.Start; f != nil; f = f.Link { + for f := g.Start; f != nil; f = f.Link { p = f.Prog n, _ = p.From.Node.(*Node) if n != nil { @@ -1008,7 +961,8 @@ } // Delete merged nodes from declaration list. - for lp = &Curfn.Dcl; ; { + var l *NodeList + for lp := &Curfn.Dcl; ; { l = *lp if l == nil { break @@ -1026,7 +980,7 @@ } // Clear aux structures. - for i = 0; i < len(var_); i++ { + for i := 0; i < len(var_); i++ { var_[i].node.Opt = nil } @@ -1036,8 +990,6 @@ func mergewalk(v *TempVar, f0 *Flow, gen uint32) { var p *obj.Prog var f1 *Flow - var f *Flow - var f2 *Flow for f1 = f0; f1 != nil; f1 = f1.P1 { if uint32(f1.Active) == gen { @@ -1054,7 +1006,8 @@ } } - for f = f0; f != f1; f = f.P1 { + var f2 *Flow + for f := f0; f != f1; f = f.P1 { for f2 = f.P2; f2 != nil; f2 = f2.P2link { mergewalk(v, f2, gen) } @@ -1064,7 +1017,6 @@ func varkillwalk(v *TempVar, f0 *Flow, gen uint32) { var p *obj.Prog var f1 *Flow - var f *Flow for f1 = f0; f1 != nil; f1 = f1.S1 { if uint32(f1.Active) == gen { @@ -1083,7 +1035,7 @@ } } - for f = f0; f != f1; f = f.S1 { + for f := f0; f != f1; f = f.S1 { varkillwalk(v, f.S2, gen) } } @@ -1107,13 +1059,7 @@ var killed int // f->data is either nil or &killed func nilopt(firstp *obj.Prog) { - var f *Flow - var p *obj.Prog - var g *Graph - var ncheck int - var nkill int - - g = Flowstart(firstp, nil) + g := Flowstart(firstp, nil) if g == nil { return } @@ -1122,9 +1068,10 @@ Dumpit("nilopt", g.Start, 0) } - ncheck = 0 - nkill = 0 - for f = g.Start; f != nil; f = f.Link { + ncheck := 0 + nkill := 0 + var p *obj.Prog + for f := g.Start; f != nil; f = f.Link { p = f.Prog if p.As != obj.ACHECKNIL || !Thearch.Regtyp(&p.From) { continue @@ -1155,7 +1102,7 @@ } } - for f = g.Start; f != nil; f = f.Link { + for f := g.Start; f != nil; f = f.Link { if f.Data != nil { nkill++ Thearch.Excise(f) @@ -1172,9 +1119,8 @@ func nilwalkback(fcheck *Flow) { var p *obj.Prog var info ProgInfo - var f *Flow - for f = fcheck; f != nil; f = Uniqp(f) { + for f := fcheck; f != nil; f = Uniqp(f) { p = f.Prog Thearch.Proginfo(&info, p) if (info.Flags&RightWrite != 0) && Thearch.Sameaddr(&p.To, &fcheck.Prog.From) { @@ -1231,8 +1177,6 @@ nilwalkback(fcheck, f2, gen); */ func nilwalkfwd(fcheck *Flow) { - var f *Flow - var last *Flow var p *obj.Prog var info ProgInfo @@ -1243,9 +1187,9 @@ // avoid problems like: // _ = *x // should panic // for {} // no writes but infinite loop may be considered visible - last = nil + last := (*Flow)(nil) - for f = Uniqs(fcheck); f != nil; f = Uniqs(f) { + for f := Uniqs(fcheck); f != nil; f = Uniqs(f) { p = f.Prog Thearch.Proginfo(&info, p)
diff --git a/src/cmd/internal/gc/racewalk.go b/src/cmd/internal/gc/racewalk.go index 582f6b4..3619fed 100644 --- a/src/cmd/internal/gc/racewalk.go +++ b/src/cmd/internal/gc/racewalk.go
@@ -31,10 +31,8 @@ var noinst_pkgs = []string{"sync", "sync/atomic"} func ispkgin(pkgs []string) bool { - var i int - if myimportpath != "" { - for i = 0; i < len(pkgs); i++ { + for i := 0; i < len(pkgs); i++ { if myimportpath == pkgs[i] { return true } @@ -54,10 +52,6 @@ } func racewalk(fn *Node) { - var nd *Node - var nodpc *Node - var s string - if ispkgin(omit_pkgs) || isforkfunc(fn) { return } @@ -72,18 +66,18 @@ // nodpc is the PC of the caller as extracted by // getcallerpc. We use -widthptr(FP) for x86. // BUG: this will not work on arm. - nodpc = Nod(OXXX, nil, nil) + nodpc := Nod(OXXX, nil, nil) *nodpc = *nodfp nodpc.Type = Types[TUINTPTR] nodpc.Xoffset = int64(-Widthptr) - nd = mkcall("racefuncenter", nil, nil, nodpc) + nd := mkcall("racefuncenter", nil, nil, nodpc) fn.Enter = concat(list1(nd), fn.Enter) nd = mkcall("racefuncexit", nil, nil) fn.Exit = list(fn.Exit, nd) if Debug['W'] != 0 { - s = fmt.Sprintf("after racewalk %v", Sconv(fn.Nname.Sym, 0)) + s := fmt.Sprintf("after racewalk %v", Sconv(fn.Nname.Sym, 0)) dumplist(s, fn.Nbody) s = fmt.Sprintf("enter %v", Sconv(fn.Nname.Sym, 0)) dumplist(s, fn.Enter) @@ -110,12 +104,7 @@ // walks the tree and adds calls to the // instrumentation code to top-level (statement) nodes' init func racewalknode(np **Node, init **NodeList, wr int, skip int) { - var n *Node - var n1 *Node - var l *NodeList - var fini *NodeList - - n = *np + n := *np if n == nil { return @@ -132,7 +121,7 @@ // If init == &n->ninit and n->ninit is non-nil, // racewalknode might append it to itself. // nil it out and handle it separately before putting it back. - l = n.Ninit + l := n.Ninit n.Ninit = nil racewalklist(l, nil) @@ -174,7 +163,7 @@ OCALLINTER: racewalknode(&n.List.N, &n.List.N.Ninit, 0, 0) - fini = nil + fini := (*NodeList)(nil) racewalklist(n.List.Next, &fini) n.List = concat(n.List, fini) @@ -204,6 +193,7 @@ if n.Left.Sym != nil && n.Left.Sym.Pkg == Runtimepkg && (strings.HasPrefix(n.Left.Sym.Name, "writebarrier") || n.Left.Sym.Name == "typedmemmove") { // Find the dst argument. // The list can be reordered, so it's not necessary just the first or the second element. + var l *NodeList for l = n.List; l != nil; l = l.Next { if n.Left.Sym.Name == "typedmemmove" { if l.N.Left.Xoffset == int64(Widthptr) { @@ -263,7 +253,7 @@ OCAP: racewalknode(&n.Left, init, 0, 0) if Istype(n.Left.Type, TMAP) { - n1 = Nod(OCONVNOP, n.Left, nil) + n1 := Nod(OCONVNOP, n.Left, nil) n1.Type = Ptrto(Types[TUINT8]) n1 = Nod(OIND, n1, nil) typecheck(&n1, Erv) @@ -495,15 +485,7 @@ } func callinstr(np **Node, init **NodeList, wr int, skip int) bool { - var name string - var f *Node - var b *Node - var n *Node - var t *Type - var class int - var hascalls int - - n = *np + n := *np //print("callinstr for %+N [ %O ] etype=%E class=%d\n", // n, n->op, n->type ? n->type->etype : -1, n->class); @@ -511,25 +493,25 @@ if skip != 0 || n.Type == nil || n.Type.Etype >= TIDEAL { return false } - t = n.Type + t := n.Type if isartificial(n) { return false } - b = outervalue(n) + b := outervalue(n) // it skips e.g. stores to ... parameter array if isartificial(b) { return false } - class = int(b.Class) + class := int(b.Class) // BUG: we _may_ want to instrument PAUTO sometimes // e.g. if we've got a local variable/method receiver // that has got a pointer inside. Whether it points to // the heap or not is impossible to know at compile time if (class&PHEAP != 0) || class == PPARAMREF || class == PEXTERN || b.Op == OINDEX || b.Op == ODOTPTR || b.Op == OIND { - hascalls = 0 + hascalls := 0 foreach(n, hascallspred, &hascalls) if hascalls != 0 { n = detachexpr(n, init) @@ -538,14 +520,15 @@ n = treecopy(n) makeaddable(n) + var f *Node if t.Etype == TSTRUCT || Isfixedarray(t) { - name = "racereadrange" + name := "racereadrange" if wr != 0 { name = "racewriterange" } f = mkcall(name, nil, init, uintptraddr(n), Nodintconst(t.Width)) } else { - name = "raceread" + name := "raceread" if wr != 0 { name = "racewrite" } @@ -592,9 +575,7 @@ } func uintptraddr(n *Node) *Node { - var r *Node - - r = Nod(OADDR, n, nil) + r := Nod(OADDR, n, nil) r.Bounded = true r = conv(r, Types[TUNSAFEPTR]) r = conv(r, Types[TUINTPTR]) @@ -602,18 +583,13 @@ } func detachexpr(n *Node, init **NodeList) *Node { - var addr *Node - var as *Node - var ind *Node - var l *Node - - addr = Nod(OADDR, n, nil) - l = temp(Ptrto(n.Type)) - as = Nod(OAS, l, addr) + addr := Nod(OADDR, n, nil) + l := temp(Ptrto(n.Type)) + as := Nod(OAS, l, addr) typecheck(&as, Etop) walkexpr(&as, init) *init = list(*init, as) - ind = Nod(OIND, l, nil) + ind := Nod(OIND, l, nil) typecheck(&ind, Erv) walkexpr(&ind, init) return ind @@ -656,13 +632,11 @@ // appendinit is like addinit in subr.c // but appends rather than prepends. func appendinit(np **Node, init *NodeList) { - var n *Node - if init == nil { return } - n = *np + n := *np switch n.Op { // There may be multiple refs to this node; // introduce OCONVNOP to hold init list.
diff --git a/src/cmd/internal/gc/range.go b/src/cmd/internal/gc/range.go index bb30bcf..616c859 100644 --- a/src/cmd/internal/gc/range.go +++ b/src/cmd/internal/gc/range.go
@@ -12,12 +12,10 @@ func typecheckrange(n *Node) { var toomany int var why string - var t *Type var t1 *Type var t2 *Type var v1 *Node var v2 *Node - var ll *NodeList // Typechecking order is important here: // 0. first typecheck range expression (slice/map/chan), @@ -31,13 +29,13 @@ typecheck(&n.Right, Erv) - t = n.Right.Type + t := n.Right.Type if t == nil { goto out } // delicate little dance. see typecheckas2 - for ll = n.List; ll != nil; ll = ll.Next { + for ll := n.List; ll != nil; ll = ll.Next { if ll.N.Defn != n { typecheck(&ll.N, Erv|Easgn) } @@ -125,7 +123,7 @@ out: n.Typecheck = 1 - for ll = n.List; ll != nil; ll = ll.Next { + for ll := n.List; ll != nil; ll = ll.Next { if ll.N.Typecheck == 0 { typecheck(&ll.N, Erv|Easgn) } @@ -137,40 +135,17 @@ } func walkrange(n *Node) { - var ohv1 *Node - var hv1 *Node // hidden (old) val 1, 2 // hidden aggregate, iterator // hidden len, pointer // hidden bool // not hidden aggregate, val 1, 2 - var hv2 *Node - var ha *Node - var hit *Node - var hn *Node - var hp *Node - var hb *Node - var a *Node - var v1 *Node - var v2 *Node - var fn *Node - var tmp *Node - var keyname *Node - var valname *Node - var key *Node - var val *Node - var body *NodeList - var init *NodeList - var th *Type - var t *Type - var lno int + t := n.Type + init := (*NodeList)(nil) - t = n.Type - init = nil + a := n.Right + lno := int(setlineno(a)) - a = n.Right - lno = int(setlineno(a)) - - v1 = nil + v1 := (*Node)(nil) if n.List != nil { v1 = n.List.N } - v2 = nil + v2 := (*Node)(nil) if n.List != nil && n.List.Next != nil && !isblank(n.List.Next.N) { v2 = n.List.Next.N } @@ -179,8 +154,9 @@ // to avoid erroneous processing by racewalk. n.List = nil - hv2 = nil + hv2 := (*Node)(nil) + var body *NodeList switch t.Etype { default: Fatal("walkrange") @@ -202,7 +178,7 @@ if n.Nbody != nil { if n.Nbody.N != nil { // at least one statement in body if n.Nbody.Next == nil { // at most one statement in body - tmp = n.Nbody.N // first statement of body + tmp := n.Nbody.N // first statement of body if tmp.Op == OAS { if tmp.Left.Op == OINDEX { if samesafeexpr(tmp.Left.Left, a) { @@ -223,9 +199,9 @@ n.Nincr = nil // hp = &a[0] - hp = temp(Ptrto(Types[TUINT8])) + hp := temp(Ptrto(Types[TUINT8])) - tmp = Nod(OINDEX, a, Nodintconst(0)) + tmp := Nod(OINDEX, a, Nodintconst(0)) tmp.Bounded = true tmp = Nod(OADDR, tmp, nil) tmp = Nod(OCONVNOP, tmp, nil) @@ -233,7 +209,7 @@ n.Nbody = list(n.Nbody, Nod(OAS, hp, tmp)) // hn = len(a) * sizeof(elem(a)) - hn = temp(Types[TUINTPTR]) + hn := temp(Types[TUINTPTR]) tmp = Nod(OLEN, a, nil) tmp = Nod(OMUL, tmp, Nodintconst(t.Type.Width)) @@ -241,7 +217,7 @@ n.Nbody = list(n.Nbody, Nod(OAS, hn, tmp)) // memclr(hp, hn) - fn = mkcall("memclr", nil, nil, hp, hn) + fn := mkcall("memclr", nil, nil, hp, hn) n.Nbody = list(n.Nbody, fn) @@ -270,17 +246,17 @@ } // orderstmt arranged for a copy of the array/slice variable if needed. - ha = a + ha := a - hv1 = temp(Types[TINT]) - hn = temp(Types[TINT]) - hp = nil + hv1 := temp(Types[TINT]) + hn := temp(Types[TINT]) + hp := (*Node)(nil) init = list(init, Nod(OAS, hv1, nil)) init = list(init, Nod(OAS, hn, Nod(OLEN, ha, nil))) if v2 != nil { hp = temp(Ptrto(n.Type.Type)) - tmp = Nod(OINDEX, ha, Nodintconst(0)) + tmp := Nod(OINDEX, ha, Nodintconst(0)) tmp.Bounded = true init = list(init, Nod(OAS, hp, Nod(OADDR, tmp, nil))) } @@ -292,7 +268,7 @@ } else if v2 == nil { body = list1(Nod(OAS, v1, hv1)) } else { - a = Nod(OAS2, nil, nil) + a := Nod(OAS2, nil, nil) a.List = list(list1(v1), v2) a.Rlist = list(list1(hv1), Nod(OIND, hp, nil)) body = list1(a) @@ -305,7 +281,7 @@ // Advancing during the increment ensures that the pointer p only points // pass the end of the array during the final "p++; i++; if(i >= len(x)) break;", // after which p is dead, so it cannot confuse the collector. - tmp = Nod(OADD, hp, Nodintconst(t.Type.Width)) + tmp := Nod(OADD, hp, Nodintconst(t.Type.Width)) tmp.Type = hp.Type tmp.Typecheck = 1 @@ -319,16 +295,16 @@ // orderstmt allocated the iterator for us. // we only use a once, so no copy needed. case TMAP: - ha = a + ha := a - th = hiter(t) - hit = n.Alloc + th := hiter(t) + hit := n.Alloc hit.Type = th n.Left = nil - keyname = newname(th.Type.Sym) // depends on layout of iterator struct. See reflect.c:hiter - valname = newname(th.Type.Down.Sym) // ditto + keyname := newname(th.Type.Sym) // depends on layout of iterator struct. See reflect.c:hiter + valname := newname(th.Type.Down.Sym) // ditto - fn = syslook("mapiterinit", 1) + fn := syslook("mapiterinit", 1) argtype(fn, t.Down) argtype(fn, t.Type) @@ -340,16 +316,16 @@ argtype(fn, th) n.Nincr = mkcall1(fn, nil, nil, Nod(OADDR, hit, nil)) - key = Nod(ODOT, hit, keyname) + key := Nod(ODOT, hit, keyname) key = Nod(OIND, key, nil) if v1 == nil { body = nil } else if v2 == nil { body = list1(Nod(OAS, v1, key)) } else { - val = Nod(ODOT, hit, valname) + val := Nod(ODOT, hit, valname) val = Nod(OIND, val, nil) - a = Nod(OAS2, nil, nil) + a := Nod(OAS2, nil, nil) a.List = list(list1(v1), v2) a.Rlist = list(list1(key), val) body = list1(a) @@ -357,19 +333,19 @@ // orderstmt arranged for a copy of the channel variable. case TCHAN: - ha = a + ha := a n.Ntest = nil - hv1 = temp(t.Type) + hv1 := temp(t.Type) hv1.Typecheck = 1 if haspointers(t.Type) { init = list(init, Nod(OAS, hv1, nil)) } - hb = temp(Types[TBOOL]) + hb := temp(Types[TBOOL]) n.Ntest = Nod(ONE, hb, Nodbool(false)) - a = Nod(OAS2RECV, nil, nil) + a := Nod(OAS2RECV, nil, nil) a.Typecheck = 1 a.List = list(list1(hv1), hb) a.Rlist = list1(Nod(ORECV, ha, nil)) @@ -382,20 +358,21 @@ // orderstmt arranged for a copy of the string variable. case TSTRING: - ha = a + ha := a - ohv1 = temp(Types[TINT]) + ohv1 := temp(Types[TINT]) - hv1 = temp(Types[TINT]) + hv1 := temp(Types[TINT]) init = list(init, Nod(OAS, hv1, nil)) + var a *Node if v2 == nil { a = Nod(OAS, hv1, mkcall("stringiter", Types[TINT], nil, ha, hv1)) } else { hv2 = temp(runetype) a = Nod(OAS2, nil, nil) a.List = list(list1(hv1), hv2) - fn = syslook("stringiter2", 0) + fn := syslook("stringiter2", 0) a.Rlist = list1(mkcall1(fn, getoutargx(fn.Type), nil, ha, hv1)) }
diff --git a/src/cmd/internal/gc/reflect.go b/src/cmd/internal/gc/reflect.go index ee08040..6059e35 100644 --- a/src/cmd/internal/gc/reflect.go +++ b/src/cmd/internal/gc/reflect.go
@@ -15,9 +15,7 @@ var signatlist *NodeList func sigcmp(a *Sig, b *Sig) int { - var i int - - i = stringsCompare(a.name, b.name) + i := stringsCompare(a.name, b.name) if i != 0 { return i } @@ -34,16 +32,12 @@ } func lsort(l *Sig, f func(*Sig, *Sig) int) *Sig { - var l1 *Sig - var l2 *Sig - var le *Sig - if l == nil || l.link == nil { return l } - l1 = l - l2 = l + l1 := l + l2 := l for { l2 = l2.link if l2 == nil { @@ -70,7 +64,7 @@ l2 = l2.link } - le = l + le := l for { if l1 == nil { @@ -121,9 +115,7 @@ ) func makefield(name string, t *Type) *Type { - var f *Type - - f = typ(TFIELD) + f := typ(TFIELD) f.Type = t f.Sym = new(Sym) f.Sym.Name = name @@ -131,20 +123,13 @@ } func mapbucket(t *Type) *Type { - var keytype *Type - var valtype *Type - var bucket *Type - var arr *Type - var field [4]*Type - var n int32 - if t.Bucket != nil { return t.Bucket } - bucket = typ(TSTRUCT) - keytype = t.Down - valtype = t.Type + bucket := typ(TSTRUCT) + keytype := t.Down + valtype := t.Type dowidth(keytype) dowidth(valtype) if keytype.Width > MAXKEYSIZE { @@ -155,10 +140,11 @@ } // The first field is: uint8 topbits[BUCKETSIZE]. - arr = typ(TARRAY) + arr := typ(TARRAY) arr.Type = Types[TUINT8] arr.Bound = BUCKETSIZE + var field [4]*Type field[0] = makefield("topbits", arr) arr = typ(TARRAY) arr.Type = keytype @@ -175,7 +161,7 @@ bucket.Local = t.Local bucket.Type = field[0] - for n = 0; n < int32(len(field)-1); n++ { + for n := int32(0); n < int32(len(field)-1); n++ { field[n].Down = field[n+1] } field[len(field)-1].Down = nil @@ -201,16 +187,12 @@ // Builds a type representing a Hmap structure for the given map type. // Make sure this stays in sync with ../../runtime/hashmap.go! func hmap(t *Type) *Type { - var h *Type - var bucket *Type - var field [8]*Type - var n int32 - if t.Hmap != nil { return t.Hmap } - bucket = mapbucket(t) + bucket := mapbucket(t) + var field [8]*Type field[0] = makefield("count", Types[TINT]) field[1] = makefield("flags", Types[TUINT8]) field[2] = makefield("B", Types[TUINT8]) @@ -220,11 +202,11 @@ field[6] = makefield("nevacuate", Types[TUINTPTR]) field[7] = makefield("overflow", Types[TUNSAFEPTR]) - h = typ(TSTRUCT) + h := typ(TSTRUCT) h.Noalg = 1 h.Local = t.Local h.Type = field[0] - for n = 0; n < int32(len(field)-1); n++ { + for n := int32(0); n < int32(len(field)-1); n++ { field[n].Down = field[n+1] } field[len(field)-1].Down = nil @@ -235,10 +217,6 @@ } func hiter(t *Type) *Type { - var n int32 - var field [12]*Type - var i *Type - if t.Hiter != nil { return t.Hiter } @@ -259,6 +237,7 @@ // checkBucket uintptr // } // must match ../../runtime/hashmap.c:hash_iter. + var field [12]*Type field[0] = makefield("key", Ptrto(t.Down)) field[1] = makefield("val", Ptrto(t.Type)) @@ -274,11 +253,11 @@ field[11] = makefield("checkBucket", Types[TUINTPTR]) // build iterator struct holding the above fields - i = typ(TSTRUCT) + i := typ(TSTRUCT) i.Noalg = 1 i.Type = field[0] - for n = 0; n < int32(len(field)-1); n++ { + for n := int32(0); n < int32(len(field)-1); n++ { field[n].Down = field[n+1] } field[len(field)-1].Down = nil @@ -296,33 +275,29 @@ * return function type, receiver as first argument (or not). */ func methodfunc(f *Type, receiver *Type) *Type { - var in *NodeList - var out *NodeList - var d *Node - var t *Type - - in = nil + in := (*NodeList)(nil) if receiver != nil { - d = Nod(ODCLFIELD, nil, nil) + d := Nod(ODCLFIELD, nil, nil) d.Type = receiver in = list(in, d) } - for t = getinargx(f).Type; t != nil; t = t.Down { + var d *Node + for t := getinargx(f).Type; t != nil; t = t.Down { d = Nod(ODCLFIELD, nil, nil) d.Type = t.Type d.Isddd = t.Isddd in = list(in, d) } - out = nil - for t = getoutargx(f).Type; t != nil; t = t.Down { + out := (*NodeList)(nil) + for t := getoutargx(f).Type; t != nil; t = t.Down { d = Nod(ODCLFIELD, nil, nil) d.Type = t.Type out = list(out, d) } - t = functype(nil, in, out) + t := functype(nil, in, out) if f.Nname != nil { // Link to name of original method function. t.Nname = f.Nname @@ -336,16 +311,8 @@ * generates stub functions as needed. */ func methods(t *Type) *Sig { - var f *Type - var mt *Type - var it *Type - var this *Type - var a *Sig - var b *Sig - var method *Sym - // method type - mt = methtype(t, 0) + mt := methtype(t, 0) if mt == nil { return nil @@ -353,7 +320,7 @@ expandmeth(mt) // type stored in interface word - it = t + it := t if !isdirectiface(it) { it = Ptrto(t) @@ -361,9 +328,12 @@ // make list of methods for t, // generating code if necessary. - a = nil + a := (*Sig)(nil) - for f = mt.Xmethod; f != nil; f = f.Down { + var this *Type + var b *Sig + var method *Sym + for f := mt.Xmethod; f != nil; f = f.Down { if f.Etype != TFIELD { Fatal("methods: not field %v", Tconv(f, 0)) } @@ -439,15 +409,12 @@ */ func imethods(t *Type) *Sig { var a *Sig - var all *Sig - var last *Sig - var f *Type var method *Sym var isym *Sym - all = nil - last = nil - for f = t.Type; f != nil; f = f.Down { + all := (*Sig)(nil) + last := (*Sig)(nil) + for f := t.Type; f != nil; f = f.Down { if f.Etype != TFIELD { Fatal("imethods: not field") } @@ -501,9 +468,6 @@ var dimportpath_gopkg *Pkg func dimportpath(p *Pkg) { - var nam string - var n *Node - if p.Pathsym != nil { return } @@ -513,9 +477,9 @@ dimportpath_gopkg.Name = "go" } - nam = fmt.Sprintf("importpath.%s.", p.Prefix) + nam := fmt.Sprintf("importpath.%s.", p.Prefix) - n = Nod(ONAME, nil, nil) + n := Nod(ONAME, nil, nil) n.Sym = Pkglookup(nam, dimportpath_gopkg) n.Class = PEXTERN @@ -552,13 +516,7 @@ * ../../runtime/type.go:/uncommonType */ func dextratype(sym *Sym, off int, t *Type, ptroff int) int { - var ot int - var n int - var s *Sym - var a *Sig - var m *Sig - - m = methods(t) + m := methods(t) if t.Sym == nil && m == nil { return off } @@ -568,14 +526,14 @@ dsymptr(sym, ptroff, sym, off) - n = 0 - for a = m; a != nil; a = a.link { + n := 0 + for a := m; a != nil; a = a.link { dtypesym(a.type_) n++ } - ot = off - s = sym + ot := off + s := sym if t.Sym != nil { ot = dgostringptr(s, ot, t.Sym.Name) if t != Types[t.Etype] && t != errortype { @@ -595,7 +553,7 @@ ot = duintxx(s, ot, uint64(n), Widthint) // methods - for a = m; a != nil; a = a.link { + for a := m; a != nil; a = a.link { // method // ../../runtime/type.go:/method ot = dgostringptr(s, ot, a.name) @@ -648,13 +606,11 @@ } func haspointers(t *Type) bool { - var t1 *Type - var ret bool - if t.Haspointers != 0 { return t.Haspointers-1 != 0 } + var ret bool switch t.Etype { case TINT, TUINT, @@ -689,7 +645,7 @@ case TSTRUCT: ret = false - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if haspointers(t1.Type) { ret = true break @@ -721,36 +677,22 @@ var dcommontype_algarray *Sym func dcommontype(s *Sym, ot int, t *Type) int { - var i int - var alg int - var sizeofAlg int - var gcprog bool - var sptr *Sym - var algsym *Sym - var zero *Sym - var gcprog0 *Sym - var gcprog1 *Sym - var sbits *Sym - var gcmask [16]uint8 - var x1 uint64 - var x2 uint64 - var p string - if ot != 0 { Fatal("dcommontype %d", ot) } - sizeofAlg = 2 * Widthptr + sizeofAlg := 2 * Widthptr if dcommontype_algarray == nil { dcommontype_algarray = Pkglookup("algarray", Runtimepkg) } dowidth(t) - alg = algtype(t) - algsym = nil + alg := algtype(t) + algsym := (*Sym)(nil) if alg < 0 || alg == AMEM { algsym = dalgsym(t) } + var sptr *Sym if t.Sym != nil && Isptr[t.Etype] == 0 { sptr = dtypesym(Ptrto(t)) } else { @@ -762,7 +704,7 @@ // might be returned by a runtime call (map access return value, // 2-arg type cast) declares the size of the zerovalue it needs. // The linker magically takes the max of all the sizes. - zero = Pkglookup("zerovalue", Runtimepkg) + zero := Pkglookup("zerovalue", Runtimepkg) // We use size 0 here so we get the pointer to the zero value, // but don't allocate space for the zero value unless we need it. @@ -791,7 +733,7 @@ ot = duint8(s, ot, 0) // unused // runtime (and common sense) expects alignment to be a power of two. - i = int(t.Align) + i := int(t.Align) if i == 0 { i = 1 @@ -802,7 +744,7 @@ ot = duint8(s, ot, t.Align) // align ot = duint8(s, ot, t.Align) // fieldAlign - gcprog = usegcprog(t) + gcprog := usegcprog(t) i = kinds[t.Etype] if t.Etype == TARRAY && t.Bound < 0 { @@ -826,6 +768,8 @@ // gc if gcprog { + var gcprog1 *Sym + var gcprog0 *Sym gengcprog(t, &gcprog0, &gcprog1) if gcprog0 != nil { ot = dsymptr(s, ot, gcprog0, 0) @@ -834,25 +778,27 @@ } ot = dsymptr(s, ot, gcprog1, 0) } else { + var gcmask [16]uint8 gengcmask(t, gcmask[:]) - x1 = 0 - for i = 0; i < 8; i++ { + x1 := uint64(0) + for i := 0; i < 8; i++ { x1 = x1<<8 | uint64(gcmask[i]) } + var p string if Widthptr == 4 { p = fmt.Sprintf("gcbits.0x%016x", x1) } else { - x2 = 0 - for i = 0; i < 8; i++ { + x2 := uint64(0) + for i := 0; i < 8; i++ { x2 = x2<<8 | uint64(gcmask[i+8]) } p = fmt.Sprintf("gcbits.0x%016x%016x", x1, x2) } - sbits = Pkglookup(p, Runtimepkg) + sbits := Pkglookup(p, Runtimepkg) if sbits.Flags&SymUniq == 0 { sbits.Flags |= SymUniq - for i = 0; i < 2*Widthptr; i++ { + for i := 0; i < 2*Widthptr; i++ { duint8(sbits, i, gcmask[i]) } ggloblsym(sbits, 2*int32(Widthptr), obj.DUPOK|obj.RODATA) @@ -862,7 +808,7 @@ ot = duintptr(s, ot, 0) } - p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned)) + p := fmt.Sprintf("%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned)) //print("dcommontype: %s\n", p); ot = dgostringptr(s, ot, p) // string @@ -879,11 +825,8 @@ } func typesym(t *Type) *Sym { - var p string - var s *Sym - - p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft)) - s = Pkglookup(p, typepkg) + p := fmt.Sprintf("%v", Tconv(t, obj.FmtLeft)) + s := Pkglookup(p, typepkg) //print("typesym: %s -> %+S\n", p, s); @@ -891,19 +834,13 @@ } func tracksym(t *Type) *Sym { - var p string - var s *Sym - - p = fmt.Sprintf("%v.%s", Tconv(t.Outer, obj.FmtLeft), t.Sym.Name) - s = Pkglookup(p, trackpkg) + p := fmt.Sprintf("%v.%s", Tconv(t.Outer, obj.FmtLeft), t.Sym.Name) + s := Pkglookup(p, trackpkg) return s } func typelinksym(t *Type) *Sym { - var p string - var s *Sym - // %-uT is what the generated Type's string field says. // It uses (ambiguous) package names instead of import paths. // %-T is the complete, unambiguous type name. @@ -912,9 +849,9 @@ // disambiguate. The names are a little long but they are // discarded by the linker and do not end up in the symbol // table of the final binary. - p = fmt.Sprintf("%v/%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned), Tconv(t, obj.FmtLeft)) + p := fmt.Sprintf("%v/%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned), Tconv(t, obj.FmtLeft)) - s = Pkglookup(p, typelinkpkg) + s := Pkglookup(p, typelinkpkg) //print("typelinksym: %s -> %+S\n", p, s); @@ -922,11 +859,8 @@ } func typesymprefix(prefix string, t *Type) *Sym { - var p string - var s *Sym - - p = fmt.Sprintf("%s.%v", prefix, Tconv(t, obj.FmtLeft)) - s = Pkglookup(p, typepkg) + p := fmt.Sprintf("%s.%v", prefix, Tconv(t, obj.FmtLeft)) + s := Pkglookup(p, typepkg) //print("algsym: %s -> %+S\n", p, s); @@ -934,15 +868,12 @@ } func typenamesym(t *Type) *Sym { - var s *Sym - var n *Node - if t == nil || (Isptr[t.Etype] != 0 && t.Type == nil) || isideal(t) { Fatal("typename %v", Tconv(t, 0)) } - s = typesym(t) + s := typesym(t) if s.Def == nil { - n = Nod(ONAME, nil, nil) + n := Nod(ONAME, nil, nil) n.Sym = s n.Type = Types[TUINT8] n.Addable = 1 @@ -959,11 +890,8 @@ } func typename(t *Type) *Node { - var s *Sym - var n *Node - - s = typenamesym(t) - n = Nod(OADDR, s.Def, nil) + s := typenamesym(t) + n := Nod(OADDR, s.Def, nil) n.Type = Ptrto(s.Def.Type) n.Addable = 1 n.Ullman = 2 @@ -972,11 +900,8 @@ } func weaktypesym(t *Type) *Sym { - var p string - var s *Sym - - p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft)) - s = Pkglookup(p, weaktypepkg) + p := fmt.Sprintf("%v", Tconv(t, obj.FmtLeft)) + s := Pkglookup(p, weaktypepkg) //print("weaktypesym: %s -> %+S\n", p, s); @@ -988,7 +913,6 @@ * That is, if x==x for all x of type t. */ func isreflexive(t *Type) bool { - var t1 *Type switch t.Etype { case TBOOL, TINT, @@ -1023,7 +947,7 @@ return isreflexive(t.Type) case TSTRUCT: - for t1 = t.Type; t1 != nil; t1 = t1.Down { + for t1 := t.Type; t1 != nil; t1 = t1.Down { if !isreflexive(t1.Type) { return false } @@ -1038,22 +962,8 @@ } func dtypesym(t *Type) *Sym { - var ot int - var xt int var n int - var isddd int - var dupok int - var s *Sym - var s1 *Sym - var s2 *Sym - var s3 *Sym - var s4 *Sym - var slink *Sym - var a *Sig - var m *Sig var t1 *Type - var tbase *Type - var t2 *Type // Replace byte, rune aliases with real type. // They've been separate internally to make error messages @@ -1066,7 +976,7 @@ Fatal("dtypesym %v", Tconv(t, 0)) } - s = typesym(t) + s := typesym(t) if s.Flags&SymSiggen != 0 { return s } @@ -1075,12 +985,12 @@ // special case (look for runtime below): // when compiling package runtime, // emit the type structures for int, float, etc. - tbase = t + tbase := t if Isptr[t.Etype] != 0 && t.Sym == nil && t.Type.Sym != nil { tbase = t.Type } - dupok = 0 + dupok := 0 if tbase.Sym == nil { dupok = obj.DUPOK } @@ -1098,8 +1008,8 @@ } ok: - ot = 0 - xt = 0 + ot := 0 + xt := 0 switch t.Etype { default: ot = dcommontype(s, ot, t) @@ -1108,12 +1018,12 @@ case TARRAY: if t.Bound >= 0 { // ../../runtime/type.go:/ArrayType - s1 = dtypesym(t.Type) + s1 := dtypesym(t.Type) - t2 = typ(TARRAY) + t2 := typ(TARRAY) t2.Type = t.Type t2.Bound = -1 // slice - s2 = dtypesym(t2) + s2 := dtypesym(t2) ot = dcommontype(s, ot, t) xt = ot - 3*Widthptr ot = dsymptr(s, ot, s1, 0) @@ -1121,7 +1031,7 @@ ot = duintptr(s, ot, uint64(t.Bound)) } else { // ../../runtime/type.go:/SliceType - s1 = dtypesym(t.Type) + s1 := dtypesym(t.Type) ot = dcommontype(s, ot, t) xt = ot - 3*Widthptr @@ -1130,7 +1040,7 @@ // ../../runtime/type.go:/ChanType case TCHAN: - s1 = dtypesym(t.Type) + s1 := dtypesym(t.Type) ot = dcommontype(s, ot, t) xt = ot - 3*Widthptr @@ -1141,7 +1051,7 @@ for t1 = getthisx(t).Type; t1 != nil; t1 = t1.Down { dtypesym(t1.Type) } - isddd = 0 + isddd := 0 for t1 = getinargx(t).Type; t1 != nil; t1 = t1.Down { isddd = int(t1.Isddd) dtypesym(t1.Type) @@ -1178,9 +1088,9 @@ } case TINTER: - m = imethods(t) + m := imethods(t) n = 0 - for a = m; a != nil; a = a.link { + for a := m; a != nil; a = a.link { dtypesym(a.type_) n++ } @@ -1192,7 +1102,7 @@ ot = dsymptr(s, ot, s, ot+Widthptr+2*Widthint) ot = duintxx(s, ot, uint64(n), Widthint) ot = duintxx(s, ot, uint64(n), Widthint) - for a = m; a != nil; a = a.link { + for a := m; a != nil; a = a.link { // ../../runtime/type.go:/imethod ot = dgostringptr(s, ot, a.name) @@ -1202,11 +1112,11 @@ // ../../runtime/type.go:/MapType case TMAP: - s1 = dtypesym(t.Down) + s1 := dtypesym(t.Down) - s2 = dtypesym(t.Type) - s3 = dtypesym(mapbucket(t)) - s4 = dtypesym(hmap(t)) + s2 := dtypesym(t.Type) + s3 := dtypesym(mapbucket(t)) + s4 := dtypesym(hmap(t)) ot = dcommontype(s, ot, t) xt = ot - 3*Widthptr ot = dsymptr(s, ot, s1, 0) @@ -1242,7 +1152,7 @@ } // ../../runtime/type.go:/PtrType - s1 = dtypesym(t.Type) + s1 := dtypesym(t.Type) ot = dcommontype(s, ot, t) xt = ot - 3*Widthptr @@ -1300,7 +1210,7 @@ case TARRAY, TCHAN, TMAP: - slink = typelinksym(t) + slink := typelinksym(t) dsymptr(slink, 0, s, 0) ggloblsym(slink, int32(Widthptr), int8(dupok|obj.RODATA)) } @@ -1310,14 +1220,10 @@ } func dumptypestructs() { - var i int - var l *NodeList var n *Node - var t *Type - var p *Pkg // copy types from externdcl list to signatlist - for l = externdcl; l != nil; l = l.Next { + for l := externdcl; l != nil; l = l.Next { n = l.N if n.Op != OTYPE { continue @@ -1326,7 +1232,8 @@ } // process signatlist - for l = signatlist; l != nil; l = l.Next { + var t *Type + for l := signatlist; l != nil; l = l.Next { n = l.N if n.Op != OTYPE { continue @@ -1339,7 +1246,8 @@ } // generate import strings for imported packages - for i = 0; i < len(phash); i++ { + var p *Pkg + for i := 0; i < len(phash); i++ { for p = phash[i]; p != nil; p = p.Link { if p.Direct != 0 { dimportpath(p) @@ -1354,7 +1262,7 @@ // another possible choice would be package main, // but using runtime means fewer copies in .6 files. if compiling_runtime != 0 { - for i = 1; i <= TBOOL; i++ { + for i := 1; i <= TBOOL; i++ { dtypesym(Ptrto(Types[i])) } dtypesym(Ptrto(Types[TSTRING])) @@ -1377,20 +1285,16 @@ } func dalgsym(t *Type) *Sym { - var ot int var s *Sym - var hash *Sym var hashfunc *Sym - var eq *Sym var eqfunc *Sym - var p string // dalgsym is only called for a type that needs an algorithm table, // which implies that the type is comparable (or else it would use ANOEQ). if algtype(t) == AMEM { // we use one algorithm table for all AMEM types of a given size - p = fmt.Sprintf(".alg%d", t.Width) + p := fmt.Sprintf(".alg%d", t.Width) s = Pkglookup(p, typepkg) @@ -1404,7 +1308,7 @@ hashfunc = Pkglookup(p, typepkg) - ot = 0 + ot := 0 ot = dsymptr(hashfunc, ot, Pkglookup("memhash_varlen", Runtimepkg), 0) ot = duintxx(hashfunc, ot, uint64(t.Width), Widthptr) // size encoded in closure ggloblsym(hashfunc, int32(ot), obj.DUPOK|obj.RODATA) @@ -1422,8 +1326,8 @@ // generate an alg table specific to this type s = typesymprefix(".alg", t) - hash = typesymprefix(".hash", t) - eq = typesymprefix(".eq", t) + hash := typesymprefix(".hash", t) + eq := typesymprefix(".eq", t) hashfunc = typesymprefix(".hashfunc", t) eqfunc = typesymprefix(".eqfunc", t) @@ -1439,7 +1343,7 @@ } // ../../runtime/alg.go:/typeAlg - ot = 0 + ot := 0 ot = dsymptr(s, ot, hashfunc, 0) ot = dsymptr(s, ot, eqfunc, 0) @@ -1448,9 +1352,6 @@ } func usegcprog(t *Type) bool { - var size int64 - var nptr int64 - if !haspointers(t) { return false } @@ -1459,9 +1360,9 @@ } // Calculate size of the unrolled GC mask. - nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr) + nptr := (t.Width + int64(Widthptr) - 1) / int64(Widthptr) - size = nptr + size := nptr if size%2 != 0 { size *= 2 // repeated } @@ -1478,16 +1379,7 @@ // Generates sparse GC bitmask (4 bits per word). func gengcmask(t *Type, gcmask []byte) { - var vec *Bvec - var xoffset int64 - var nptr int64 - var i int64 - var j int64 - var half bool - var bits uint8 - var pos []byte - - for i = 0; i < 16; i++ { + for i := int64(0); i < 16; i++ { gcmask[i] = 0 } if !haspointers(t) { @@ -1495,21 +1387,23 @@ } // Generate compact mask as stacks use. - xoffset = 0 + xoffset := int64(0) - vec = bvalloc(2 * int32(Widthptr) * 8) + vec := bvalloc(2 * int32(Widthptr) * 8) twobitwalktype1(t, &xoffset, vec) // Unfold the mask for the GC bitmap format: // 4 bits per word, 2 high bits encode pointer info. - pos = gcmask + pos := gcmask - nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr) - half = false + nptr := (t.Width + int64(Widthptr) - 1) / int64(Widthptr) + half := false // If number of words is odd, repeat the mask. // This makes simpler handling of arrays in runtime. - for j = 0; j <= (nptr % 2); j++ { + var i int64 + var bits uint8 + for j := int64(0); j <= (nptr % 2); j++ { for i = 0; i < nptr; i++ { bits = uint8(bvget(vec, int32(i*obj.BitsPerPointer)) | bvget(vec, int32(i*obj.BitsPerPointer+1))<<1) @@ -1553,16 +1447,13 @@ // Emits insData block from g->data. func proggendataflush(g *ProgGen) { - var i int32 - var s int32 - if g.datasize == 0 { return } proggenemit(g, obj.InsData) proggenemit(g, uint8(g.datasize)) - s = (g.datasize + obj.PointersPerByte - 1) / obj.PointersPerByte - for i = 0; i < s; i++ { + s := (g.datasize + obj.PointersPerByte - 1) / obj.PointersPerByte + for i := int32(0); i < s; i++ { proggenemit(g, g.data[i]) } g.datasize = 0 @@ -1579,9 +1470,7 @@ // Skip v bytes due to alignment, etc. func proggenskip(g *ProgGen, off int64, v int64) { - var i int64 - - for i = off; i < off+v; i++ { + for i := off; i < off+v; i++ { if (i % int64(Widthptr)) == 0 { proggendata(g, obj.BitsScalar) } @@ -1612,16 +1501,8 @@ // Generates GC program for large types. func gengcprog(t *Type, pgc0 **Sym, pgc1 **Sym) { - var gc0 *Sym - var gc1 *Sym - var nptr int64 - var size int64 - var ot int64 - var xoffset int64 - var g ProgGen - - nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr) - size = nptr + nptr := (t.Width + int64(Widthptr) - 1) / int64(Widthptr) + size := nptr if size%2 != 0 { size *= 2 // repeated twice } @@ -1633,30 +1514,25 @@ // Don't generate it if it's too large, runtime will unroll directly into GC bitmap. if size <= obj.MaxGCMask { - gc0 = typesymprefix(".gc", t) + gc0 := typesymprefix(".gc", t) ggloblsym(gc0, int32(size), obj.DUPOK|obj.NOPTR) *pgc0 = gc0 } // program in RODATA - gc1 = typesymprefix(".gcprog", t) + gc1 := typesymprefix(".gcprog", t) + var g ProgGen proggeninit(&g, gc1) - xoffset = 0 + xoffset := int64(0) gengcprog1(&g, t, &xoffset) - ot = proggenfini(&g) + ot := proggenfini(&g) ggloblsym(gc1, int32(ot), obj.DUPOK|obj.RODATA) *pgc1 = gc1 } // Recursively walks type t and writes GC program into g. func gengcprog1(g *ProgGen, t *Type, xoffset *int64) { - var fieldoffset int64 - var i int64 - var o int64 - var n int64 - var t1 *Type - switch t.Etype { case TINT8, TUINT8, @@ -1704,16 +1580,16 @@ proggendata(g, obj.BitsScalar) proggendata(g, obj.BitsScalar) } else { - t1 = t.Type + t1 := t.Type if t1.Width == 0 { } // ignore if t.Bound <= 1 || t.Bound*t1.Width < int64(32*Widthptr) { - for i = 0; i < t.Bound; i++ { + for i := int64(0); i < t.Bound; i++ { gengcprog1(g, t1, xoffset) } } else if !haspointers(t1) { - n = t.Width + n := t.Width n -= -*xoffset & (int64(Widthptr) - 1) // skip to next ptr boundary proggenarray(g, (n+int64(Widthptr)-1)/int64(Widthptr)) proggendata(g, obj.BitsScalar) @@ -1728,8 +1604,9 @@ } case TSTRUCT: - o = 0 - for t1 = t.Type; t1 != nil; t1 = t1.Down { + o := int64(0) + var fieldoffset int64 + for t1 := t.Type; t1 != nil; t1 = t1.Down { fieldoffset = t1.Width proggenskip(g, *xoffset, fieldoffset-o) *xoffset += fieldoffset - o
diff --git a/src/cmd/internal/gc/reg.go b/src/cmd/internal/gc/reg.go index 37a394c..42a65da 100644 --- a/src/cmd/internal/gc/reg.go +++ b/src/cmd/internal/gc/reg.go
@@ -51,11 +51,8 @@ } func (x rcmp) Less(i, j int) bool { - var p1 *Rgn - var p2 *Rgn - - p1 = &x[i] - p2 = &x[j] + p1 := &x[i] + p2 := &x[j] if p1.cost != p2.cost { return int(p2.cost)-int(p1.cost) < 0 } @@ -96,7 +93,6 @@ func walkvardef(n *Node, f *Flow, active int) { var f1 *Flow - var f2 *Flow var bn int var v *Var @@ -118,7 +114,7 @@ } } - for f2 = f; f2 != f1; f2 = f2.S1 { + for f2 := f; f2 != f1; f2 = f2.S1 { if f2.S2 != nil { walkvardef(n, f2.S2, active) } @@ -130,23 +126,18 @@ * just after r */ func addmove(r *Flow, bn int, rn int, f int) { - var p *obj.Prog - var p1 *obj.Prog - var a *obj.Addr - var v *Var - - p1 = Ctxt.NewProg() + p1 := Ctxt.NewProg() Clearp(p1) p1.Pc = 9999 - p = r.Prog + p := r.Prog p1.Link = p.Link p.Link = p1 p1.Lineno = p.Lineno - v = &var_[bn:][0] + v := &var_[bn:][0] - a = &p1.To + a := &p1.To a.Offset = v.offset a.Etype = uint8(v.etype) a.Type = obj.TYPE_MEM @@ -183,11 +174,8 @@ } func overlap_reg(o1 int64, w1 int, o2 int64, w2 int) bool { - var t1 int64 - var t2 int64 - - t1 = o1 + int64(w1) - t2 = o2 + int64(w2) + t1 := o1 + int64(w1) + t2 := o2 + int64(w2) if t1 <= o2 || t2 <= o1 { return false @@ -201,10 +189,8 @@ var i int var n int var et int - var z int var flag int var w int64 - var regu uint64 var o int64 var bit Bits var node *Node @@ -222,16 +208,17 @@ switch a.Type { default: - regu = Thearch.Doregbits(int(a.Reg)) | Thearch.RtoB(int(a.Reg)) // TODO: Use RtoB + regu := Thearch.Doregbits(int(a.Reg)) | Thearch.RtoB(int(a.Reg)) // TODO: Use RtoB if regu == 0 { goto none } - bit = zbits + bit := zbits bit.b[0] = regu return bit // TODO(rsc): Remove special case here. case obj.TYPE_ADDR: + var bit Bits if Thearch.Thechar == '9' || Thearch.Thechar == '5' { goto memcase } @@ -285,7 +272,7 @@ } flag = 0 - for i = 0; i < nvar; i++ { + for i := 0; i < nvar; i++ { v = &var_[i:][0] if v.node == node && int(v.name) == n { if v.offset == o { @@ -324,7 +311,8 @@ // having its address taken, so that we keep the whole thing // live at all calls. otherwise we might optimize away part of // a variable but not all of it. - for i = 0; i < nvar; i++ { + var v *Var + for i := 0; i < nvar; i++ { v = &var_[i:][0] if v.node == node { v.addr = 1 @@ -355,23 +343,23 @@ bit = blsh(uint(i)) if n == obj.NAME_EXTERN || n == obj.NAME_STATIC { - for z = 0; z < BITS; z++ { + for z := 0; z < BITS; z++ { externs.b[z] |= bit.b[z] } } if n == obj.NAME_PARAM { - for z = 0; z < BITS; z++ { + for z := 0; z < BITS; z++ { params.b[z] |= bit.b[z] } } if node.Class == PPARAM { - for z = 0; z < BITS; z++ { + for z := 0; z < BITS; z++ { ivar.b[z] |= bit.b[z] } } if node.Class == PPARAMOUT { - for z = 0; z < BITS; z++ { + for z := 0; z < BITS; z++ { ovar.b[z] |= bit.b[z] } } @@ -420,8 +408,6 @@ func prop(f *Flow, ref Bits, cal Bits) { var f1 *Flow - var f2 *Flow - var r *Reg var r1 *Reg var z int var i int @@ -533,6 +519,8 @@ f1.Active = 1 } + var r *Reg + var f2 *Flow for ; f != f1; f = f.P1 { r = f.Data.(*Reg) for f2 = f.P2; f2 != nil; f2 = f2.P2link { @@ -542,11 +530,10 @@ } func synch(f *Flow, dif Bits) { - var f1 *Flow var r1 *Reg var z int - for f1 = f; f1 != nil; f1 = f1.S1 { + for f1 := f; f1 != nil; f1 = f1.S1 { r1 = f1.Data.(*Reg) for z = 0; z < BITS; z++ { dif.b[z] = dif.b[z]&^(^r1.refbehind.b[z]&r1.refahead.b[z]) | r1.set.b[z] | r1.regdiff.b[z] @@ -570,10 +557,7 @@ } func allreg(b uint64, r *Rgn) uint64 { - var v *Var - var i int - - v = &var_[r.varno:][0] + v := &var_[r.varno:][0] r.regno = 0 switch v.etype { default: @@ -593,7 +577,7 @@ TBOOL, TPTR32, TPTR64: - i = Thearch.BtoR(^b) + i := Thearch.BtoR(^b) if i != 0 && r.cost > 0 { r.regno = int16(i) return Thearch.RtoB(i) @@ -601,7 +585,7 @@ case TFLOAT32, TFLOAT64: - i = Thearch.BtoF(^b) + i := Thearch.BtoF(^b) if i != 0 && r.cost > 0 { r.regno = int16(i) return Thearch.FtoB(i) @@ -620,18 +604,14 @@ } func paint1(f *Flow, bn int) { - var f1 *Flow - var r *Reg - var r1 *Reg - var z int - var bb uint64 - - z = bn / 64 - bb = 1 << uint(bn%64) - r = f.Data.(*Reg) + z := bn / 64 + bb := uint64(1 << uint(bn%64)) + r := f.Data.(*Reg) if r.act.b[z]&bb != 0 { return } + var f1 *Flow + var r1 *Reg for { if r.refbehind.b[z]&bb == 0 { break @@ -703,20 +683,15 @@ } func paint2(f *Flow, bn int, depth int) uint64 { - var f1 *Flow - var r *Reg - var r1 *Reg - var z int - var bb uint64 - var vreg uint64 - - z = bn / 64 - bb = 1 << uint(bn%64) - vreg = regbits - r = f.Data.(*Reg) + z := bn / 64 + bb := uint64(1 << uint(bn%64)) + vreg := regbits + r := f.Data.(*Reg) if r.act.b[z]&bb == 0 { return vreg } + var r1 *Reg + var f1 *Flow for { if r.refbehind.b[z]&bb == 0 { break @@ -779,19 +754,14 @@ } func paint3(f *Flow, bn int, rb uint64, rn int) { - var f1 *Flow - var r *Reg - var r1 *Reg - var p *obj.Prog - var z int - var bb uint64 - - z = bn / 64 - bb = 1 << uint(bn%64) - r = f.Data.(*Reg) + z := bn / 64 + bb := uint64(1 << uint(bn%64)) + r := f.Data.(*Reg) if r.act.b[z]&bb != 0 { return } + var r1 *Reg + var f1 *Flow for { if r.refbehind.b[z]&bb == 0 { break @@ -814,6 +784,7 @@ if LOAD(r, z)&^(r.set.b[z]&^(r.use1.b[z]|r.use2.b[z]))&bb != 0 { addmove(f, bn, rn, 0) } + var p *obj.Prog for { r.act.b[z] |= bb p = f.Prog @@ -886,14 +857,11 @@ } func dumpone(f *Flow, isreg int) { - var z int - var bit Bits - var r *Reg - fmt.Printf("%d:%v", f.Loop, f.Prog) if isreg != 0 { - r = f.Data.(*Reg) - for z = 0; z < BITS; z++ { + r := f.Data.(*Reg) + var bit Bits + for z := 0; z < BITS; z++ { bit.b[z] = r.set.b[z] | r.use1.b[z] | r.use2.b[z] | r.refbehind.b[z] | r.refahead.b[z] | r.calbehind.b[z] | r.calahead.b[z] | r.regdiff.b[z] | r.act.b[z] | 0 } if bany(&bit) { @@ -932,11 +900,10 @@ } func Dumpit(str string, r0 *Flow, isreg int) { - var r *Flow var r1 *Flow fmt.Printf("\n%s\n", str) - for r = r0; r != nil; r = r.Link { + for r := r0; r != nil; r = r.Link { dumpone(r, isreg) r1 = r.P2 if r1 != nil { @@ -967,23 +934,6 @@ } func regopt(firstp *obj.Prog) { - var f *Flow - var f1 *Flow - var r *Reg - var p *obj.Prog - var g *Graph - var info ProgInfo - var i int - var z int - var active int - var vreg uint64 - var usedreg uint64 - var mask uint64 - var nreg int - var regnames []string - var bit Bits - var rgp *Rgn - if first != 0 { first = 0 } @@ -995,13 +945,14 @@ * than in generated c code. define pseudo-variables for * registers, so we have complete register usage information. */ - regnames = Thearch.Regnames(&nreg) + var nreg int + regnames := Thearch.Regnames(&nreg) nvar = nreg - for i = 0; i < nreg; i++ { + for i := 0; i < nreg; i++ { var_[i] = Var{} } - for i = 0; i < nreg; i++ { + for i := 0; i < nreg; i++ { if regnodes[i] == nil { regnodes[i] = newname(Lookup(regnames[i])) } @@ -1022,10 +973,10 @@ * allocate pcs * find use and set of variables */ - g = Flowstart(firstp, func() interface{} { return new(Reg) }) + g := Flowstart(firstp, func() interface{} { return new(Reg) }) if g == nil { - for i = 0; i < nvar; i++ { + for i := 0; i < nvar; i++ { var_[i].node.Opt = nil } return @@ -1033,7 +984,12 @@ firstf = g.Start - for f = firstf; f != nil; f = f.Link { + var r *Reg + var info ProgInfo + var p *obj.Prog + var bit Bits + var z int + for f := firstf; f != nil; f = f.Link { p = f.Prog if p.As == obj.AVARDEF || p.As == obj.AVARKILL { continue @@ -1097,9 +1053,8 @@ } } - for i = 0; i < nvar; i++ { - var v *Var - v = &var_[i:][0] + for i := 0; i < nvar; i++ { + v := &var_[i:][0] if v.addr != 0 { bit = blsh(uint(i)) for z = 0; z < BITS; z++ { @@ -1133,15 +1088,15 @@ * (r->act will be reused in pass 5 for something else, * but we'll be done with it by then.) */ - active = 0 + active := 0 - for f = firstf; f != nil; f = f.Link { + for f := firstf; f != nil; f = f.Link { f.Active = 0 r = f.Data.(*Reg) r.act = zbits } - for f = firstf; f != nil; f = f.Link { + for f := firstf; f != nil; f = f.Link { p = f.Prog if p.As == obj.AVARDEF && Isfat(((p.To.Node).(*Node)).Type) && ((p.To.Node).(*Node)).Opt != nil { active++ @@ -1154,6 +1109,9 @@ * iterate propagating usage * back until flow graph is complete */ + var f1 *Flow + var i int + var f *Flow loop1: change = 0 @@ -1213,8 +1171,8 @@ * pass 4.5 * move register pseudo-variables into regu. */ - mask = (1 << uint(nreg)) - 1 - for f = firstf; f != nil; f = f.Link { + mask := uint64((1 << uint(nreg)) - 1) + for f := firstf; f != nil; f = f.Link { r = f.Data.(*Reg) r.regu = (r.refbehind.b[0] | r.set.b[0]) & mask r.set.b[0] &^= mask @@ -1240,8 +1198,8 @@ f = firstf if f != nil { - r = f.Data.(*Reg) - for z = 0; z < BITS; z++ { + r := f.Data.(*Reg) + for z := 0; z < BITS; z++ { bit.b[z] = (r.refahead.b[z] | r.calahead.b[z]) &^ (externs.b[z] | params.b[z] | addrs.b[z] | consts.b[z]) } if bany(&bit) && f.Refset == 0 { @@ -1253,11 +1211,12 @@ } } - for f = firstf; f != nil; f = f.Link { + for f := firstf; f != nil; f = f.Link { (f.Data.(*Reg)).act = zbits } nregion = 0 - for f = firstf; f != nil; f = f.Link { + var rgp *Rgn + for f := firstf; f != nil; f = f.Link { r = f.Data.(*Reg) for z = 0; z < BITS; z++ { bit.b[z] = r.set.b[z] &^ (r.refahead.b[z] | r.calahead.b[z] | addrs.b[z]) @@ -1311,7 +1270,9 @@ if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("\nregisterizing\n") } - for i = 0; i < nregion; i++ { + var usedreg uint64 + var vreg uint64 + for i := 0; i < nregion; i++ { rgp = ®ion[i] if Debug['R'] != 0 && Debug['v'] != 0 { fmt.Printf("region %d: cost %d varno %d enter %d\n", i, rgp.cost, rgp.varno, rgp.enter.Prog.Pc) @@ -1321,9 +1282,7 @@ vreg = allreg(usedreg, rgp) if rgp.regno != 0 { if Debug['R'] != 0 && Debug['v'] != 0 { - var v *Var - - v = &var_[rgp.varno:][0] + v := &var_[rgp.varno:][0] fmt.Printf("registerize %v+%d (bit=%2d et=%v) in %v usedreg=%#x vreg=%#x\n", Nconv(v.node, 0), v.offset, rgp.varno, Econv(int(v.etype), 0), Ctxt.Rconv(int(rgp.regno)), usedreg, vreg) } @@ -1334,7 +1293,7 @@ /* * free aux structures. peep allocates new ones. */ - for i = 0; i < nvar; i++ { + for i := 0; i < nvar; i++ { var_[i].node.Opt = nil } Flowend(g) @@ -1342,7 +1301,7 @@ if Debug['R'] != 0 && Debug['v'] != 0 { // Rebuild flow graph, since we inserted instructions - g = Flowstart(firstp, nil) + g := Flowstart(firstp, nil) firstf = g.Start Dumpit("pass6", firstf, 0) @@ -1361,7 +1320,7 @@ /* * eliminate nops */ - for p = firstp; p != nil; p = p.Link { + for p := firstp; p != nil; p = p.Link { for p.Link != nil && p.Link.As == obj.ANOP { p.Link = p.Link.Link }
diff --git a/src/cmd/internal/gc/select.go b/src/cmd/internal/gc/select.go index ab7a144..ca6a21d 100644 --- a/src/cmd/internal/gc/select.go +++ b/src/cmd/internal/gc/select.go
@@ -10,16 +10,12 @@ func typecheckselect(sel *Node) { var ncase *Node var n *Node - var def *Node - var l *NodeList - var lno int - var count int - def = nil - lno = int(setlineno(sel)) - count = 0 + def := (*Node)(nil) + lno := int(setlineno(sel)) + count := 0 typechecklist(sel.Ninit, Etop) - for l = sel.List; l != nil; l = l.Next { + for l := sel.List; l != nil; l = l.Next { count++ ncase = l.N setlineno(ncase) @@ -94,27 +90,20 @@ } func walkselect(sel *Node) { - var lno int - var i int - var n *Node - var r *Node - var a *Node - var var_ *Node - var selv *Node - var cas *Node - var dflt *Node - var ch *Node - var l *NodeList - var init *NodeList - if sel.List == nil && sel.Xoffset != 0 { Fatal("double walkselect") // already rewrote } - lno = int(setlineno(sel)) - i = count(sel.List) + lno := int(setlineno(sel)) + i := count(sel.List) // optimization: zero-case select + var init *NodeList + var r *Node + var n *Node + var var_ *Node + var selv *Node + var cas *Node if i == 0 { sel.Nbody = list1(mkcall("block", nil, nil)) goto out @@ -124,13 +113,14 @@ // TODO(rsc): Reenable optimization once order.c can handle it. // golang.org/issue/7672. if i == 1 { - cas = sel.List.N + cas := sel.List.N setlineno(cas) - l = cas.Ninit + l := cas.Ninit if cas.Left != nil { // not default: - n = cas.Left + n := cas.Left l = concat(l, n.Ninit) n.Ninit = nil + var ch *Node switch n.Op { default: Fatal("select %v", Oconv(int(n.Op), 0)) @@ -167,7 +157,7 @@ } // if ch == nil { block() }; n; - a = Nod(OIF, nil, nil) + a := Nod(OIF, nil, nil) a.Ntest = Nod(OEQ, ch, nodnil()) a.Nbody = list1(mkcall("block", nil, &l)) @@ -183,7 +173,7 @@ // convert case value arguments to addresses. // this rewrite is used by both the general code and the next optimization. - for l = sel.List; l != nil; l = l.Next { + for l := sel.List; l != nil; l = l.Next { cas = l.N setlineno(cas) n = cas.Left @@ -216,6 +206,8 @@ // optimization: two-case select but one is default: single non-blocking op. if i == 2 && (sel.List.N.Left == nil || sel.List.Next.N.Left == nil) { + var cas *Node + var dflt *Node if sel.List.N.Left == nil { cas = sel.List.Next.N dflt = sel.List.N @@ -224,9 +216,9 @@ cas = sel.List.N } - n = cas.Left + n := cas.Left setlineno(n) - r = Nod(OIF, nil, nil) + r := Nod(OIF, nil, nil) r.Ninit = cas.Ninit switch n.Op { default: @@ -234,7 +226,7 @@ // if selectnbsend(c, v) { body } else { default body } case OSEND: - ch = n.Left + ch := n.Left r.Ntest = mkcall1(chanfn("selectnbsend", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), ch, n.Right) @@ -243,7 +235,7 @@ r = Nod(OIF, nil, nil) r.Ninit = cas.Ninit - ch = n.Right.Left + ch := n.Right.Left r.Ntest = mkcall1(chanfn("selectnbrecv", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, ch) // if c != nil && selectnbrecv2(&v, c) { body } else { default body } @@ -251,7 +243,7 @@ r = Nod(OIF, nil, nil) r.Ninit = cas.Ninit - ch = n.Right.Left + ch := n.Right.Left r.Ntest = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, n.Ntest, ch) } @@ -278,7 +270,7 @@ init = list(init, r) // register cases - for l = sel.List; l != nil; l = l.Next { + for l := sel.List; l != nil; l = l.Next { cas = l.N setlineno(cas) n = cas.Left @@ -334,14 +326,9 @@ // Keep in sync with src/runtime/chan.h. func selecttype(size int32) *Type { - var sel *Node - var sudog *Node - var scase *Node - var arr *Node - // TODO(dvyukov): it's possible to generate SudoG and Scase only once // and then cache; and also cache Select per size. - sudog = Nod(OTSTRUCT, nil, nil) + sudog := Nod(OTSTRUCT, nil, nil) sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("g")), typenod(Ptrto(Types[TUINT8])))) sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("selectdone")), typenod(Ptrto(Types[TUINT8])))) @@ -355,7 +342,7 @@ sudog.Type.Noalg = 1 sudog.Type.Local = 1 - scase = Nod(OTSTRUCT, nil, nil) + scase := Nod(OTSTRUCT, nil, nil) scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8])))) scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("chan")), typenod(Ptrto(Types[TUINT8])))) scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("pc")), typenod(Types[TUINTPTR]))) @@ -367,12 +354,12 @@ scase.Type.Noalg = 1 scase.Type.Local = 1 - sel = Nod(OTSTRUCT, nil, nil) + sel := Nod(OTSTRUCT, nil, nil) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("tcase")), typenod(Types[TUINT16]))) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("ncase")), typenod(Types[TUINT16]))) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("pollorder")), typenod(Ptrto(Types[TUINT8])))) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("lockorder")), typenod(Ptrto(Types[TUINT8])))) - arr = Nod(OTARRAY, Nodintconst(int64(size)), scase) + arr := Nod(OTARRAY, Nodintconst(int64(size)), scase) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("scase")), arr)) arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Ptrto(Types[TUINT8]))) sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("lockorderarr")), arr))
diff --git a/src/cmd/internal/gc/sinit.go b/src/cmd/internal/gc/sinit.go index 57422b4..ca8db418 100644 --- a/src/cmd/internal/gc/sinit.go +++ b/src/cmd/internal/gc/sinit.go
@@ -23,15 +23,12 @@ // init1 walks the AST starting at n, and accumulates in out // the list of definitions needing init code in dependency order. func init1(n *Node, out **NodeList) { - var l *NodeList - var nv *Node - if n == nil { return } init1(n.Left, out) init1(n.Right, out) - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { init1(l.N, out) } @@ -72,12 +69,13 @@ // Conversely, if there exists an initialization cycle involving // a variable in the program, the tree walk will reach a cycle // involving that variable. + var nv *Node if n.Class != PFUNC { nv = n goto foundinitloop } - for l = initlist; l.N != n; l = l.Next { + for l := initlist; l.N != n; l = l.Next { if l.N.Class != PFUNC { nv = l.N goto foundinitloop @@ -103,13 +101,14 @@ fmt.Printf("%v: initialization loop:\n", nv.Line()) // Build back pointers in initlist. - for l = initlist; l != nil; l = l.Next { + for l := initlist; l != nil; l = l.Next { if l.Next != nil { l.Next.End = l } } // Print nv -> ... -> n1 -> n. + var l *NodeList for l = initlist; l.N != nv; l = l.Next { } for ; l != nil; l = l.End { @@ -129,7 +128,7 @@ // reached a new unvisited node. n.Initorder = InitPending - l = new(NodeList) + l := new(NodeList) if l == nil { Flusherrors() Yyerror("out of memory") @@ -181,7 +180,7 @@ break } n.Defn.Initorder = InitDone - for l = n.Defn.Rlist; l != nil; l = l.Next { + for l := n.Defn.Rlist; l != nil; l = l.Next { init1(l.N, out) } if Debug['%'] != 0 { @@ -261,11 +260,8 @@ // declarations and outputs the corresponding list of statements // to include in the init() function body. func initfix(l *NodeList) *NodeList { - var lout *NodeList - var lno int - - lout = nil - lno = int(lineno) + lout := (*NodeList)(nil) + lno := int(lineno) initreorder(l, &lout) lineno = int32(lno) return lout @@ -276,31 +272,19 @@ * into DATA statements if at all possible. */ func staticinit(n *Node, out **NodeList) bool { - var l *Node - var r *Node - if n.Op != ONAME || n.Class != PEXTERN || n.Defn == nil || n.Defn.Op != OAS { Fatal("staticinit") } lineno = n.Lineno - l = n.Defn.Left - r = n.Defn.Right + l := n.Defn.Left + r := n.Defn.Right return staticassign(l, r, out) } // like staticassign but we are copying an already // initialized value r. func staticcopy(l *Node, r *Node, out **NodeList) bool { - var i int - var e *InitEntry - var p *InitPlan - var a *Node - var ll *Node - var rr *Node - var orig *Node - var n1 Node - if r.Op != ONAME || r.Class != PEXTERN || r.Sym.Pkg != localpkg { return false } @@ -310,7 +294,7 @@ if r.Defn.Op != OAS { return false } - orig = r + orig := r r = r.Defn.Right switch r.Op { @@ -353,9 +337,9 @@ case OARRAYLIT: if Isslice(r.Type) { // copy slice - a = r.Nname + a := r.Nname - n1 = *l + n1 := *l n1.Xoffset = l.Xoffset + int64(Array_array) gdata(&n1, Nod(OADDR, a, nil), Widthptr) n1.Xoffset = l.Xoffset + int64(Array_nel) @@ -368,10 +352,13 @@ // fall through case OSTRUCTLIT: - p = r.Initplan + p := r.Initplan - n1 = *l - for i = 0; i < len(p.E); i++ { + n1 := *l + var e *InitEntry + var ll *Node + var rr *Node + for i := 0; i < len(p.E); i++ { e = &p.E[i] n1.Xoffset = l.Xoffset + e.Xoffset n1.Type = e.Expr.Type @@ -402,14 +389,7 @@ } func staticassign(l *Node, r *Node, out **NodeList) bool { - var a *Node var n1 Node - var nam Node - var ta *Type - var p *InitPlan - var e *InitEntry - var i int - var sval *Strlit switch r.Op { //dump("not static", r); @@ -429,8 +409,9 @@ return true case OADDR: + var nam Node if stataddr(&nam, r.Left) { - n1 = *r + n1 := *r n1.Left = &nam gdata(l, &n1, int(l.Type.Width)) return true @@ -447,7 +428,7 @@ case OARRAYLIT, OMAPLIT, OSTRUCTLIT: - a = staticname(r.Left.Type, 1) + a := staticname(r.Left.Type, 1) r.Nname = a gdata(l, Nod(OADDR, a, nil), int(l.Type.Width)) @@ -461,7 +442,7 @@ case OSTRARRAYBYTE: if l.Class == PEXTERN && r.Left.Op == OLITERAL { - sval = r.Left.Val.U.Sval + sval := r.Left.Val.U.Sval slicebytes(l, sval.S, len(sval.S)) return true } @@ -470,11 +451,11 @@ initplan(r) if Isslice(r.Type) { // Init slice. - ta = typ(TARRAY) + ta := typ(TARRAY) ta.Type = r.Type.Type ta.Bound = Mpgetfix(r.Right.Val.U.Xval) - a = staticname(ta, 1) + a := staticname(ta, 1) r.Nname = a n1 = *l n1.Xoffset = l.Xoffset + int64(Array_array) @@ -493,9 +474,11 @@ case OSTRUCTLIT: initplan(r) - p = r.Initplan + p := r.Initplan n1 = *l - for i = 0; i < len(p.E); i++ { + var e *InitEntry + var a *Node + for i := 0; i < len(p.E); i++ { e = &p.E[i] n1.Xoffset = l.Xoffset + e.Xoffset n1.Type = e.Expr.Type @@ -529,11 +512,9 @@ * part of the composite literal. */ func staticname(t *Type, ctxt int) *Node { - var n *Node - namebuf = fmt.Sprintf("statictmp_%.4d", statuniqgen) statuniqgen++ - n = newname(Lookup(namebuf)) + n := newname(Lookup(namebuf)) if ctxt == 0 { n.Readonly = 1 } @@ -570,9 +551,7 @@ } func litas(l *Node, r *Node, init **NodeList) { - var a *Node - - a = Nod(OAS, l, r) + a := Nod(OAS, l, r) typecheck(&a, Etop) walkexpr(&a, init) *init = list(*init, a) @@ -584,11 +563,7 @@ ) func getdyn(n *Node, top int) int { - var nl *NodeList - var value *Node - var mode int - - mode = 0 + mode := 0 switch n.Op { default: if isliteral(n) { @@ -606,7 +581,8 @@ break } - for nl = n.List; nl != nil; nl = nl.Next { + var value *Node + for nl := n.List; nl != nil; nl = nl.Next { value = nl.N.Right mode |= getdyn(value, 0) if mode == MODEDYNAM|MODECONST { @@ -620,11 +596,10 @@ func structlit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) { var r *Node var a *Node - var nl *NodeList var index *Node var value *Node - for nl = n.List; nl != nil; nl = nl.Next { + for nl := n.List; nl != nil; nl = nl.Next { r = nl.N if r.Op != OKEY { Fatal("structlit: rhs not OKEY: %v", Nconv(r, 0)) @@ -688,11 +663,10 @@ func arraylit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) { var r *Node var a *Node - var l *NodeList var index *Node var value *Node - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { r = l.N if r.Op != OKEY { Fatal("arraylit: rhs not OKEY: %v", Nconv(r, 0)) @@ -754,18 +728,8 @@ } func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) { - var r *Node - var a *Node - var l *NodeList - var t *Type - var vstat *Node - var vauto *Node - var index *Node - var value *Node - var mode int - // make an array type - t = shallow(n.Type) + t := shallow(n.Type) t.Bound = Mpgetfix(n.Right.Val.U.Xval) t.Width = 0 @@ -775,13 +739,13 @@ if ctxt != 0 { // put everything into static array - vstat = staticname(t, ctxt) + vstat := staticname(t, ctxt) arraylit(ctxt, 1, n, vstat, init) arraylit(ctxt, 2, n, vstat, init) // copy static to slice - a = Nod(OSLICE, vstat, Nod(OKEY, nil, nil)) + a := Nod(OSLICE, vstat, Nod(OKEY, nil, nil)) a = Nod(OAS, var_, a) typecheck(&a, Etop) @@ -811,18 +775,19 @@ // if the literal contains constants, // make static initialized array (1),(2) - vstat = nil + vstat := (*Node)(nil) - mode = getdyn(n, 1) + mode := getdyn(n, 1) if mode&MODECONST != 0 { vstat = staticname(t, ctxt) arraylit(ctxt, 1, n, vstat, init) } // make new auto *array (3 declare) - vauto = temp(Ptrto(t)) + vauto := temp(Ptrto(t)) // set auto to point at new temp or heap (3 assign) + var a *Node if n.Alloc != nil { // temp allocated during order.c for dddarg n.Alloc.Type = t @@ -873,7 +838,10 @@ *init = list(*init, a) // put dynamics into slice (6) - for l = n.List; l != nil; l = l.Next { + var value *Node + var r *Node + var index *Node + for l := n.List; l != nil; l = l.Next { r = l.N if r.Op != OKEY { Fatal("slicelit: rhs not OKEY: %v", Nconv(r, 0)) @@ -914,35 +882,22 @@ func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) { var r *Node - var a *Node - var l *NodeList - var nerr int - var b int64 - var t *Type - var tk *Type - var tv *Type - var t1 *Type - var vstat *Node var index *Node var value *Node - var key *Node - var val *Node - var syma *Sym - var symb *Sym ctxt = 0 // make the map var - nerr = nerrors + nerr := nerrors - a = Nod(OMAKE, nil, nil) + a := Nod(OMAKE, nil, nil) a.List = list1(typenod(n.Type)) litas(var_, a, init) // count the initializers - b = 0 + b := int64(0) - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { r = l.N if r.Op != OKEY { @@ -958,18 +913,18 @@ if b != 0 { // build type [count]struct { a Tindex, b Tvalue } - t = n.Type + t := n.Type - tk = t.Down - tv = t.Type + tk := t.Down + tv := t.Type - symb = Lookup("b") + symb := Lookup("b") t = typ(TFIELD) t.Type = tv t.Sym = symb - syma = Lookup("a") - t1 = t + syma := Lookup("a") + t1 := t t = typ(TFIELD) t.Type = tk t.Sym = syma @@ -987,10 +942,13 @@ dowidth(t) // make and initialize static array - vstat = staticname(t, ctxt) + vstat := staticname(t, ctxt) - b = 0 - for l = n.List; l != nil; l = l.Next { + b := int64(0) + var index *Node + var r *Node + var value *Node + for l := n.List; l != nil; l = l.Next { r = l.N if r.Op != OKEY { @@ -1056,10 +1014,10 @@ } // put in dynamic entries one-at-a-time - key = nil + key := (*Node)(nil) - val = nil - for l = n.List; l != nil; l = l.Next { + val := (*Node)(nil) + for l := n.List; l != nil; l = l.Next { r = l.N if r.Op != OKEY { @@ -1109,12 +1067,7 @@ } func anylit(ctxt int, n *Node, var_ *Node, init **NodeList) { - var t *Type - var a *Node - var vstat *Node - var r *Node - - t = n.Type + t := n.Type switch n.Op { default: Fatal("anylit: not lit") @@ -1124,6 +1077,7 @@ Fatal("anylit: not ptr") } + var r *Node if n.Right != nil { r = Nod(OADDR, n.Right, nil) typecheck(&r, Erv) @@ -1135,7 +1089,7 @@ } walkexpr(&r, init) - a = Nod(OAS, var_, r) + a := Nod(OAS, var_, r) typecheck(&a, Etop) *init = list(*init, a) @@ -1152,12 +1106,12 @@ if simplename(var_) && count(n.List) > 4 { if ctxt == 0 { // lay out static data - vstat = staticname(t, ctxt) + vstat := staticname(t, ctxt) structlit(ctxt, 1, n, vstat, init) // copy static to var - a = Nod(OAS, var_, vstat) + a := Nod(OAS, var_, vstat) typecheck(&a, Etop) walkexpr(&a, init) @@ -1176,7 +1130,7 @@ // initialize of not completely specified if simplename(var_) || count(n.List) < structcount(t) { - a = Nod(OAS, var_, nil) + a := Nod(OAS, var_, nil) typecheck(&a, Etop) walkexpr(&a, init) *init = list(*init, a) @@ -1196,12 +1150,12 @@ if simplename(var_) && count(n.List) > 4 { if ctxt == 0 { // lay out static data - vstat = staticname(t, ctxt) + vstat := staticname(t, ctxt) arraylit(1, 1, n, vstat, init) // copy static to automatic - a = Nod(OAS, var_, vstat) + a := Nod(OAS, var_, vstat) typecheck(&a, Etop) walkexpr(&a, init) @@ -1220,7 +1174,7 @@ // initialize of not completely specified if simplename(var_) || int64(count(n.List)) < t.Bound { - a = Nod(OAS, var_, nil) + a := Nod(OAS, var_, nil) typecheck(&a, Etop) walkexpr(&a, init) *init = list(*init, a) @@ -1289,8 +1243,6 @@ } func stataddr(nam *Node, n *Node) bool { - var l int - if n == nil { goto no } @@ -1315,7 +1267,7 @@ if !stataddr(nam, n.Left) { break } - l = getlit(n.Right) + l := getlit(n.Right) if l < 0 { break } @@ -1334,21 +1286,18 @@ } func initplan(n *Node) { - var p *InitPlan - var a *Node - var l *NodeList - if n.Initplan != nil { return } - p = new(InitPlan) + p := new(InitPlan) n.Initplan = p switch n.Op { default: Fatal("initplan") case OARRAYLIT: - for l = n.List; l != nil; l = l.Next { + var a *Node + for l := n.List; l != nil; l = l.Next { a = l.N if a.Op != OKEY || !Smallintconst(a.Left) { Fatal("initplan arraylit") @@ -1357,7 +1306,8 @@ } case OSTRUCTLIT: - for l = n.List; l != nil; l = l.Next { + var a *Node + for l := n.List; l != nil; l = l.Next { a = l.N if a.Op != OKEY || a.Left.Type == nil { Fatal("initplan structlit") @@ -1366,7 +1316,8 @@ } case OMAPLIT: - for l = n.List; l != nil; l = l.Next { + var a *Node + for l := n.List; l != nil; l = l.Next { a = l.N if a.Op != OKEY { Fatal("initplan maplit") @@ -1377,10 +1328,6 @@ } func addvalue(p *InitPlan, xoffset int64, key *Node, n *Node) { - var i int - var q *InitPlan - var e *InitEntry - // special case: zero can be dropped entirely if iszero(n) { p.Zero += n.Type.Width @@ -1390,8 +1337,9 @@ // special case: inline struct and array (not slice) literals if isvaluelit(n) { initplan(n) - q = n.Initplan - for i = 0; i < len(q.E); i++ { + q := n.Initplan + var e *InitEntry + for i := 0; i < len(q.E); i++ { e = entry(p) *e = q.E[i] e.Xoffset += xoffset @@ -1407,14 +1355,12 @@ p.Expr += n.Type.Width } - e = entry(p) + e := entry(p) e.Xoffset = xoffset e.Expr = n } func iszero(n *Node) bool { - var l *NodeList - switch n.Op { case OLITERAL: switch n.Val.Ctype { @@ -1450,7 +1396,7 @@ // fall through case OSTRUCTLIT: - for l = n.List; l != nil; l = l.Next { + for l := n.List; l != nil; l = l.Next { if !iszero(l.N.Right) { return false } @@ -1483,6 +1429,7 @@ nr = n.Right nl = n.Left if nr == nil { + var nam Node if !stataddr(&nam, nl) { goto no }
diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go index dba7dc3..f7c07584 100644 --- a/src/cmd/internal/gc/subr.go +++ b/src/cmd/internal/gc/subr.go
@@ -44,12 +44,10 @@ } func adderrorname(n *Node) { - var old string - if n.Op != ODOT { return } - old = fmt.Sprintf("%v: undefined: %v\n", n.Line(), Nconv(n.Left, 0)) + old := fmt.Sprintf("%v: undefined: %v\n", n.Line(), Nconv(n.Left, 0)) if len(errors) > 0 && int32(errors[len(errors)-1].lineno) == n.Lineno && errors[len(errors)-1].msg == old { errors[len(errors)-1].msg = fmt.Sprintf("%v: undefined: %v in %v\n", n.Line(), Nconv(n.Left, 0), Nconv(n, 0)) } @@ -74,11 +72,8 @@ } func (x errcmp) Less(i, j int) bool { - var a *Error - var b *Error - - a = &x[i] - b = &x[j] + a := &x[i] + b := &x[j] if a.lineno != b.lineno { return a.lineno-b.lineno < 0 } @@ -89,14 +84,12 @@ } func Flusherrors() { - var i int - obj.Bflush(&bstdout) if len(errors) == 0 { return } sort.Sort(errcmp(errors[:len(errors)])) - for i = 0; i < len(errors); i++ { + for i := 0; i < len(errors); i++ { if i == 0 || errors[i].msg != errors[i-1].msg { fmt.Printf("%s", errors[i].msg) } @@ -134,8 +127,6 @@ var yyerror_lastsyntax int func Yyerror(fmt_ string, args ...interface{}) { - var i int - if fmt_ == "%s" && len(args) == 1 && args[0] == "syntax error" { nsyntaxerrors++ } @@ -169,7 +160,7 @@ } // look for parse state-specific errors in list (see go.errors). - for i = 0; i < len(yymsg); i++ { + for i := 0; i < len(yymsg); i++ { if yymsg[i].yystate == yystate && yymsg[i].yychar == yychar_subr { yyerrorl(int(lexlineno), "syntax error: %s", yymsg[i].msg) return @@ -204,7 +195,6 @@ } func Warn(fmt_ string, args ...interface{}) { - adderr(parserline(), fmt_, args) hcrash() @@ -218,7 +208,6 @@ } func Fatal(fmt_ string, args ...interface{}) { - Flusherrors() fmt.Printf("%v: internal compiler error: ", Ctxt.Line(int(lineno))) @@ -259,9 +248,7 @@ } func setlineno(n *Node) int32 { - var lno int32 - - lno = lineno + lno := lineno if n != nil { switch n.Op { case ONAME, @@ -285,10 +272,9 @@ } func stringhash(p string) uint32 { - var h uint32 var c int - h = 0 + h := uint32(0) for { c, p = intstarstringplusplus(p) if c == 0 { @@ -312,13 +298,9 @@ } func Pkglookup(name string, pkg *Pkg) *Sym { - var s *Sym - var h uint32 - var c int - - h = stringhash(name) % NHASH - c = int(name[0]) - for s = hash[h]; s != nil; s = s.Link { + h := stringhash(name) % NHASH + c := int(name[0]) + for s := hash[h]; s != nil; s = s.Link { if int(s.Name[0]) != c || s.Pkg != pkg { continue } @@ -327,7 +309,7 @@ } } - s = new(Sym) + s := new(Sym) s.Name = name s.Pkg = pkg @@ -351,12 +333,10 @@ func importdot(opkg *Pkg, pack *Node) { var s *Sym var s1 *Sym - var h uint32 - var n int var pkgerror string - n = 0 - for h = 0; h < NHASH; h++ { + n := 0 + for h := uint32(0); h < NHASH; h++ { for s = hash[h]; s != nil; s = s.Link { if s.Pkg != opkg { continue @@ -389,14 +369,11 @@ } func gethunk() { - var h string - var nh int32 - - nh = NHUNK + nh := int32(NHUNK) if thunk >= 10*NHUNK { nh = 10 * NHUNK } - h = string(make([]byte, nh)) + h := string(make([]byte, nh)) if h == "" { Flusherrors() Yyerror("out of memory") @@ -409,9 +386,7 @@ } func Nod(op int, nleft *Node, nright *Node) *Node { - var n *Node - - n = new(Node) + n := new(Node) n.Op = uint8(op) n.Left = nleft n.Right = nright @@ -423,12 +398,10 @@ } func saveorignode(n *Node) { - var norig *Node - if n.Orig != nil { return } - norig = Nod(int(n.Op), nil, nil) + norig := Nod(int(n.Op), nil, nil) *norig = *n n.Orig = norig } @@ -447,10 +420,6 @@ } func algtype1(t *Type, bad **Type) int { - var a int - var ret int - var t1 *Type - if bad != nil { *bad = nil } @@ -523,7 +492,7 @@ return ANOEQ } - a = algtype1(t.Type, bad) + a := algtype1(t.Type, bad) if a == ANOEQ || a == AMEM { if a == ANOEQ && bad != nil { *bad = t @@ -539,8 +508,9 @@ return algtype1(t.Type.Type, bad) } - ret = AMEM - for t1 = t.Type; t1 != nil; t1 = t1.Down { + ret := AMEM + var a int + for t1 := t.Type; t1 != nil; t1 = t1.Down { // All fields must be comparable. a = algtype1(t1.Type, bad) @@ -564,9 +534,7 @@ } func algtype(t *Type) int { - var a int - - a = algtype1(t, nil) + a := algtype1(t, nil) if a == AMEM || a == ANOEQ { if Isslice(t) { return ASLICE @@ -596,13 +564,10 @@ } func maptype(key *Type, val *Type) *Type { - var t *Type - var bad *Type - var atype int - var mtype int - if key != nil { - atype = algtype1(key, &bad) + var bad *Type + atype := algtype1(key, &bad) + var mtype int if bad == nil { mtype = int(key.Etype) } else { @@ -631,16 +596,14 @@ } } - t = typ(TMAP) + t := typ(TMAP) t.Down = key t.Type = val return t } func typ(et int) *Type { - var t *Type - - t = new(Type) + t := new(Type) t.Etype = uint8(et) t.Width = BADWIDTH t.Lineno = int(lineno) @@ -659,12 +622,8 @@ } func (x methcmp) Less(i, j int) bool { - var a *Type - var b *Type - var k int - - a = x[i] - b = x[j] + a := x[i] + b := x[j] if a.Sym == nil && b.Sym == nil { return false } @@ -674,12 +633,12 @@ if b.Sym == nil { return 1 < 0 } - k = stringsCompare(a.Sym.Name, b.Sym.Name) + k := stringsCompare(a.Sym.Name, b.Sym.Name) if k != 0 { return k < 0 } if !exportname(a.Sym.Name) { - k = stringsCompare(a.Sym.Pkg.Path.S, b.Sym.Pkg.Path.S) + k := stringsCompare(a.Sym.Pkg.Path.S, b.Sym.Pkg.Path.S) if k != 0 { return k < 0 } @@ -689,20 +648,17 @@ } func sortinter(t *Type) *Type { - var f *Type - var i int - var a []*Type - if t.Type == nil || t.Type.Down == nil { return t } - i = 0 - for f = t.Type; f != nil; f = f.Down { + i := 0 + for f := t.Type; f != nil; f = f.Down { i++ } - a = make([]*Type, i) + a := make([]*Type, i) i = 0 + var f *Type for f = t.Type; f != nil; f = f.Down { a[i] = f i++ @@ -723,9 +679,7 @@ } func Nodintconst(v int64) *Node { - var c *Node - - c = Nod(OLITERAL, nil, nil) + c := Nod(OLITERAL, nil, nil) c.Addable = 1 c.Val.U.Xval = new(Mpint) Mpmovecfix(c.Val.U.Xval, v) @@ -736,9 +690,7 @@ } func nodfltconst(v *Mpflt) *Node { - var c *Node - - c = Nod(OLITERAL, nil, nil) + c := Nod(OLITERAL, nil, nil) c.Addable = 1 c.Val.U.Fval = new(Mpflt) mpmovefltflt(c.Val.U.Fval, v) @@ -764,18 +716,14 @@ } func nodnil() *Node { - var c *Node - - c = Nodintconst(0) + c := Nodintconst(0) c.Val.Ctype = CTNIL c.Type = Types[TNIL] return c } func Nodbool(b bool) *Node { - var c *Node - - c = Nodintconst(0) + c := Nodintconst(0) c.Val.Ctype = CTBOOL c.Val.U.Bval = int16(bool2int(b)) c.Type = idealbool @@ -783,10 +731,7 @@ } func aindex(b *Node, t *Type) *Type { - var r *Type - var bound int64 - - bound = -1 // open bound + bound := int64(-1) // open bound typecheck(&b, Erv) if b != nil { switch consttype(b) { @@ -803,7 +748,7 @@ } // fixed array - r = typ(TARRAY) + r := typ(TARRAY) r.Type = t r.Bound = bound @@ -811,12 +756,11 @@ } func treecopy(n *Node) *Node { - var m *Node - if n == nil { return nil } + var m *Node switch n.Op { default: m = Nod(OXXX, nil, nil) @@ -1023,8 +967,6 @@ } func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) bool { - var l TypePairList - if t1 == t2 { return true } @@ -1053,6 +995,7 @@ if onlist(assumed_equal, t1, t2) { return true } + var l TypePairList l.next = assumed_equal l.t1 = t1 l.t2 = t2 @@ -1159,10 +1102,6 @@ // If so, return op code to use in conversion. // If not, return 0. func assignop(src *Type, dst *Type, why *string) int { - var missing *Type - var have *Type - var ptr int - if why != nil { *why = "" } @@ -1197,6 +1136,9 @@ // 3. dst is an interface type and src implements dst. if dst.Etype == TINTER && src.Etype != TNIL { + var missing *Type + var ptr int + var have *Type if implements(src, dst, &missing, &have, &ptr) { return OCONVIFACE } @@ -1233,6 +1175,9 @@ } if src.Etype == TINTER && dst.Etype != TBLANK { + var have *Type + var ptr int + var missing *Type if why != nil && implements(dst, src, &missing, &have, &ptr) { *why = ": need type assertion" } @@ -1281,8 +1226,6 @@ // If so, return op code to use in conversion (maybe OCONVNOP). // If not, return 0. func convertop(src *Type, dst *Type, why *string) int { - var op int - if why != nil { *why = "" } @@ -1295,7 +1238,7 @@ } // 1. src can be assigned to dst. - op = assignop(src, dst, why) + op := assignop(src, dst, why) if op != 0 { return op } @@ -1381,11 +1324,6 @@ // Convert node n for assignment to type t. func assignconv(n *Node, t *Type, context string) *Node { - var op int - var r *Node - var old *Node - var why string - if n == nil || n.Type == nil || n.Type.Broke != 0 { return n } @@ -1394,7 +1332,7 @@ Yyerror("use of untyped nil") } - old = n + old := n old.Diag++ // silence errors about n; we'll issue one below defaultlit(&n, t) old.Diag-- @@ -1406,7 +1344,7 @@ // if the next step is non-bool (like interface{}). if n.Type == idealbool && t.Etype != TBOOL { if n.Op == ONAME || n.Op == OLITERAL { - r = Nod(OCONVNOP, n, nil) + r := Nod(OCONVNOP, n, nil) r.Type = Types[TBOOL] r.Typecheck = 1 r.Implicit = 1 @@ -1418,13 +1356,14 @@ return n } - op = assignop(n.Type, t, &why) + var why string + op := assignop(n.Type, t, &why) if op == 0 { Yyerror("cannot use %v as type %v in %s%s", Nconv(n, obj.FmtLong), Tconv(t, 0), context, why) op = OCONV } - r = Nod(op, n, nil) + r := Nod(op, n, nil) r.Type = t r.Typecheck = 1 r.Implicit = 1 @@ -1517,11 +1456,8 @@ * Is a conversion between t1 and t2 a no-op? */ func Noconv(t1 *Type, t2 *Type) bool { - var e1 int - var e2 int - - e1 = int(Simtype[t1.Etype]) - e2 = int(Simtype[t2.Etype]) + e1 := int(Simtype[t1.Etype]) + e2 := int(Simtype[t2.Etype]) switch e1 { case TINT8, @@ -1560,12 +1496,10 @@ } func shallow(t *Type) *Type { - var nt *Type - if t == nil { return nil } - nt = typ(0) + nt := typ(0) *nt = *t if t.Orig == t { nt.Orig = nt @@ -1574,13 +1508,11 @@ } func deep(t *Type) *Type { - var nt *Type - var xt *Type - if t == nil { return nil } + var nt *Type switch t.Etype { default: nt = t // share from here down @@ -1610,7 +1542,7 @@ case TSTRUCT: nt = shallow(t) nt.Type = shallow(t.Type) - xt = nt.Type + xt := nt.Type for t = t.Type; t != nil; t = t.Down { xt.Type = deep(t.Type) @@ -1623,10 +1555,7 @@ } func syslook(name string, copy int) *Node { - var s *Sym - var n *Node - - s = Pkglookup(name, Runtimepkg) + s := Pkglookup(name, Runtimepkg) if s == nil || s.Def == nil { Fatal("syslook: can't find runtime.%s", name) } @@ -1635,7 +1564,7 @@ return s.Def } - n = Nod(0, nil, nil) + n := Nod(0, nil, nil) *n = *s.Def n.Type = deep(s.Def.Type) @@ -1656,7 +1585,6 @@ */ func typehash(t *Type) uint32 { var p string - var d MD5 if t.Thistuple != 0 { // hide method receiver from Tpretty @@ -1669,6 +1597,7 @@ } //print("typehash: %s\n", p); + var d MD5 md5reset(&d) md5write(&d, []byte(p), len(p)) @@ -1677,12 +1606,10 @@ } func Ptrto(t *Type) *Type { - var t1 *Type - if Tptr == 0 { Fatal("ptrto: no tptr") } - t1 = typ(Tptr) + t1 := typ(Tptr) t1.Type = t t1.Width = int64(Widthptr) t1.Align = uint8(Widthptr) @@ -1691,8 +1618,6 @@ func frame(context int) { var l *NodeList - var n *Node - var w int64 if context != 0 { fmt.Printf("--- external frame ---\n") @@ -1704,6 +1629,8 @@ return } + var n *Node + var w int64 for ; l != nil; l = l.Next { n = l.N w = -1 @@ -1727,13 +1654,12 @@ * hardest side first to minimize registers. */ func ullmancalc(n *Node) { - var ul int - var ur int - if n == nil { return } + var ul int + var ur int if n.Ninit != nil { ul = UINF goto out @@ -1788,10 +1714,7 @@ } func badtype(o int, tl *Type, tr *Type) { - var fmt_ string - var s string - - fmt_ = "" + fmt_ := "" if tl != nil { fmt_ += fmt.Sprintf("\n\t%v", Tconv(tl, 0)) } @@ -1808,7 +1731,7 @@ } } - s = fmt_ + s := fmt_ Yyerror("illegal types for operand: %v%s", Oconv(int(o), 0), s) } @@ -1816,10 +1739,9 @@ * iterator to walk a structure declaration */ func Structfirst(s *Iter, nn **Type) *Type { - var n *Type var t *Type - n = *nn + n := *nn if n == nil { goto bad } @@ -1854,11 +1776,8 @@ } func structnext(s *Iter) *Type { - var n *Type - var t *Type - - n = s.T - t = n.Down + n := s.T + t := n.Down if t == nil { goto rnil } @@ -1907,9 +1826,7 @@ } func funcnext(s *Iter) *Type { - var fp *Type - - fp = structnext(s) + fp := structnext(s) if fp == nil && s.Done == 0 { s.Done = 1 fp = Structfirst(s, getinarg(s.Tfunc)) @@ -2004,10 +1921,6 @@ * result is assignable if n is. */ func safeexpr(n *Node, init **NodeList) *Node { - var l *Node - var r *Node - var a *Node - if n == nil { return nil } @@ -2024,11 +1937,11 @@ return n case ODOT: - l = safeexpr(n.Left, init) + l := safeexpr(n.Left, init) if l == n.Left { return n } - r = Nod(OXXX, nil, nil) + r := Nod(OXXX, nil, nil) *r = *n r.Left = l typecheck(&r, Erv) @@ -2037,11 +1950,11 @@ case ODOTPTR, OIND: - l = safeexpr(n.Left, init) + l := safeexpr(n.Left, init) if l == n.Left { return n } - a = Nod(OXXX, nil, nil) + a := Nod(OXXX, nil, nil) *a = *n a.Left = l walkexpr(&a, init) @@ -2049,12 +1962,12 @@ case OINDEX, OINDEXMAP: - l = safeexpr(n.Left, init) - r = safeexpr(n.Right, init) + l := safeexpr(n.Left, init) + r := safeexpr(n.Right, init) if l == n.Left && r == n.Right { return n } - a = Nod(OXXX, nil, nil) + a := Nod(OXXX, nil, nil) *a = *n a.Left = l a.Right = r @@ -2070,11 +1983,8 @@ } func copyexpr(n *Node, t *Type, init **NodeList) *Node { - var a *Node - var l *Node - - l = temp(t) - a = Nod(OAS, l, n) + l := temp(t) + a := Nod(OAS, l, n) typecheck(&a, Etop) walkexpr(&a, init) *init = list(*init, a) @@ -2109,10 +2019,8 @@ } func Setmaxarg(t *Type, extra int32) { - var w int64 - dowidth(t) - w = t.Argwid + w := t.Argwid if w >= Thearch.MAXWIDTH { Fatal("bad argwid %v", Tconv(t, 0)) } @@ -2138,18 +2046,14 @@ // return count of fields+methods // found with a given name func lookdot0(s *Sym, t *Type, save **Type, ignorecase int) int { - var f *Type - var u *Type - var c int - - u = t + u := t if Isptr[u.Etype] != 0 { u = u.Type } - c = 0 + c := 0 if u.Etype == TSTRUCT || u.Etype == TINTER { - for f = u.Type; f != nil; f = f.Down { + for f := u.Type; f != nil; f = f.Down { if f.Sym == s || (ignorecase != 0 && f.Type.Etype == TFUNC && f.Type.Thistuple > 0 && strings.EqualFold(f.Sym.Name, s.Name)) { if save != nil { *save = f @@ -2161,7 +2065,7 @@ u = methtype(t, 0) if u != nil { - for f = u.Method; f != nil; f = f.Down { + for f := u.Method; f != nil; f = f.Down { if f.Embedded == 0 && (f.Sym == s || (ignorecase != 0 && strings.EqualFold(f.Sym.Name, s.Name))) { if save != nil { *save = f @@ -2180,16 +2084,14 @@ // answer is in dotlist array and // count of number of ways is returned. func adddot1(s *Sym, t *Type, d int, save **Type, ignorecase int) int { - var f *Type - var u *Type - var c int - var a int - if t.Trecur != 0 { return 0 } t.Trecur = 1 + var c int + var u *Type + var a int if d == 0 { c = lookdot0(s, t, save, ignorecase) goto out @@ -2205,7 +2107,7 @@ } d-- - for f = u.Type; f != nil; f = f.Down { + for f := u.Type; f != nil; f = f.Down { if f.Embedded == 0 { continue } @@ -2229,14 +2131,13 @@ // will give shortest unique addressing. // modify the tree with missing type names. func adddot(n *Node) *Node { - var t *Type var s *Sym var c int var d int typecheck(&n.Left, Etype|Erv) n.Diag |= n.Left.Diag - t = n.Left.Type + t := n.Left.Type if t == nil { goto ret } @@ -2270,7 +2171,7 @@ } // rebuild elided dots - for c = d - 1; c >= 0; c-- { + for c := d - 1; c >= 0; c-- { n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym)) } @@ -2298,18 +2199,15 @@ var slist *Symlink func expand0(t *Type, followptr int) { - var f *Type - var u *Type - var sl *Symlink - - u = t + u := t if Isptr[u.Etype] != 0 { followptr = 1 u = u.Type } if u.Etype == TINTER { - for f = u.Type; f != nil; f = f.Down { + var sl *Symlink + for f := u.Type; f != nil; f = f.Down { if f.Sym.Flags&SymUniq != 0 { continue } @@ -2326,7 +2224,8 @@ u = methtype(t, 0) if u != nil { - for f = u.Method; f != nil; f = f.Down { + var sl *Symlink + for f := u.Method; f != nil; f = f.Down { if f.Sym.Flags&SymUniq != 0 { continue } @@ -2341,9 +2240,6 @@ } func expand1(t *Type, d int, followptr int) { - var f *Type - var u *Type - if t.Trecur != 0 { return } @@ -2356,7 +2252,7 @@ expand0(t, followptr) } - u = t + u := t if Isptr[u.Etype] != 0 { followptr = 1 u = u.Type @@ -2366,7 +2262,7 @@ goto out } - for f = u.Type; f != nil; f = f.Down { + for f := u.Type; f != nil; f = f.Down { if f.Embedded == 0 { continue } @@ -2381,17 +2277,13 @@ } func expandmeth(t *Type) { - var sl *Symlink - var f *Type - var c int - var d int - if t == nil || t.Xmethod != nil { return } // mark top-level method symbols // so that expand1 doesn't consider them. + var f *Type for f = t.Method; f != nil; f = f.Down { f.Sym.Flags |= SymUniq } @@ -2402,7 +2294,9 @@ expand1(t, len(dotlist)-1, 0) // check each method to be uniquely reachable - for sl = slist; sl != nil; sl = sl.link { + var c int + var d int + for sl := slist; sl != nil; sl = sl.link { sl.field.Sym.Flags &^= SymUniq for d = 0; d < len(dotlist); d++ { c = adddot1(sl.field.Sym, t, d, &f, 0) @@ -2426,7 +2320,7 @@ } t.Xmethod = t.Method - for sl = slist; sl != nil; sl = sl.link { + for sl := slist; sl != nil; sl = sl.link { if sl.good != 0 { // add it to the base type method list f = typ(TFIELD) @@ -2449,14 +2343,11 @@ var savet Iter var a *Node var n *Node - var args *NodeList - var t *Type var buf string - var gen int - args = nil - gen = 0 - for t = Structfirst(&savet, tl); t != nil; t = structnext(&savet) { + args := (*NodeList)(nil) + gen := 0 + for t := Structfirst(&savet, tl); t != nil; t = structnext(&savet) { n = nil if mustname != 0 && (t.Sym == nil || t.Sym.Name == "_") { // invent a name so that we can refer to it in the trampoline @@ -2505,23 +2396,6 @@ var genwrapper_linehistdone int = 0 func genwrapper(rcvr *Type, method *Type, newnam *Sym, iface int) { - var this *Node - var fn *Node - var call *Node - var n *Node - var t *Node - var pad *Node - var dot *Node - var as *Node - var l *NodeList - var args *NodeList - var in *NodeList - var out *NodeList - var tpad *Type - var methodrcvr *Type - var isddd int - var v Val - if false && Debug['r'] != 0 { fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", Tconv(rcvr, 0), Tconv(method, 0), Sconv(newnam, 0)) } @@ -2538,31 +2412,31 @@ dclcontext = PEXTERN markdcl() - this = Nod(ODCLFIELD, newname(Lookup(".this")), typenod(rcvr)) + this := Nod(ODCLFIELD, newname(Lookup(".this")), typenod(rcvr)) this.Left.Ntype = this.Right - in = structargs(getinarg(method.Type), 1) - out = structargs(Getoutarg(method.Type), 0) + in := structargs(getinarg(method.Type), 1) + out := structargs(Getoutarg(method.Type), 0) - t = Nod(OTFUNC, nil, nil) - l = list1(this) + t := Nod(OTFUNC, nil, nil) + l := list1(this) if iface != 0 && rcvr.Width < Types[Tptr].Width { // Building method for interface table and receiver // is smaller than the single pointer-sized word // that the interface call will pass in. // Add a dummy padding argument after the // receiver to make up the difference. - tpad = typ(TARRAY) + tpad := typ(TARRAY) tpad.Type = Types[TUINT8] tpad.Bound = Types[Tptr].Width - rcvr.Width - pad = Nod(ODCLFIELD, newname(Lookup(".pad")), typenod(tpad)) + pad := Nod(ODCLFIELD, newname(Lookup(".pad")), typenod(tpad)) l = list(l, pad) } t.List = concat(l, in) t.Rlist = out - fn = Nod(ODCLFUNC, nil, nil) + fn := Nod(ODCLFUNC, nil, nil) fn.Nname = newname(newnam) fn.Nname.Defn = fn fn.Nname.Ntype = t @@ -2570,27 +2444,28 @@ funchdr(fn) // arg list - args = nil + args := (*NodeList)(nil) - isddd = 0 - for l = in; l != nil; l = l.Next { + isddd := 0 + for l := in; l != nil; l = l.Next { args = list(args, l.N.Left) isddd = int(l.N.Left.Isddd) } - methodrcvr = getthisx(method.Type).Type.Type + methodrcvr := getthisx(method.Type).Type.Type // generate nil pointer check for better error if Isptr[rcvr.Etype] != 0 && rcvr.Type == methodrcvr { // generating wrapper from *T to T. - n = Nod(OIF, nil, nil) + n := Nod(OIF, nil, nil) n.Ntest = Nod(OEQ, this.Left, nodnil()) // these strings are already in the reflect tables, // so no space cost to use them here. - l = nil + l := (*NodeList)(nil) + var v Val v.Ctype = CTSTR v.U.Sval = newstrlit(rcvr.Type.Sym.Pkg.Name) // package name l = list(l, nodlit(v)) @@ -2598,13 +2473,13 @@ l = list(l, nodlit(v)) v.U.Sval = newstrlit(method.Sym.Name) l = list(l, nodlit(v)) // method name - call = Nod(OCALL, syslook("panicwrap", 0), nil) + call := Nod(OCALL, syslook("panicwrap", 0), nil) call.List = l n.Nbody = list1(call) fn.Nbody = list(fn.Nbody, n) } - dot = adddot(Nod(OXDOT, this.Left, newname(method.Sym))) + dot := adddot(Nod(OXDOT, this.Left, newname(method.Sym))) // generate call if flag_race == 0 && Isptr[rcvr.Etype] != 0 && Isptr[methodrcvr.Etype] != 0 && method.Embedded != 0 && !isifacemethod(method.Type) { @@ -2613,19 +2488,19 @@ if Isptr[dotlist[0].field.Type.Etype] == 0 { dot = Nod(OADDR, dot, nil) } - as = Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil)) + as := Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil)) as.Right.Type = rcvr fn.Nbody = list(fn.Nbody, as) - n = Nod(ORETJMP, nil, nil) + n := Nod(ORETJMP, nil, nil) n.Left = newname(methodsym(method.Sym, methodrcvr, 0)) fn.Nbody = list(fn.Nbody, n) } else { fn.Wrapper = 1 // ignore frame for panic+recover matching - call = Nod(OCALL, dot, nil) + call := Nod(OCALL, dot, nil) call.List = args call.Isddd = uint8(isddd) if method.Type.Outtuple > 0 { - n = Nod(ORETURN, nil, nil) + n := Nod(ORETURN, nil, nil) n.List = list1(call) call = n } @@ -2662,15 +2537,11 @@ } func hashmem(t *Type) *Node { - var tfn *Node - var n *Node - var sym *Sym + sym := Pkglookup("memhash", Runtimepkg) - sym = Pkglookup("memhash", Runtimepkg) - - n = newname(sym) + n := newname(sym) n.Class = PFUNC - tfn = Nod(OTFUNC, nil, nil) + tfn := Nod(OTFUNC, nil, nil) tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t)))) tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR]))) tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR]))) @@ -2681,12 +2552,9 @@ } func hashfor(t *Type) *Node { - var a int var sym *Sym - var tfn *Node - var n *Node - a = algtype1(t, nil) + a := algtype1(t, nil) switch a { case AMEM: Fatal("hashfor with AMEM type") @@ -2716,9 +2584,9 @@ sym = typesymprefix(".hash", t) } - n = newname(sym) + n := newname(sym) n.Class = PFUNC - tfn = Nod(OTFUNC, nil, nil) + tfn := Nod(OTFUNC, nil, nil) tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t)))) tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR]))) tfn.Rlist = list(tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR]))) @@ -2731,24 +2599,6 @@ * Generate a helper function to compute the hash of a value of type t. */ func genhash(sym *Sym, t *Type) { - var n *Node - var fn *Node - var np *Node - var nh *Node - var ni *Node - var call *Node - var nx *Node - var na *Node - var tfn *Node - var r *Node - var hashel *Node - var first *Type - var t1 *Type - var old_safemode int - var size int64 - var mul int64 - var offend int64 - if Debug['r'] != 0 { fmt.Printf("genhash %v %v\n", Sconv(sym, 0), Tconv(t, 0)) } @@ -2758,19 +2608,19 @@ markdcl() // func sym(p *T, h uintptr) uintptr - fn = Nod(ODCLFUNC, nil, nil) + fn := Nod(ODCLFUNC, nil, nil) fn.Nname = newname(sym) fn.Nname.Class = PFUNC - tfn = Nod(OTFUNC, nil, nil) + tfn := Nod(OTFUNC, nil, nil) fn.Nname.Ntype = tfn - n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t))) + n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t))) tfn.List = list(tfn.List, n) - np = n.Left + np := n.Left n = Nod(ODCLFIELD, newname(Lookup("h")), typenod(Types[TUINTPTR])) tfn.List = list(tfn.List, n) - nh = n.Left + nh := n.Left n = Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value tfn.Rlist = list(tfn.Rlist, n) @@ -2792,10 +2642,10 @@ // An array of pure memory would be handled by the // standard algorithm, so the element type must not be // pure memory. - hashel = hashfor(t.Type) + hashel := hashfor(t.Type) - n = Nod(ORANGE, nil, Nod(OIND, np, nil)) - ni = newname(Lookup("i")) + n := Nod(ORANGE, nil, Nod(OIND, np, nil)) + ni := newname(Lookup("i")) ni.Type = Types[TINT] n.List = list1(ni) n.Colas = 1 @@ -2809,6 +2659,7 @@ // h *= mul // Same multipliers as in runtime.memhash. + var mul int64 if Widthptr == 4 { mul = 3267000013 } else { @@ -2817,11 +2668,11 @@ n.Nbody = list(n.Nbody, Nod(OAS, nh, Nod(OMUL, nh, Nodintconst(mul)))) // h = hashel(&p[i], h) - call = Nod(OCALL, hashel, nil) + call := Nod(OCALL, hashel, nil) - nx = Nod(OINDEX, np, ni) + nx := Nod(OINDEX, np, ni) nx.Bounded = true - na = Nod(OADDR, nx, nil) + na := Nod(OADDR, nx, nil) na.Etype = 1 // no escape to heap call.List = list(call.List, na) call.List = list(call.List, nh) @@ -2832,10 +2683,15 @@ // Walk the struct using memhash for runs of AMEM // and calling specific hash functions for the others. case TSTRUCT: - first = nil + first := (*Type)(nil) - offend = 0 - for t1 = t.Type; ; t1 = t1.Down { + offend := int64(0) + var size int64 + var call *Node + var nx *Node + var na *Node + var hashel *Node + for t1 := t.Type; ; t1 = t1.Down { if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) { offend = t1.Width + t1.Type.Width if first == nil { @@ -2906,7 +2762,7 @@ } } - r = Nod(ORETURN, nil, nil) + r := Nod(ORETURN, nil, nil) r.List = list(r.List, nh) fn.Nbody = list(fn.Nbody, r) @@ -2926,7 +2782,7 @@ // 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 funccompile(fn) @@ -2936,23 +2792,17 @@ // Return node for // if p.field != q.field { return false } func eqfield(p *Node, q *Node, field *Node) *Node { - var nif *Node - var nx *Node - var ny *Node - var r *Node - - nx = Nod(OXDOT, p, field) - ny = Nod(OXDOT, q, field) - nif = Nod(OIF, nil, nil) + nx := Nod(OXDOT, p, field) + ny := Nod(OXDOT, q, field) + nif := Nod(OIF, nil, nil) nif.Ntest = Nod(ONE, nx, ny) - r = Nod(ORETURN, nil, nil) + r := Nod(ORETURN, nil, nil) r.List = list(r.List, Nodbool(false)) nif.Nbody = list(nif.Nbody, r) return nif } func eqmemfunc(size int64, type_ *Type, needsize *int) *Node { - var buf string var fn *Node switch size { @@ -2965,7 +2815,7 @@ 4, 8, 16: - buf = fmt.Sprintf("memequal%d", int(size)*8) + buf := fmt.Sprintf("memequal%d", int(size)*8) fn = syslook(buf, 1) *needsize = 0 } @@ -2978,31 +2828,26 @@ // Return node for // if !memequal(&p.field, &q.field [, size]) { return false } func eqmem(p *Node, q *Node, field *Node, size int64) *Node { - var nif *Node - var nx *Node - var ny *Node - var call *Node - var r *Node var needsize int - nx = Nod(OADDR, Nod(OXDOT, p, field), nil) + nx := Nod(OADDR, Nod(OXDOT, p, field), nil) nx.Etype = 1 // does not escape - ny = Nod(OADDR, Nod(OXDOT, q, field), nil) + ny := Nod(OADDR, Nod(OXDOT, q, field), nil) ny.Etype = 1 // does not escape typecheck(&nx, Erv) typecheck(&ny, Erv) - call = Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil) + call := Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil) call.List = list(call.List, nx) call.List = list(call.List, ny) if needsize != 0 { call.List = list(call.List, Nodintconst(size)) } - nif = Nod(OIF, nil, nil) + nif := Nod(OIF, nil, nil) nif.Ninit = list(nif.Ninit, call) nif.Ntest = Nod(ONOT, call, nil) - r = Nod(ORETURN, nil, nil) + r := Nod(ORETURN, nil, nil) r.List = list(r.List, Nodbool(false)) nif.Nbody = list(nif.Nbody, r) return nif @@ -3012,23 +2857,6 @@ * Generate a helper function to check equality of two values of type t. */ func geneq(sym *Sym, t *Type) { - var n *Node - var fn *Node - var np *Node - var nq *Node - var tfn *Node - var nif *Node - var ni *Node - var nx *Node - var ny *Node - var nrange *Node - var r *Node - var t1 *Type - var first *Type - var old_safemode int - var size int64 - var offend int64 - if Debug['r'] != 0 { fmt.Printf("geneq %v %v\n", Sconv(sym, 0), Tconv(t, 0)) } @@ -3038,19 +2866,19 @@ markdcl() // func sym(p, q *T) bool - fn = Nod(ODCLFUNC, nil, nil) + fn := Nod(ODCLFUNC, nil, nil) fn.Nname = newname(sym) fn.Nname.Class = PFUNC - tfn = Nod(OTFUNC, nil, nil) + tfn := Nod(OTFUNC, nil, nil) fn.Nname.Ntype = tfn - n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t))) + n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t))) tfn.List = list(tfn.List, n) - np = n.Left + np := n.Left n = Nod(ODCLFIELD, newname(Lookup("q")), typenod(Ptrto(t))) tfn.List = list(tfn.List, n) - nq = n.Left + nq := n.Left n = Nod(ODCLFIELD, nil, typenod(Types[TBOOL])) tfn.Rlist = list(tfn.Rlist, n) @@ -3073,9 +2901,9 @@ // pure memory. Even if we unrolled the range loop, // each iteration would be a function call, so don't bother // unrolling. - nrange = Nod(ORANGE, nil, Nod(OIND, np, nil)) + nrange := Nod(ORANGE, nil, Nod(OIND, np, nil)) - ni = newname(Lookup("i")) + ni := newname(Lookup("i")) ni.Type = Types[TINT] nrange.List = list1(ni) nrange.Colas = 1 @@ -3083,15 +2911,15 @@ ni = nrange.List.N // if p[i] != q[i] { return false } - nx = Nod(OINDEX, np, ni) + nx := Nod(OINDEX, np, ni) nx.Bounded = true - ny = Nod(OINDEX, nq, ni) + ny := Nod(OINDEX, nq, ni) ny.Bounded = true - nif = Nod(OIF, nil, nil) + nif := Nod(OIF, nil, nil) nif.Ntest = Nod(ONE, nx, ny) - r = Nod(ORETURN, nil, nil) + r := Nod(ORETURN, nil, nil) r.List = list(r.List, Nodbool(false)) nif.Nbody = list(nif.Nbody, r) nrange.Nbody = list(nrange.Nbody, nif) @@ -3101,10 +2929,11 @@ // and calling specific equality tests for the others. // Skip blank-named fields. case TSTRUCT: - first = nil + first := (*Type)(nil) - offend = 0 - for t1 = t.Type; ; t1 = t1.Down { + offend := int64(0) + var size int64 + for t1 := t.Type; ; t1 = t1.Down { if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) { offend = t1.Width + t1.Type.Width if first == nil { @@ -3153,7 +2982,7 @@ } // return true - r = Nod(ORETURN, nil, nil) + r := Nod(ORETURN, nil, nil) r.List = list(r.List, Nodbool(true)) fn.Nbody = list(fn.Nbody, r) @@ -3174,7 +3003,7 @@ // 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 funccompile(fn) @@ -3182,18 +3011,16 @@ } func ifacelookdot(s *Sym, t *Type, followptr *int, ignorecase int) *Type { - var i int - var c int - var d int - var m *Type - *followptr = 0 if t == nil { return nil } - for d = 0; d < len(dotlist); d++ { + var m *Type + var i int + var c int + for d := 0; d < len(dotlist); d++ { c = adddot1(s, t, d, &m, ignorecase) if c > 1 { Yyerror("%v.%v is ambiguous", Tconv(t, 0), Sconv(s, 0)) @@ -3221,14 +3048,7 @@ } func implements(t *Type, iface *Type, m **Type, samename **Type, ptr *int) bool { - var t0 *Type - var im *Type - var tm *Type - var rcvr *Type - var imtype *Type - var followptr int - - t0 = t + t0 := t if t == nil { return false } @@ -3238,7 +3058,8 @@ // and then do one loop. if t.Etype == TINTER { - for im = iface.Type; im != nil; im = im.Down { + var tm *Type + for im := iface.Type; im != nil; im = im.Down { for tm = t.Type; tm != nil; tm = tm.Down { if tm.Sym == im.Sym { if Eqtype(tm.Type, im.Type) { @@ -3265,7 +3086,11 @@ if t != nil { expandmeth(t) } - for im = iface.Type; im != nil; im = im.Down { + var tm *Type + var imtype *Type + var followptr int + var rcvr *Type + for im := iface.Type; im != nil; im = im.Down { imtype = methodfunc(im.Type, nil) tm = ifacelookdot(im.Sym, t, &followptr, 0) if tm == nil || tm.Nointerface || !Eqtype(methodfunc(tm.Type, nil), imtype) { @@ -3303,13 +3128,11 @@ * all the invalid conversions (like ptr -> bool) */ func Simsimtype(t *Type) int { - var et int - if t == nil { return 0 } - et = int(Simtype[t.Etype]) + et := int(Simtype[t.Etype]) switch et { case TPTR32: et = TUINT32 @@ -3339,21 +3162,19 @@ } func list1(n *Node) *NodeList { - var l *NodeList - if n == nil { return nil } if n.Op == OBLOCK && n.Ninit == nil { // Flatten list and steal storage. // Poison pointer to catch errant uses. - l = n.List + l := n.List n.List = nil return l } - l = new(NodeList) + l := new(NodeList) l.N = n l.End = l return l @@ -3364,16 +3185,12 @@ } func listsort(l **NodeList, f func(*Node, *Node) int) { - var l1 *NodeList - var l2 *NodeList - var le *NodeList - if *l == nil || (*l).Next == nil { return } - l1 = *l - l2 = *l + l1 := *l + l2 := *l for { l2 = l2.Next if l2 == nil { @@ -3405,6 +3222,7 @@ // now l1 == *l; and l1 < l2 + var le *NodeList for (l1 != nil) && (l2 != nil) { for (l1.Next != nil) && f(l1.Next.N, l2.N) < 0 { l1 = l1.Next @@ -3427,9 +3245,7 @@ } func listtreecopy(l *NodeList) *NodeList { - var out *NodeList - - out = nil + out := (*NodeList)(nil) for ; l != nil; l = l.Next { out = list(out, treecopy(l.N)) } @@ -3437,9 +3253,7 @@ } func liststmt(l *NodeList) *Node { - var n *Node - - n = Nod(OBLOCK, nil, nil) + n := Nod(OBLOCK, nil, nil) n.List = l if l != nil { n.Lineno = l.N.Lineno @@ -3451,9 +3265,7 @@ * return nelem of list */ func count(l *NodeList) int { - var n int64 - - n = 0 + n := int64(0) for ; l != nil; l = l.Next { n++ } @@ -3468,10 +3280,9 @@ * return nelem of list */ func structcount(t *Type) int { - var v int var s Iter - v = 0 + v := 0 for t = Structfirst(&s, &t); t != nil; t = structnext(&s) { v++ } @@ -3486,7 +3297,6 @@ func powtwo(n *Node) int { var v uint64 var b uint64 - var i int if n == nil || n.Op != OLITERAL || n.Type == nil { goto no @@ -3497,7 +3307,7 @@ v = uint64(Mpgetfix(n.Val.U.Xval)) b = 1 - for i = 0; i < 64; i++ { + for i := 0; i < 64; i++ { if b == v { return i } @@ -3510,7 +3320,7 @@ v = -v b = 1 - for i = 0; i < 64; i++ { + for i := 0; i < 64; i++ { if b == v { return i + 1000 } @@ -3559,17 +3369,7 @@ * see hacker's delight chapter 10 */ func Smagic(m *Magic) { - var p int - var ad uint64 - var anc uint64 - var delta uint64 - var q1 uint64 - var r1 uint64 - var q2 uint64 - var r2 uint64 - var t uint64 var mask uint64 - var two31 uint64 m.Bad = 0 switch m.W { @@ -3590,10 +3390,10 @@ mask = 0xffffffffffffffff } - two31 = mask ^ (mask >> 1) + two31 := mask ^ (mask >> 1) - p = m.W - 1 - ad = uint64(m.Sd) + p := m.W - 1 + ad := uint64(m.Sd) if m.Sd < 0 { ad = -uint64(m.Sd) } @@ -3604,22 +3404,23 @@ return } - t = two31 + t := two31 ad &= mask - anc = t - 1 - t%ad + anc := t - 1 - t%ad anc &= mask - q1 = two31 / anc - r1 = two31 - q1*anc + q1 := two31 / anc + r1 := two31 - q1*anc q1 &= mask r1 &= mask - q2 = two31 / ad - r2 = two31 - q2*ad + q2 := two31 / ad + r2 := two31 - q2*ad q2 &= mask r2 &= mask + var delta uint64 for { p++ q1 <<= 1 @@ -3665,15 +3466,7 @@ * see hacker's delight chapter 10 */ func Umagic(m *Magic) { - var p int - var nc uint64 - var delta uint64 - var q1 uint64 - var r1 uint64 - var q2 uint64 - var r2 uint64 var mask uint64 - var two31 uint64 m.Bad = 0 m.Ua = 0 @@ -3696,7 +3489,7 @@ mask = 0xffffffffffffffff } - two31 = mask ^ (mask >> 1) + two31 := mask ^ (mask >> 1) m.Ud &= mask if m.Ud == 0 || m.Ud == two31 { @@ -3704,19 +3497,20 @@ return } - nc = mask - (-m.Ud&mask)%m.Ud - p = m.W - 1 + nc := mask - (-m.Ud&mask)%m.Ud + p := m.W - 1 - q1 = two31 / nc - r1 = two31 - q1*nc + q1 := two31 / nc + r1 := two31 - q1*nc q1 &= mask r1 &= mask - q2 = (two31 - 1) / m.Ud - r2 = (two31 - 1) - q2*m.Ud + q2 := (two31 - 1) / m.Ud + r2 := (two31 - 1) - q2*m.Ud q2 &= mask r2 &= mask + var delta uint64 for { p++ if r1 >= nc-r1 { @@ -3811,17 +3605,14 @@ } func mkpkg(path_ *Strlit) *Pkg { - var p *Pkg - var h int - - h = int(stringhash(path_.S) & uint32(len(phash)-1)) - for p = phash[h]; p != nil; p = p.Link { + h := int(stringhash(path_.S) & uint32(len(phash)-1)) + for p := phash[h]; p != nil; p = p.Link { if p.Path.S == path_.S { return p } } - p = new(Pkg) + p := new(Pkg) p.Path = path_ p.Prefix = pathtoprefix(path_.S) p.Link = phash[h] @@ -3836,13 +3627,11 @@ } func addinit(np **Node, init *NodeList) { - var n *Node - if init == nil { return } - n = *np + n := *np switch n.Op { // There may be multiple refs to this node; // introduce OCONVNOP to hold init list. @@ -3865,23 +3654,21 @@ } func isbadimport(path_ *Strlit) bool { - var i int - var s string - var r uint - if len(path_.S) != len(path_.S) { Yyerror("import path contains NUL") return true } - for i = 0; i < len(reservedimports); i++ { + for i := 0; i < len(reservedimports); i++ { if path_.S == reservedimports[i] { Yyerror("import path \"%s\" is reserved and cannot be used", path_.S) return true } } + var s string _ = s + var r uint _ = r for _, r := range path_.S { if r == utf8.RuneError { @@ -3914,14 +3701,12 @@ } func checknil(x *Node, init **NodeList) { - var n *Node - if Isinter(x.Type) { x = Nod(OITAB, x, nil) typecheck(&x, Erv) } - n = Nod(OCHECKNIL, x, nil) + n := Nod(OCHECKNIL, x, nil) n.Typecheck = 1 *init = list(*init, n) }
diff --git a/src/cmd/internal/gc/swt.go b/src/cmd/internal/gc/swt.go index 7c25041..81eb56c 100644 --- a/src/cmd/internal/gc/swt.go +++ b/src/cmd/internal/gc/swt.go
@@ -35,9 +35,7 @@ var C *Case func dumpcase(c0 *Case) { - var c *Case - - for c = c0; c != nil; c = c.link { + for c := c0; c != nil; c = c.link { switch c.type_ { case Tdefault: fmt.Printf("case-default\n") @@ -104,11 +102,6 @@ } func exprcmp(c1 *Case, c2 *Case) int { - var ct int - var n int - var n1 *Node - var n2 *Node - // sort non-constants last if c1.type_ != Texprconst { return +1 @@ -117,11 +110,11 @@ return -1 } - n1 = c1.node.Left - n2 = c2.node.Left + n1 := c1.node.Left + n2 := c2.node.Left // sort by type (for switches on interface) - ct = int(n1.Val.Ctype) + ct := int(n1.Val.Ctype) if ct != int(n2.Val.Ctype) { return ct - int(n2.Val.Ctype) @@ -135,7 +128,7 @@ } // sort by constant value - n = 0 + n := 0 switch ct { case CTFLT: @@ -181,16 +174,12 @@ } func csort(l *Case, f func(*Case, *Case) int) *Case { - var l1 *Case - var l2 *Case - var le *Case - if l == nil || l.link == nil { return l } - l1 = l - l2 = l + l1 := l + l2 := l for { l2 = l2.link if l2 == nil { @@ -217,7 +206,7 @@ l2 = l2.link } - le = l + le := l for { if l1 == nil { @@ -270,31 +259,24 @@ * deal with fallthrough, break, unreachable statements */ func casebody(sw *Node, typeswvar *Node) { - var n *Node - var c *Node - var last *Node - var def *Node - var cas *NodeList - var stat *NodeList - var l *NodeList - var lc *NodeList - var go_ *Node - var br *Node - var lno int32 - var needvar bool - if sw.List == nil { return } - lno = setlineno(sw) + lno := setlineno(sw) - cas = nil // cases - stat = nil // statements - def = nil // defaults - br = Nod(OBREAK, nil, nil) + cas := (*NodeList)(nil) // cases + stat := (*NodeList)(nil) // statements + def := (*Node)(nil) // defaults + br := Nod(OBREAK, nil, nil) - for l = sw.List; l != nil; l = l.Next { + var c *Node + var go_ *Node + var needvar bool + var lc *NodeList + var last *Node + var n *Node + for l := sw.List; l != nil; l = l.Next { n = l.N setlineno(n) if n.Op != OXCASE { @@ -333,9 +315,7 @@ stat = list(stat, Nod(OLABEL, go_.Left, nil)) if typeswvar != nil && needvar && n.Nname != nil { - var l *NodeList - - l = list1(Nod(ODCL, n.Nname, nil)) + l := list1(Nod(ODCL, n.Nname, nil)) l = list(l, Nod(OAS, n.Nname, typeswvar)) typechecklist(l, Etop) stat = concat(stat, l) @@ -375,16 +355,12 @@ func mkcaselist(sw *Node, arg int) *Case { var n *Node - var c *Case var c1 *Case - var c2 *Case - var l *NodeList - var ord int - c = nil - ord = 0 + c := (*Case)(nil) + ord := 0 - for l = sw.List; l != nil; l = l.Next { + for l := sw.List; l != nil; l = l.Next { n = l.N c1 = new(Case) c1.link = c @@ -444,7 +420,8 @@ switch arg { case Stype: c = csort(c, typecmp) - for c1 = c; c1 != nil; c1 = c1.link { + var c2 *Case + for c1 := c; c1 != nil; c1 = c1.link { for c2 = c1.link; c2 != nil && c2.hash == c1.hash; c2 = c2.link { if c1.type_ == Ttypenil || c1.type_ == Tdefault { break @@ -463,7 +440,7 @@ Strue, Sfalse: c = csort(c, exprcmp) - for c1 = c; c1.link != nil; c1 = c1.link { + for c1 := c; c1.link != nil; c1 = c1.link { if exprcmp(c1, c1.link) != 0 { continue } @@ -481,17 +458,12 @@ var exprname *Node func exprbsw(c0 *Case, ncase int, arg int) *Node { - var cas *NodeList - var a *Node - var n *Node - var c *Case - var i int - var half int - var lno int - - cas = nil + cas := (*NodeList)(nil) if ncase < Ncase { - for i = 0; i < ncase; i++ { + var a *Node + var n *Node + var lno int + for i := 0; i < ncase; i++ { n = c0.node lno = int(setlineno(n)) @@ -520,13 +492,13 @@ } // find the middle and recur - c = c0 + c := c0 - half = ncase >> 1 - for i = 1; i < half; i++ { + half := ncase >> 1 + for i := 1; i < half; i++ { c = c.link } - a = Nod(OIF, nil, nil) + a := Nod(OIF, nil, nil) a.Ntest = Nod(OLE, exprname, c.node.Left) typecheck(&a.Ntest, Erv) a.Nbody = list1(exprbsw(c0, half, arg)) @@ -539,19 +511,9 @@ * rebuild case statements into if .. goto */ func exprswitch(sw *Node) { - var def *Node - var cas *NodeList - var a *Node - var c0 *Case - var c *Case - var c1 *Case - var t *Type - var arg int - var ncase int - casebody(sw, nil) - arg = Snorm + arg := Snorm if Isconst(sw.Ntest, CTBOOL) { arg = Strue if sw.Ntest.Val.U.Bval == 0 { @@ -560,7 +522,7 @@ } walkexpr(&sw.Ntest, &sw.Ninit) - t = sw.Type + t := sw.Type if t == nil { return } @@ -570,7 +532,7 @@ */ exprname = nil - cas = nil + cas := (*NodeList)(nil) if arg == Strue || arg == Sfalse { exprname = Nodbool(arg == Strue) } else if consttype(sw.Ntest) >= 0 { @@ -582,7 +544,8 @@ typechecklist(cas, Etop) } - c0 = mkcaselist(sw, arg) + c0 := mkcaselist(sw, arg) + var def *Node if c0 != nil && c0.type_ == Tdefault { def = c0.node.Right c0 = c0.link @@ -590,6 +553,10 @@ def = Nod(OBREAK, nil, nil) } + var c *Case + var a *Node + var ncase int + var c1 *Case loop: if c0 == nil { cas = list(cas, def) @@ -639,13 +606,8 @@ var boolname *Node func typeone(t *Node) *Node { - var init *NodeList - var a *Node - var b *Node - var var_ *Node - - var_ = t.Nname - init = nil + var_ := t.Nname + init := (*NodeList)(nil) if var_ == nil { typecheck(&nblank, Erv|Easgn) var_ = nblank @@ -653,9 +615,9 @@ init = list1(Nod(ODCL, var_, nil)) } - a = Nod(OAS2, nil, nil) + a := Nod(OAS2, nil, nil) a.List = list(list1(var_), boolname) // var,bool = - b = Nod(ODOTTYPE, facename, nil) + b := Nod(ODOTTYPE, facename, nil) b.Type = t.Left.Type // interface.(type) a.Rlist = list1(b) typecheck(&a, Etop) @@ -669,17 +631,12 @@ } func typebsw(c0 *Case, ncase int) *Node { - var cas *NodeList - var a *Node - var n *Node - var c *Case - var i int - var half int - - cas = nil + cas := (*NodeList)(nil) if ncase < Ncase { - for i = 0; i < ncase; i++ { + var n *Node + var a *Node + for i := 0; i < ncase; i++ { n = c0.node if c0.type_ != Ttypeconst { Fatal("typebsw") @@ -696,13 +653,13 @@ } // find the middle and recur - c = c0 + c := c0 - half = ncase >> 1 - for i = 1; i < half; i++ { + half := ncase >> 1 + for i := 1; i < half; i++ { c = c.link } - a = Nod(OIF, nil, nil) + a := Nod(OIF, nil, nil) a.Ntest = Nod(OLE, hashname, Nodintconst(int64(c.hash))) typecheck(&a.Ntest, Erv) a.Nbody = list1(typebsw(c0, half)) @@ -716,18 +673,6 @@ * into if statements */ func typeswitch(sw *Node) { - var def *Node - var cas *NodeList - var hash *NodeList - var a *Node - var n *Node - var c *Case - var c0 *Case - var c1 *Case - var ncase int - var t *Type - var v Val - if sw.Ntest == nil { return } @@ -743,7 +688,7 @@ return } - cas = nil + cas := (*NodeList)(nil) /* * predeclare temporary variables @@ -751,7 +696,7 @@ */ facename = temp(sw.Ntest.Right.Type) - a = Nod(OAS, facename, sw.Ntest.Right) + a := Nod(OAS, facename, sw.Ntest.Right) typecheck(&a, Etop) cas = list(cas, a) @@ -763,7 +708,7 @@ hashname = temp(Types[TUINT32]) typecheck(&hashname, Erv) - t = sw.Ntest.Right.Type + t := sw.Ntest.Right.Type if isnilinter(t) { a = syslook("efacethash", 1) } else { @@ -776,7 +721,8 @@ typecheck(&a, Etop) cas = list(cas, a) - c0 = mkcaselist(sw, Stype) + c0 := mkcaselist(sw, Stype) + var def *Node if c0 != nil && c0.type_ == Tdefault { def = c0.node.Right c0 = c0.link @@ -787,7 +733,9 @@ /* * insert if statement into each case block */ - for c = c0; c != nil; c = c.link { + var v Val + var n *Node + for c := c0; c != nil; c = c.link { n = c.node switch c.type_ { case Ttypenil: @@ -807,6 +755,10 @@ /* * generate list of if statements, binary search for constant sequences */ + var ncase int + var c1 *Case + var hash *NodeList + var c *Case for c0 != nil { if c0.type_ != Ttypeconst { n = c0.node @@ -895,22 +847,11 @@ */ func typecheckswitch(n *Node) { var top int - var lno int - var ptr int - var nilonly string var t *Type - var badtype *Type - var missing *Type - var have *Type - var l *NodeList - var ll *NodeList - var ncase *Node - var nvar *Node - var def *Node - lno = int(lineno) + lno := int(lineno) typechecklist(n.Ninit, Etop) - nilonly = "" + nilonly := "" if n.Ntest != nil && n.Ntest.Op == OTYPESW { // type switch @@ -933,6 +874,7 @@ t = Types[TBOOL] } if t != nil { + var badtype *Type if okforeq[t.Etype] == 0 { Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong)) } else if t.Etype == TARRAY && !Isfixedarray(t) { @@ -951,8 +893,14 @@ n.Type = t - def = nil - for l = n.List; l != nil; l = l.Next { + def := (*Node)(nil) + var ptr int + var have *Type + var nvar *Node + var ll *NodeList + var missing *Type + var ncase *Node + for l := n.List; l != nil; l = l.Next { ncase = l.N setlineno(n) if ncase.List == nil {
diff --git a/src/cmd/internal/gc/typecheck.go b/src/cmd/internal/gc/typecheck.go index 3cd7408..9fa1930 100644 --- a/src/cmd/internal/gc/typecheck.go +++ b/src/cmd/internal/gc/typecheck.go
@@ -24,10 +24,8 @@ * resolve ONONAME to definition, if any. */ func resolve(n *Node) *Node { - var r *Node - if n != nil && n.Op == ONONAME && n.Sym != nil { - r = n.Sym.Def + r := n.Sym.Def if r != nil { if r.Op != OIOTA { n = r @@ -80,15 +78,12 @@ var typekind_buf string func typekind(t *Type) string { - var et int - var s string - if Isslice(t) { return "slice" } - et = int(t.Etype) + et := int(t.Etype) if 0 <= et && et < len(_typekind) { - s = _typekind[et] + s := _typekind[et] if s != "" { return s } @@ -104,9 +99,7 @@ * to print constant definition loops. */ func sprint_depchain(fmt_ *string, stack *NodeList, cur *Node, first *Node) { - var l *NodeList - - for l = stack; l != nil; l = l.Next { + for l := stack; l != nil; l = l.Next { if l.N.Op == cur.Op { if l.N != first { sprint_depchain(fmt_, l.Next, l.N, first) @@ -127,22 +120,17 @@ var typecheck_tcfree *NodeList func typecheck(np **Node, top int) *Node { - var n *Node - var lno int - var fmt_ string - var l *NodeList - // cannot type check until all the source has been parsed if typecheckok == 0 { Fatal("early typecheck") } - n = *np + n := *np if n == nil { return nil } - lno = int(setlineno(n)) + lno := int(setlineno(n)) // Skip over parens. for n.Op == OPAREN { @@ -173,6 +161,7 @@ if n.Typecheck == 2 { // Typechecking loop. Trying printing a meaningful message, // otherwise a stack trace of typechecking. + var fmt_ string switch n.Op { // We can already diagnose variables used as types. case ONAME: @@ -193,7 +182,7 @@ if nsavederrors+nerrors == 0 { fmt_ = "" - for l = typecheck_tcstack; l != nil; l = l.Next { + for l := typecheck_tcstack; l != nil; l = l.Next { fmt_ += fmt.Sprintf("\n\t%v %v", l.N.Line(), Nconv(l.N, 0)) } Yyerror("typechecking loop involving %v%s", Nconv(n, 0), fmt_) @@ -205,6 +194,7 @@ n.Typecheck = 2 + var l *NodeList if typecheck_tcfree != nil { l = typecheck_tcfree typecheck_tcfree = l.Next @@ -270,9 +260,7 @@ // except for constants of numerical kind, which are acceptable // whenever they can be represented by a value of type int. func indexlit(np **Node) { - var n *Node - - n = *np + n := *np if n == nil || !isideal(n.Type) { return } @@ -292,13 +280,11 @@ var aop int var op int var ptr int - var n *Node var l *Node var r *Node var lo *Node var mid *Node var hi *Node - var args *NodeList var ok int var ntop int var t *Type @@ -308,11 +294,9 @@ var badtype *Type var v Val var why string - var desc string - var descbuf string var x int64 - n = *np + n := *np if n.Sym != nil { if n.Op == ONAME && n.Etype != 0 && top&Ecall == 0 { @@ -1046,7 +1030,7 @@ } defaultlit(&n.Left, nil) - l = n.Left + l := n.Left if l.Op == OTYPE { if n.Isddd != 0 || l.Type.Bound == -100 { if l.Type.Broke == 0 { @@ -1074,7 +1058,7 @@ } else { typechecklist(n.List, Erv) } - t = l.Type + t := l.Type if t == nil { goto error } @@ -1091,7 +1075,7 @@ // information further down the call chain to know if we // were testing a method receiver for unexported fields. // It isn't necessary, so just do a sanity check. - tp = getthisx(t).Type.Type + tp := getthisx(t).Type.Type if l.Left == nil || !Eqtype(l.Left.Type, tp) { Fatal("method receiver") @@ -1105,8 +1089,8 @@ } } - descbuf = fmt.Sprintf("argument to %v", Nconv(n.Left, 0)) - desc = descbuf + descbuf := fmt.Sprintf("argument to %v", Nconv(n.Left, 0)) + desc := descbuf typecheckaste(OCALL, n.Left, int(n.Isddd), getinargx(t), n.List, desc) ok |= Etop if t.Outtuple == 0 { @@ -1114,7 +1098,7 @@ } ok |= Erv if t.Outtuple == 1 { - t = getoutargx(l.Type).Type + t := getoutargx(l.Type).Type if t == nil { goto error } @@ -1145,8 +1129,8 @@ typecheck(&n.Left, Erv) defaultlit(&n.Left, nil) implicitstar(&n.Left) - l = n.Left - t = l.Type + l := n.Left + t := l.Type if t == nil { goto error } @@ -1167,7 +1151,7 @@ goto badcall1 } if Isconst(l, CTCPLX) { - r = n + r := n if n.Op == OREAL { n = nodfltconst(&l.Val.U.Cval.Real) } else { @@ -1184,7 +1168,7 @@ switch t.Etype { case TSTRING: if Isconst(l, CTSTR) { - r = Nod(OXXX, nil, nil) + r := Nod(OXXX, nil, nil) Nodconst(r, Types[TINT], int64(len(l.Val.U.Sval.S))) r.Orig = n n = r @@ -1197,7 +1181,7 @@ if callrecv(l) { // has call or receive break } - r = Nod(OXXX, nil, nil) + r := Nod(OXXX, nil, nil) Nodconst(r, Types[TINT], t.Bound) r.Orig = n n = r @@ -1208,6 +1192,8 @@ case OCOMPLEX: ok |= Erv + var r *Node + var l *Node if count(n.List) == 1 { typechecklist(n.List, Efnstruct) if n.List.N.Op != OCALLFUNC && n.List.N.Op != OCALLMETH { @@ -1215,7 +1201,7 @@ goto error } - t = n.List.N.Left.Type + t := n.List.N.Left.Type if t.Outtuple != 2 { Yyerror("invalid operation: complex expects two arguments, %v returns %d results", Nconv(n.List.N, 0), t.Outtuple) goto error @@ -1246,6 +1232,7 @@ goto error } + var t *Type switch l.Type.Etype { default: Yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", Nconv(n, 0), Tconv(l.Type, 0), r.Type) @@ -1278,8 +1265,8 @@ } typecheck(&n.Left, Erv) defaultlit(&n.Left, nil) - l = n.Left - t = l.Type + l := n.Left + t := l.Type if t == nil { goto error } @@ -1297,7 +1284,7 @@ goto ret case ODELETE: - args = n.List + args := n.List if args == nil { Yyerror("missing arguments to delete") goto error @@ -1315,8 +1302,8 @@ ok |= Etop typechecklist(args, Erv) - l = args.N - r = args.Next.N + l := args.N + r := args.Next.N if l.Type != nil && l.Type.Etype != TMAP { Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, obj.FmtLong)) goto error @@ -1327,7 +1314,7 @@ case OAPPEND: ok |= Erv - args = n.List + args := n.List if args == nil { Yyerror("missing arguments to append") goto error @@ -1339,7 +1326,7 @@ typechecklist(args, Erv) } - t = args.N.Type + t := args.N.Type if t == nil { goto error } @@ -1394,7 +1381,7 @@ case OCOPY: ok |= Etop | Erv - args = n.List + args := n.List if args == nil || args.Next == nil { Yyerror("missing arguments to copy") goto error @@ -1452,17 +1439,17 @@ case OMAKE: ok |= Erv - args = n.List + args := n.List if args == nil { Yyerror("missing argument to make") goto error } n.List = nil - l = args.N + l := args.N args = args.Next typecheck(&l, Etype) - t = l.Type + t := l.Type if t == nil { goto error } @@ -1486,7 +1473,7 @@ l = args.N args = args.Next typecheck(&l, Erv) - r = nil + r := (*Node)(nil) if args != nil { r = args.N args = args.Next @@ -1496,7 +1483,7 @@ if l.Type == nil || (r != nil && r.Type == nil) { goto error } - et = bool2int(checkmake(t, "len", l) < 0) + et := bool2int(checkmake(t, "len", l) < 0) et |= bool2int(r != nil && checkmake(t, "cap", r) < 0) if et != 0 { goto error @@ -1559,15 +1546,15 @@ case ONEW: ok |= Erv - args = n.List + args := n.List if args == nil { Yyerror("missing argument to new") goto error } - l = args.N + l := args.N typecheck(&l, Etype) - t = l.Type + t := l.Type if t == nil { goto error } @@ -1584,7 +1571,7 @@ OPRINTN: ok |= Etop typechecklist(n.List, Erv|Eindir) // Eindir: address does not escape - for args = n.List; args != nil; args = args.Next { + for args := n.List; args != nil; args = args.Next { // Special case for print: int constant is int64, not int. if Isconst(args.N, CTINT) { defaultlit(&args.N, Types[TINT64]) @@ -1628,7 +1615,7 @@ case OITAB: ok |= Erv typecheck(&n.Left, Erv) - t = n.Left.Type + t := n.Left.Type if t == nil { goto error } @@ -1641,7 +1628,7 @@ case OSPTR: ok |= Erv typecheck(&n.Left, Erv) - t = n.Left.Type + t := n.Left.Type if t == nil { goto error } @@ -1724,7 +1711,7 @@ decldepth++ typecheck(&n.Ntest, Erv) if n.Ntest != nil { - t = n.Ntest.Type + t := n.Ntest.Type if t != nil && t.Etype != TBOOL { Yyerror("non-bool %v used as for condition", Nconv(n.Ntest, obj.FmtLong)) } @@ -1739,7 +1726,7 @@ typechecklist(n.Ninit, Etop) typecheck(&n.Ntest, Erv) if n.Ntest != nil { - t = n.Ntest.Type + t := n.Ntest.Type if t != nil && t.Etype != TBOOL { Yyerror("non-bool %v used as if condition", Nconv(n.Ntest, obj.FmtLong)) } @@ -2049,7 +2036,7 @@ switch n.Op { case OCONVNOP: if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] { - r = Nod(OXXX, nil, nil) + r := Nod(OXXX, nil, nil) n.Op = OCONV n.Orig = r *r = *n @@ -2135,9 +2122,7 @@ } func checksliceindex(l *Node, r *Node, tp *Type) int { - var t *Type - - t = r.Type + t := r.Type if t == nil { return -1 } @@ -2175,9 +2160,7 @@ } func checkdefergo(n *Node) { - var what string - - what = "defer" + what := "defer" if n.Op == OPROC { what = "go" } @@ -2231,13 +2214,10 @@ } func implicitstar(nn **Node) { - var t *Type - var n *Node - // insert implicit * if needed for fixed array - n = *nn + n := *nn - t = n.Type + t := n.Type if t == nil || Isptr[t.Etype] == 0 { return } @@ -2255,19 +2235,17 @@ } func onearg(n *Node, f string, args ...interface{}) int { - var p string - if n.Left != nil { return 0 } if n.List == nil { - p = fmt.Sprintf(f, args...) + p := fmt.Sprintf(f, args...) Yyerror("missing argument to %s: %v", p, Nconv(n, 0)) return -1 } if n.List.Next != nil { - p = fmt.Sprintf(f, args...) + p := fmt.Sprintf(f, args...) Yyerror("too many arguments to %s: %v", p, Nconv(n, 0)) n.Left = n.List.N n.List = nil @@ -2307,9 +2285,7 @@ } func lookdot1(errnode *Node, s *Sym, t *Type, f *Type, dostrcmp int) *Type { - var r *Type - - r = nil + r := (*Type)(nil) for ; f != nil; f = f.Down { if dostrcmp != 0 && f.Sym.Name == s.Name { return f @@ -2335,14 +2311,10 @@ } func looktypedot(n *Node, t *Type, dostrcmp int) bool { - var f1 *Type - var f2 *Type - var s *Sym - - s = n.Right.Sym + s := n.Right.Sym if t.Etype == TINTER { - f1 = lookdot1(n, s, t, t.Type, dostrcmp) + f1 := lookdot1(n, s, t, t.Type, dostrcmp) if f1 == nil { return false } @@ -2356,7 +2328,7 @@ // Find the base type: methtype will fail if t // is not of the form T or *T. - f2 = methtype(t, 0) + f2 := methtype(t, 0) if f2 == nil { return false @@ -2389,21 +2361,15 @@ } func lookdot(n *Node, t *Type, dostrcmp int) bool { - var f1 *Type - var f2 *Type - var tt *Type - var rcvr *Type - var s *Sym - - s = n.Right.Sym + s := n.Right.Sym dowidth(t) - f1 = nil + f1 := (*Type)(nil) if t.Etype == TSTRUCT || t.Etype == TINTER { f1 = lookdot1(n, s, t, t.Type, dostrcmp) } - f2 = nil + f2 := (*Type)(nil) if n.Left.Type == t || n.Left.Type.Sym == nil { f2 = methtype(t, 0) if f2 != nil { @@ -2437,9 +2403,9 @@ } if f2 != nil { - tt = n.Left.Type + tt := n.Left.Type dowidth(tt) - rcvr = getthisx(f2.Type).Type.Type + rcvr := getthisx(f2.Type).Type.Type if !Eqtype(rcvr, tt) { if int(rcvr.Etype) == Tptr && Eqtype(rcvr.Type, tt) { checklvalue(n.Left, "call pointer method on") @@ -2490,9 +2456,7 @@ } func hasddd(t *Type) bool { - var tl *Type - - for tl = t.Type; tl != nil; tl = tl.Down { + for tl := t.Type; tl != nil; tl = tl.Down { if tl.Isddd != 0 { return true } @@ -2502,11 +2466,8 @@ } func downcount(t *Type) int { - var tl *Type - var n int - - n = 0 - for tl = t.Type; tl != nil; tl = tl.Down { + n := 0 + for tl := t.Type; tl != nil; tl = tl.Down { n++ } @@ -2518,15 +2479,11 @@ */ func typecheckaste(op int, call *Node, isddd int, tstruct *Type, nl *NodeList, desc string) { var t *Type - var tl *Type - var tn *Type var n *Node - var lno int - var why string var n1 int var n2 int - lno = int(lineno) + lno := int(lineno) if tstruct.Broke != 0 { goto out @@ -2538,8 +2495,8 @@ if n.Type != nil { if n.Type.Etype == TSTRUCT && n.Type.Funarg != 0 { if !hasddd(tstruct) { - n1 = downcount(tstruct) - n2 = downcount(n.Type) + n1 := downcount(tstruct) + n2 := downcount(n.Type) if n2 > n1 { goto toomany } @@ -2548,8 +2505,9 @@ } } - tn = n.Type.Type - for tl = tstruct.Type; tl != nil; tl = tl.Down { + tn := n.Type.Type + var why string + for tl := tstruct.Type; tl != nil; tl = tl.Down { if tl.Isddd != 0 { for ; tn != nil; tn = tn.Down { if assignop(tn.Type, tl.Type.Type, &why) == 0 { @@ -2610,7 +2568,7 @@ } } - for tl = tstruct.Type; tl != nil; tl = tl.Down { + for tl := tstruct.Type; tl != nil; tl = tl.Down { t = tl.Type if tl.Isddd != 0 { if isddd != 0 { @@ -2692,16 +2650,12 @@ * type check composite */ func fielddup(n *Node, hash []*Node) { - var h uint - var s string - var a *Node - if n.Op != ONAME { Fatal("fielddup: not ONAME") } - s = n.Sym.Name - h = uint(stringhash(s) % uint32(len(hash))) - for a = hash[h]; a != nil; a = a.Ntest { + s := n.Sym.Name + h := uint(stringhash(s) % uint32(len(hash))) + for a := hash[h]; a != nil; a = a.Ntest { if a.Sym.Name == s { Yyerror("duplicate field name in struct literal: %s", s) return @@ -2713,16 +2667,7 @@ } func keydup(n *Node, hash []*Node) { - var h uint - var b uint32 - var d float64 - var i int - var a *Node - var orign *Node - var cmp Node - var s string - - orign = n + orign := n if n.Op == OCONVIFACE { n = n.Left } @@ -2731,6 +2676,7 @@ return // we dont check variables } + var b uint32 switch n.Val.Ctype { default: // unknown, bool, nil b = 23 @@ -2740,7 +2686,7 @@ b = uint32(Mpgetfix(n.Val.U.Xval)) case CTFLT: - d = mpgetflt(n.Val.U.Fval) + d := mpgetflt(n.Val.U.Fval) x := math.Float64bits(d) for i := 0; i < 8; i++ { b = b*PRIME1 + uint32(x&0xFF) @@ -2749,16 +2695,16 @@ case CTSTR: b = 0 - s = n.Val.U.Sval.S - for i = len(n.Val.U.Sval.S); i > 0; i-- { + s := n.Val.U.Sval.S + for i := len(n.Val.U.Sval.S); i > 0; i-- { b = b*PRIME1 + uint32(s[0]) s = s[1:] } } - h = uint(b % uint32(len(hash))) - cmp = Node{} - for a = hash[h]; a != nil; a = a.Ntest { + h := uint(b % uint32(len(hash))) + cmp := Node{} + for a := hash[h]; a != nil; a = a.Ntest { cmp.Op = OEQ cmp.Left = n b = 0 @@ -2785,18 +2731,14 @@ } func indexdup(n *Node, hash []*Node) { - var h uint - var a *Node - var b uint32 - var c uint32 - if n.Op != OLITERAL { Fatal("indexdup: not OLITERAL") } - b = uint32(Mpgetfix(n.Val.U.Xval)) - h = uint(b % uint32(len(hash))) - for a = hash[h]; a != nil; a = a.Ntest { + b := uint32(Mpgetfix(n.Val.U.Xval)) + h := uint(b % uint32(len(hash))) + var c uint32 + for a := hash[h]; a != nil; a = a.Ntest { c = uint32(Mpgetfix(a.Val.U.Xval)) if b == c { Yyerror("duplicate index in array literal: %d", b) @@ -2809,9 +2751,7 @@ } func prime(h uint32, sr uint32) bool { - var n uint32 - - for n = 3; n <= sr; n += 2 { + for n := uint32(3); n <= sr; n += 2 { if h%n == 0 { return false } @@ -2820,15 +2760,10 @@ } func inithash(n *Node, autohash []*Node) []*Node { - var h uint32 - var sr uint32 - var ll *NodeList - var i int - // count the number of entries - h = 0 + h := uint32(0) - for ll = n.List; ll != nil; ll = ll.Next { + for ll := n.List; ll != nil; ll = ll.Next { h++ } @@ -2847,9 +2782,9 @@ h |= 1 // calculate sqrt of h - sr = h / 2 + sr := h / 2 - for i = 0; i < 5; i++ { + for i := 0; i < 5; i++ { sr = (sr + h/sr) / 2 } @@ -2900,25 +2835,14 @@ } func typecheckcomplit(np **Node) { - var bad int - var i int var nerr int - var length int64 var l *Node - var n *Node var norig *Node var r *Node - var hash []*Node - var ll *NodeList var t *Type - var f *Type - var s *Sym - var s1 *Sym - var lno int32 - var autohash [101]*Node - n = *np - lno = lineno + n := *np + lno := lineno if n.Right == nil { if n.List != nil { @@ -2965,11 +2889,13 @@ n.Type = nil case TARRAY: - hash = inithash(n, autohash[:]) + var autohash [101]*Node + hash := inithash(n, autohash[:]) - length = 0 - i = 0 - for ll = n.List; ll != nil; ll = ll.Next { + length := int64(0) + i := 0 + var l *Node + for ll := n.List; ll != nil; ll = ll.Next { l = ll.N setlineno(l) if l.Op != OKEY { @@ -3017,9 +2943,11 @@ n.Op = OARRAYLIT case TMAP: - hash = inithash(n, autohash[:]) + var autohash [101]*Node + hash := inithash(n, autohash[:]) - for ll = n.List; ll != nil; ll = ll.Next { + var l *Node + for ll := n.List; ll != nil; ll = ll.Next { l = ll.N setlineno(l) if l.Op != OKEY { @@ -3045,12 +2973,13 @@ n.Op = OMAPLIT case TSTRUCT: - bad = 0 + bad := 0 if n.List != nil && nokeys(n.List) { // simple list of variables - f = t.Type + f := t.Type - for ll = n.List; ll != nil; ll = ll.Next { + var s *Sym + for ll := n.List; ll != nil; ll = ll.Next { setlineno(ll.N) typecheck(&ll.N, Erv) if f == nil { @@ -3080,10 +3009,15 @@ Yyerror("too few values in struct initializer") } } else { - hash = inithash(n, autohash[:]) + var autohash [101]*Node + hash := inithash(n, autohash[:]) // keyed list - for ll = n.List; ll != nil; ll = ll.Next { + var s *Sym + var f *Type + var l *Node + var s1 *Sym + for ll := n.List; ll != nil; ll = ll.Next { l = ll.N setlineno(l) if l.Op != OKEY { @@ -3201,12 +3135,10 @@ } func checkassign(stmt *Node, n *Node) { - var r *Node - var l *Node - // Variables declared in ORANGE are assigned on every iteration. if n.Defn != stmt || stmt.Op == ORANGE { - r = outervalue(n) + r := outervalue(n) + var l *Node for l = n; l != r; l = l.Left { l.Assigned = 1 if l.Closure != nil { @@ -3345,14 +3277,8 @@ } func typecheckas2(n *Node) { - var cl int - var cr int var ll *NodeList var lr *NodeList - var l *Node - var r *Node - var s Iter - var t *Type for ll = n.List; ll != nil; ll = ll.Next { // delicate little dance. @@ -3363,8 +3289,8 @@ } } - cl = count(n.List) - cr = count(n.Rlist) + cl := count(n.List) + cr := count(n.Rlist) if cl > 1 && cr == 1 { typecheck(&n.Rlist.N, Erv|Efnstruct) } else { @@ -3372,6 +3298,8 @@ } checkassignlist(n, n.List) + var l *Node + var r *Node if cl == cr { // easy ll = n.List @@ -3409,7 +3337,8 @@ goto mismatch } n.Op = OAS2FUNC - t = Structfirst(&s, &r.Type) + var s Iter + t := Structfirst(&s, &r.Type) for ll = n.List; ll != nil; ll = ll.Next { if t.Type != nil && ll.N.Type != nil { checkassignto(t.Type, ll.N) @@ -3451,7 +3380,7 @@ if l.Defn == n { l.Type = r.Type } - l = n.List.Next.N + l := n.List.Next.N if l.Type != nil && l.Type.Etype != TBOOL { checkassignto(Types[TBOOL], l) } @@ -3480,23 +3409,19 @@ * type check function definition */ func typecheckfunc(n *Node) { - var t *Type - var rcvr *Type - var l *NodeList - typecheck(&n.Nname, Erv|Easgn) - t = n.Nname.Type + t := n.Nname.Type if t == nil { return } n.Type = t t.Nname = n.Nname - rcvr = getthisx(t).Type + rcvr := getthisx(t).Type if rcvr != nil && n.Shortname != nil && !isblank(n.Shortname) { addmethod(n.Shortname.Sym, t, true, n.Nname.Nointerface) } - for l = n.Dcl; l != nil; l = l.Next { + for l := n.Dcl; l != nil; l = l.Next { if l.N.Op == ONAME && (l.N.Class == PPARAM || l.N.Class == PPARAMOUT) { l.N.Decldepth = 1 } @@ -3536,10 +3461,7 @@ var methodqueue *NodeList func domethod(n *Node) { - var nt *Node - var t *Type - - nt = n.Type.Nname + nt := n.Type.Nname typecheck(&nt, Etype) if nt.Type == nil { // type check failed; leave empty func @@ -3557,7 +3479,7 @@ // value of its argument, a specific implementation of I may // care. The _ would suppress the assignment to that argument // while generating a call, so remove it. - for t = getinargx(nt.Type).Type; t != nil; t = t.Down { + for t := getinargx(nt.Type).Type; t != nil; t = t.Down { if t.Sym != nil && t.Sym.Name == "_" { t.Sym = nil } @@ -3571,11 +3493,6 @@ var mapqueue *NodeList func copytype(n *Node, t *Type) { - var maplineno int - var embedlineno int - var lno int - var l *NodeList - if t.Etype == TFORW { // This type isn't computed yet; when it is, update n. t.Copyto = list(t.Copyto, n) @@ -3583,10 +3500,10 @@ return } - maplineno = int(n.Type.Maplineno) - embedlineno = int(n.Type.Embedlineno) + maplineno := int(n.Type.Maplineno) + embedlineno := int(n.Type.Embedlineno) - l = n.Type.Copyto + l := n.Type.Copyto *n.Type = *t t = n.Type @@ -3607,7 +3524,7 @@ } // Double-check use of type as embedded type. - lno = int(lineno) + lno := int(lineno) if embedlineno != 0 { lineno = int32(embedlineno) @@ -3626,17 +3543,13 @@ } func typecheckdeftype(n *Node) { - var lno int - var t *Type - var l *NodeList - ntypecheckdeftype++ - lno = int(lineno) + lno := int(lineno) setlineno(n) n.Type.Sym = n.Sym n.Typecheck = 1 typecheck(&n.Ntype, Etype) - t = n.Ntype.Type + t := n.Ntype.Type if t == nil { n.Diag = 1 n.Type = nil @@ -3661,6 +3574,7 @@ // try to resolve the method types for the interfaces // we just read. if ntypecheckdeftype == 1 { + var l *NodeList for { l = methodqueue if l == nil { @@ -3672,7 +3586,7 @@ } } - for l = mapqueue; l != nil; l = l.Next { + for l := mapqueue; l != nil; l = l.Next { lineno = l.N.Type.Maplineno maptype(l.N.Type, Types[TBOOL]) } @@ -3693,13 +3607,7 @@ } func typecheckdef(n *Node) *Node { - var lno int - var nerrors0 int - var e *Node - var t *Type - var l *NodeList - - lno = int(lineno) + lno := int(lineno) setlineno(n) if n.Op == ONONAME { @@ -3721,7 +3629,7 @@ return n } - l = new(NodeList) + l := new(NodeList) l.N = n l.Next = typecheckdefstack typecheckdefstack = l @@ -3729,7 +3637,7 @@ if n.Walkdef == 2 { Flusherrors() fmt.Printf("typecheckdef loop:") - for l = typecheckdefstack; l != nil; l = l.Next { + for l := typecheckdefstack; l != nil; l = l.Next { fmt.Printf(" %v", Sconv(l.N.Sym, 0)) } fmt.Printf("\n") @@ -3762,7 +3670,7 @@ } } - e = n.Defn + e := n.Defn n.Defn = nil if e == nil { lineno = n.Lineno @@ -3785,7 +3693,7 @@ goto ret } - t = n.Type + t := n.Type if t != nil { if okforconst[t.Etype] == 0 { Yyerror("invalid constant type %v", Tconv(t, 0)) @@ -3847,7 +3755,7 @@ n.Walkdef = 1 n.Type = typ(TFORW) n.Type.Sym = n.Sym - nerrors0 = nerrors + nerrors0 := nerrors typecheckdeftype(n) if n.Type.Etype == TFORW && nerrors > nerrors0 { // Something went wrong during type-checking, @@ -3920,8 +3828,6 @@ } func markbreak(n *Node, implicit *Node) { - var lab *Label - if n == nil { return } @@ -3933,7 +3839,7 @@ implicit.Hasbreak = 1 } } else { - lab = n.Left.Sym.Label + lab := n.Left.Sym.Label if lab != nil { lab.Def.Hasbreak = 1 } @@ -3990,9 +3896,6 @@ } func isterminating(l *NodeList, top int) bool { - var def int - var n *Node - if l == nil { return false } @@ -4006,7 +3909,7 @@ for l.Next != nil { l = l.Next } - n = l.N + n := l.N if n == nil { return false @@ -4046,7 +3949,7 @@ if n.Hasbreak != 0 { return false } - def = 0 + def := 0 for l = n.List; l != nil; l = l.Next { if !isterminating(l.N.Nbody, 0) { return false
diff --git a/src/cmd/internal/gc/unsafe.go b/src/cmd/internal/gc/unsafe.go index 3970468..7f0a33f 100644 --- a/src/cmd/internal/gc/unsafe.go +++ b/src/cmd/internal/gc/unsafe.go
@@ -15,19 +15,11 @@ */ func unsafenmagic(nn *Node) *Node { var r *Node - var n *Node - var base *Node - var r1 *Node var s *Sym - var t *Type - var tr *Type var v int64 - var val Val - var fn *Node - var args *NodeList - fn = nn.Left - args = nn.List + fn := nn.Left + args := nn.List if safemode != 0 || fn == nil || fn.Op != ONAME { goto no @@ -50,7 +42,7 @@ if s.Name == "Sizeof" { typecheck(&r, Erv) defaultlit(&r, nil) - tr = r.Type + tr := r.Type if tr == nil { goto bad } @@ -70,7 +62,7 @@ // first to track it correctly. typecheck(&r.Left, Erv) - base = r.Left + base := r.Left typecheck(&r, Erv) switch r.Op { case ODOT, @@ -89,6 +81,7 @@ v = 0 // add offsets for inserted dots. + var r1 *Node for r1 = r; r1.Left != base; r1 = r1.Left { switch r1.Op { case ODOT: @@ -112,13 +105,13 @@ if s.Name == "Alignof" { typecheck(&r, Erv) defaultlit(&r, nil) - tr = r.Type + tr := r.Type if tr == nil { goto bad } // make struct { byte; T; } - t = typ(TSTRUCT) + t := typ(TSTRUCT) t.Type = typ(TFIELD) t.Type.Type = Types[TUINT8] @@ -149,11 +142,12 @@ // any side effects disappear; ignore init ret: + var val Val val.Ctype = CTINT val.U.Xval = new(Mpint) Mpmovecfix(val.U.Xval, v) - n = Nod(OLITERAL, nil, nil) + n := Nod(OLITERAL, nil, nil) n.Orig = nn n.Val = val n.Type = Types[TUINTPTR]
diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go index dfb965e..b242fd4 100644 --- a/src/cmd/internal/gc/walk.go +++ b/src/cmd/internal/gc/walk.go
@@ -18,35 +18,31 @@ ) 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 @@ } 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 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 @@ // 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 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ // 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 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 @@ return } - lno = setlineno(n) + lno := setlineno(n) if Debug['w'] > 1 { Dump("walk-before", n) @@ -515,7 +477,7 @@ // 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 @@ 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 @@ // 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 @@ // 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 @@ 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 @@ // 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 @@ } } - t = n.Left.Type + t := n.Left.Type if n.List != nil && n.List.N.Op == OAS { goto ret } @@ -670,19 +632,19 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ *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 @@ *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 @@ *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 @@ } } + var key *Node if p != "" { // fast versions take key by value key = r.Right @@ -851,9 +815,9 @@ // 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 @@ // 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 @@ 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 @@ *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 @@ } 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 @@ } 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 @@ // 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 @@ // 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 @@ 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 @@ 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 @@ 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 @@ * 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 @@ /* * 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 @@ // 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 @@ 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 @@ // 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 @@ 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 @@ } } + var key *Node if p != "" { // fast versions take key by value key = n.Right @@ -1325,7 +1291,7 @@ 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 @@ // 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 @@ // 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ // 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 @@ // 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 @@ // 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 @@ 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 @@ 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 @@ 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 @@ // 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 @@ } 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 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 @@ 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 @@ * 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 @@ 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 @@ * 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 @@ 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 @@ * 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 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(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 @@ // 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 @@ 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 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 @@ 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 @@ } 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 @@ 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 @@ 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 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 @@ } 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 @@ * 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 @@ 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 @@ * 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 @@ * 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 @@ * 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 @@ // 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 @@ * 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 @@ 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 @@ * called by sinit.c */ func vmatch1(l *Node, r *Node) bool { - var ll *NodeList - /* * isolate all left sides */ @@ -2767,7 +2673,7 @@ 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 @@ * 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 @@ * 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 @@ * 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 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 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 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 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 @@ // 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 @@ // 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 @@ 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 @@ // // 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 @@ 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 @@ 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 @@ } 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 @@ // } // 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 @@ // 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ } 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 @@ // 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 @@ } 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 @@ // 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 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 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 @@ // 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 @@ 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 @@ 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 @@ 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 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 @@ } // 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 @@ 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 @@ * 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 @@ 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 @@ * 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 @@ return } + var n1 *Node + var m Magic + var n2 *Node if pow < 0 { goto divbymul } @@ -4025,32 +3821,32 @@ // 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 @@ // 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 @@ 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ 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 usefield(n *Node) { - var field *Type - var l *Type - if obj.Fieldtrack_enabled == 0 { return } @@ -4317,7 +4107,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ fn.Nname.Ntype = t declare(fn.Nname, PFUNC) - oldfn = Curfn + oldfn := Curfn Curfn = nil funchdr(fn)
diff --git a/src/cmd/internal/obj/data.go b/src/cmd/internal/obj/data.go index 66995a3..39e1ce5 100644 --- a/src/cmd/internal/obj/data.go +++ b/src/cmd/internal/obj/data.go
@@ -41,8 +41,7 @@ } func Symgrow(ctxt *Link, s *LSym, lsiz int64) { - var siz int - siz = int(lsiz) + siz := int(lsiz) if int64(siz) != lsiz { log.Fatal("Symgrow size %d too long", lsiz) } @@ -143,9 +142,7 @@ } func adduintxx(ctxt *Link, s *LSym, v uint64, wid int) int64 { - var off int64 - - off = s.Size + off := s.Size Setuintxx(ctxt, s, off, v, int64(wid)) return off } @@ -183,17 +180,14 @@ } func addaddrplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 { - var i int64 - var r *Reloc - if s.Type == 0 { s.Type = SDATA } s.Reachable = 1 - i = s.Size + i := s.Size s.Size += int64(ctxt.Arch.Ptrsize) Symgrow(ctxt, s, s.Size) - r = Addrel(s) + r := Addrel(s) r.Sym = t r.Off = int32(i) r.Siz = uint8(ctxt.Arch.Ptrsize) @@ -203,17 +197,14 @@ } func addpcrelplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 { - var i int64 - var r *Reloc - if s.Type == 0 { s.Type = SDATA } s.Reachable = 1 - i = s.Size + i := s.Size s.Size += 4 Symgrow(ctxt, s, s.Size) - r = Addrel(s) + r := Addrel(s) r.Sym = t r.Off = int32(i) r.Add = add @@ -227,8 +218,6 @@ } func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 { - var r *Reloc - if s.Type == 0 { s.Type = SDATA } @@ -238,7 +227,7 @@ Symgrow(ctxt, s, s.Size) } - r = Addrel(s) + r := Addrel(s) r.Sym = t r.Off = int32(off) r.Siz = uint8(ctxt.Arch.Ptrsize) @@ -252,17 +241,14 @@ } func addsize(ctxt *Link, s *LSym, t *LSym) int64 { - var i int64 - var r *Reloc - if s.Type == 0 { s.Type = SDATA } s.Reachable = 1 - i = s.Size + i := s.Size s.Size += int64(ctxt.Arch.Ptrsize) Symgrow(ctxt, s, s.Size) - r = Addrel(s) + r := Addrel(s) r.Sym = t r.Off = int32(i) r.Siz = uint8(ctxt.Arch.Ptrsize) @@ -271,17 +257,14 @@ } func addaddrplus4(ctxt *Link, s *LSym, t *LSym, add int64) int64 { - var i int64 - var r *Reloc - if s.Type == 0 { s.Type = SDATA } s.Reachable = 1 - i = s.Size + i := s.Size s.Size += 4 Symgrow(ctxt, s, s.Size) - r = Addrel(s) + r := Addrel(s) r.Sym = t r.Off = int32(i) r.Siz = 4
diff --git a/src/cmd/internal/obj/go.go b/src/cmd/internal/obj/go.go index 1bd10fc..496a5b8 100644 --- a/src/cmd/internal/obj/go.go +++ b/src/cmd/internal/obj/go.go
@@ -36,9 +36,7 @@ } func addexp(s string) { - var i int - - for i = 0; i < len(exper); i++ { + for i := 0; i < len(exper); i++ { if exper[i].name == s { if exper[i].val != nil { *exper[i].val = 1
diff --git a/src/cmd/internal/obj/ld.go b/src/cmd/internal/obj/ld.go index 99cf64a..4d2e429 100644 --- a/src/cmd/internal/obj/ld.go +++ b/src/cmd/internal/obj/ld.go
@@ -44,13 +44,11 @@ ) func mkfwd(sym *LSym) { - var p *Prog - var i int var dwn [LOG]int32 var cnt [LOG]int32 var lst [LOG]*Prog - for i = 0; i < LOG; i++ { + for i := 0; i < LOG; i++ { if i == 0 { cnt[i] = 1 } else { @@ -60,8 +58,8 @@ lst[i] = nil } - i = 0 - for p = sym.Text; p != nil && p.Link != nil; p = p.Link { + i := 0 + for p := sym.Text; p != nil && p.Link != nil; p = p.Link { i-- if i < 0 { i = LOG - 1 @@ -79,17 +77,13 @@ } func Copyp(ctxt *Link, q *Prog) *Prog { - var p *Prog - - p = ctxt.NewProg() + p := ctxt.NewProg() *p = *q return p } func Appendp(ctxt *Link, q *Prog) *Prog { - var p *Prog - - p = ctxt.NewProg() + p := ctxt.NewProg() p.Link = q.Link q.Link = p p.Lineno = q.Lineno
diff --git a/src/cmd/internal/obj/obj.go b/src/cmd/internal/obj/obj.go index 214d9ca..05902e2 100644 --- a/src/cmd/internal/obj/obj.go +++ b/src/cmd/internal/obj/obj.go
@@ -25,12 +25,8 @@ lno := int32(lno0) lno1 := lno var d int32 - var i int - var n int - var h *Hist - n = 0 - var fp string - for h = ctxt.Hist; h != nil; h = h.Link { + n := 0 + for h := ctxt.Hist; h != nil; h = h.Link { if h.Offset < 0 { continue } @@ -65,7 +61,8 @@ if n > int(HISTSZ) { n = int(HISTSZ) } - for i = n - 1; i >= 0; i-- { + var fp string + for i := n - 1; i >= 0; i-- { if i != n-1 { if !showAll { break @@ -93,12 +90,12 @@ // For portability, we allow ASCII case folding, so that haspathprefix("a/b/c", "A/B") is true. // Similarly, we allow slash folding, so that haspathprefix("a/b/c", "a\\b") is true. func haspathprefix(s string, t string) bool { - var i int - var cs int - var ct int if len(t) > len(s) { return false } + var i int + var cs int + var ct int for i = 0; i < len(t); i++ { cs = int(s[i]) ct = int(t[i]) @@ -131,17 +128,10 @@ line *Hist ldel int32 } - var lno int32 var d int32 - var dlno int32 - var n int - var h *Hist - var buf string - var buf1 string - var file string - lno = int32(line) - n = 0 - for h = ctxt.Hist; h != nil; h = h.Link { + lno := int32(line) + n := 0 + for h := ctxt.Hist; h != nil; h = h.Link { if h.Offset < 0 { continue } @@ -182,6 +172,8 @@ return } n-- + var dlno int32 + var file string if a[n].line != nil { file = a[n].line.Name dlno = a[n].ldel - 1 @@ -189,6 +181,7 @@ file = a[n].incl.Name dlno = a[n].idel - 1 } + var buf string if filepath.IsAbs(file) || strings.HasPrefix(file, "<") { buf = fmt.Sprintf("%s", file) } else { @@ -199,14 +192,14 @@ if len(buf) == len(ctxt.Trimpath) { buf = "??" } else { - buf1 = fmt.Sprintf("%s", buf[len(ctxt.Trimpath)+1:]) + buf1 := fmt.Sprintf("%s", buf[len(ctxt.Trimpath)+1:]) if buf1[0] == '\x00' { buf1 = "??" } buf = buf1 } } else if ctxt.Goroot_final != "" && haspathprefix(buf, ctxt.Goroot) { - buf1 = fmt.Sprintf("%s%s", ctxt.Goroot_final, buf[len(ctxt.Goroot):]) + buf1 := fmt.Sprintf("%s%s", ctxt.Goroot_final, buf[len(ctxt.Goroot):]) buf = buf1 } lno -= dlno @@ -215,8 +208,6 @@ } func Linklinehist(ctxt *Link, lineno int, f string, offset int) { - var h *Hist - if false { // debug['f'] if f != "" { if offset != 0 { @@ -229,7 +220,7 @@ } } - h = new(Hist) + h := new(Hist) *h = Hist{} h.Name = f h.Line = int32(lineno) @@ -248,12 +239,10 @@ func Linkprfile(ctxt *Link, line int) { l := int32(line) var i int - var n int var a [HISTSZ]Hist - var h *Hist var d int32 - n = 0 - for h = ctxt.Hist; h != nil; h = h.Link { + n := 0 + for h := ctxt.Hist; h != nil; h = h.Link { if l < h.Line { break } @@ -286,7 +275,7 @@ if n > HISTSZ { n = HISTSZ } - for i = 0; i < n; i++ { + for i := 0; i < n; i++ { fmt.Printf("%s:%d ", a[i].Name, int(l-a[i].Line+a[i].Offset+1)) } } @@ -295,9 +284,7 @@ * start a new Prog list. */ func Linknewplist(ctxt *Link) *Plist { - var pl *Plist - - pl = new(Plist) + pl := new(Plist) *pl = Plist{} if ctxt.Plist == nil { ctxt.Plist = pl
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go index b15bd00..6e76a39 100644 --- a/src/cmd/internal/obj/objfile.go +++ b/src/cmd/internal/obj/objfile.go
@@ -18,15 +18,7 @@ // does not write out object files. func Writeobjdirect(ctxt *Link, b *Biobuf) { var flag int - var found int - var h *Hist var s *LSym - var text *LSym - var etext *LSym - var curtext *LSym - var data *LSym - var edata *LSym - var pl *Plist var p *Prog var plink *Prog var a *Auto @@ -34,13 +26,13 @@ // Build list of symbols, and assign instructions to lists. // Ignore ctxt->plist boundaries. There are no guarantees there, // and the C compilers and assemblers just use one big list. - text = nil + text := (*LSym)(nil) - curtext = nil - data = nil - etext = nil - edata = nil - for pl = ctxt.Plist; pl != nil; pl = pl.Link { + curtext := (*LSym)(nil) + data := (*LSym)(nil) + etext := (*LSym)(nil) + edata := (*LSym)(nil) + for pl := ctxt.Plist; pl != nil; pl = pl.Link { for p = pl.Firstpc; p != nil; p = plink { if ctxt.Debugasm != 0 && ctxt.Debugvlog != 0 { fmt.Printf("obj: %v\n", p) @@ -176,7 +168,8 @@ } // Add reference to Go arguments for C or assembly functions without them. - for s = text; s != nil; s = s.Next { + var found int + for s := text; s != nil; s = s.Next { if !strings.HasPrefix(s.Name, "\"\".") { continue } @@ -200,7 +193,7 @@ } // Turn functions into machine code images. - for s = text; s != nil; s = s.Next { + for s := text; s != nil; s = s.Next { mkfwd(s) linkpatch(ctxt, s) ctxt.Arch.Follow(ctxt, s) @@ -217,7 +210,7 @@ Bputc(b, 1) // version // Emit autolib. - for h = ctxt.Hist; h != nil; h = h.Link { + for h := ctxt.Hist; h != nil; h = h.Link { if h.Offset < 0 { wrstring(b, h.Name) } @@ -225,10 +218,10 @@ wrstring(b, "") // Emit symbols. - for s = text; s != nil; s = s.Next { + for s := text; s != nil; s = s.Next { writesym(ctxt, b, s) } - for s = data; s != nil; s = s.Next { + for s := data; s != nil; s = s.Next { writesym(ctxt, b, s) } @@ -240,16 +233,6 @@ } func writesym(ctxt *Link, b *Biobuf, s *LSym) { - var r *Reloc - var i int - var j int - var c int - var n int - var pc *Pcln - var p *Prog - var a *Auto - var name string - if ctxt.Debugasm != 0 { fmt.Fprintf(ctxt.Bso, "%s ", s.Name) if s.Version != 0 { @@ -276,10 +259,12 @@ } fmt.Fprintf(ctxt.Bso, "\n") - for p = s.Text; p != nil; p = p.Link { + for p := s.Text; p != nil; p = p.Link { fmt.Fprintf(ctxt.Bso, "\t%#04x %v\n", uint(int(p.Pc)), p) } - for i = 0; i < len(s.P); { + var c int + var j int + for i := 0; i < len(s.P); { fmt.Fprintf(ctxt.Bso, "\t%#04x", uint(i)) for j = i; j < i+16 && j < len(s.P); j++ { fmt.Fprintf(ctxt.Bso, " %02x", s.P[j]) @@ -301,7 +286,9 @@ i += 16 } - for i = 0; i < len(s.R); i++ { + var r *Reloc + var name string + for i := 0; i < len(s.R); i++ { r = &s.R[i] name = "" if r.Sym != nil { @@ -325,7 +312,8 @@ wrdata(b, s.P) wrint(b, int64(len(s.R))) - for i = 0; i < len(s.R); i++ { + var r *Reloc + for i := 0; i < len(s.R); i++ { r = &s.R[i] wrint(b, int64(r.Off)) wrint(b, int64(r.Siz)) @@ -341,12 +329,12 @@ wrint(b, int64(s.Locals)) wrint(b, int64(s.Nosplit)) wrint(b, int64(s.Leaf)|int64(s.Cfunc)<<1) - n = 0 - for a = s.Autom; a != nil; a = a.Link { + n := 0 + for a := s.Autom; a != nil; a = a.Link { n++ } wrint(b, int64(n)) - for a = s.Autom; a != nil; a = a.Link { + for a := s.Autom; a != nil; a = a.Link { wrsym(b, a.Asym) wrint(b, int64(a.Aoffset)) if a.Name == NAME_AUTO { @@ -359,35 +347,33 @@ wrsym(b, a.Gotype) } - pc = s.Pcln + pc := s.Pcln wrdata(b, pc.Pcsp.P) wrdata(b, pc.Pcfile.P) wrdata(b, pc.Pcline.P) wrint(b, int64(len(pc.Pcdata))) - for i = 0; i < len(pc.Pcdata); i++ { + for i := 0; i < len(pc.Pcdata); i++ { wrdata(b, pc.Pcdata[i].P) } wrint(b, int64(len(pc.Funcdataoff))) - for i = 0; i < len(pc.Funcdataoff); i++ { + for i := 0; i < len(pc.Funcdataoff); i++ { wrsym(b, pc.Funcdata[i]) } - for i = 0; i < len(pc.Funcdataoff); i++ { + for i := 0; i < len(pc.Funcdataoff); i++ { wrint(b, pc.Funcdataoff[i]) } wrint(b, int64(len(pc.File))) - for i = 0; i < len(pc.File); i++ { + for i := 0; i < len(pc.File); i++ { wrpathsym(ctxt, b, pc.File[i]) } } } func wrint(b *Biobuf, sval int64) { - var uv uint64 var v uint64 var buf [10]uint8 - var p []uint8 - uv = (uint64(sval) << 1) ^ uint64(int64(sval>>63)) - p = buf[:] + uv := (uint64(sval) << 1) ^ uint64(int64(sval>>63)) + p := buf[:] for v = uv; v >= 0x80; v >>= 7 { p[0] = uint8(v | 0x80) p = p[1:]
diff --git a/src/cmd/internal/obj/pass.go b/src/cmd/internal/obj/pass.go index 812e00b..b03cd43 100644 --- a/src/cmd/internal/obj/pass.go +++ b/src/cmd/internal/obj/pass.go
@@ -33,9 +33,7 @@ // Code and data passes. func Brchain(ctxt *Link, p *Prog) *Prog { - var i int - - for i = 0; i < 20; i++ { + for i := 0; i < 20; i++ { if p == nil || p.As != AJMP || p.Pcond == nil { return p } @@ -46,10 +44,9 @@ } func brloop(ctxt *Link, p *Prog) *Prog { - var c int var q *Prog - c = 0 + c := 0 for q = p; q != nil; q = q.Pcond { if q.As != AJMP || q.Pcond == nil { break @@ -152,12 +149,11 @@ func linkpatch(ctxt *Link, sym *LSym) { var c int32 var name string - var p *Prog var q *Prog ctxt.Cursym = sym - for p = sym.Text; p != nil; p = p.Link { + for p := sym.Text; p != nil; p = p.Link { checkaddr(ctxt, p, &p.From) checkaddr(ctxt, p, &p.From3) checkaddr(ctxt, p, &p.To) @@ -203,7 +199,7 @@ p.Pcond = q } - for p = sym.Text; p != nil; p = p.Link { + for p := sym.Text; p != nil; p = p.Link { p.Mark = 0 /* initialization for follow */ if p.Pcond != nil { p.Pcond = brloop(ctxt, p.Pcond)
diff --git a/src/cmd/internal/obj/pcln.go b/src/cmd/internal/obj/pcln.go index f5cdd3a..13bb1cd8 100644 --- a/src/cmd/internal/obj/pcln.go +++ b/src/cmd/internal/obj/pcln.go
@@ -28,17 +28,8 @@ // where func is the function, val is the current value, p is the instruction being // considered, and arg can be used to further parameterize valfunc. func funcpctab(ctxt *Link, dst *Pcdata, func_ *LSym, desc string, valfunc func(*Link, *LSym, int32, *Prog, int32, interface{}) int32, arg interface{}) { - var dbg int - var i int - var oldval int32 - var val int32 - var started int32 - var delta uint32 - var pc int64 - var p *Prog - // To debug a specific function, uncomment second line and change name. - dbg = 0 + dbg := 0 //dbg = strcmp(func->name, "main.main") == 0; //dbg = strcmp(desc, "pctofile") == 0; @@ -51,21 +42,22 @@ fmt.Fprintf(ctxt.Bso, "funcpctab %s [valfunc=%s]\n", func_.Name, desc) } - val = -1 - oldval = val + val := int32(-1) + oldval := val if func_.Text == nil { ctxt.Debugpcln -= int32(dbg) return } - pc = func_.Text.Pc + pc := func_.Text.Pc if ctxt.Debugpcln != 0 { fmt.Fprintf(ctxt.Bso, "%6x %6d %v\n", uint64(pc), val, func_.Text) } - started = 0 - for p = func_.Text; p != nil; p = p.Link { + started := int32(0) + var delta uint32 + for p := func_.Text; p != nil; p = p.Link { // Update val. If it's not changing, keep going. val = valfunc(ctxt, func_, val, p, 0, arg) @@ -134,7 +126,7 @@ if ctxt.Debugpcln != 0 { fmt.Fprintf(ctxt.Bso, "wrote %d bytes to %p\n", len(dst.P), dst) - for i = 0; i < len(dst.P); i++ { + for i := 0; i < len(dst.P); i++ { fmt.Fprintf(ctxt.Bso, " %02x", dst.P[i]) } fmt.Fprintf(ctxt.Bso, "\n") @@ -148,14 +140,11 @@ // Because p->lineno applies to p, phase == 0 (before p) // takes care of the update. func pctofileline(ctxt *Link, sym *LSym, oldval int32, p *Prog, phase int32, arg interface{}) int32 { - var i int32 - var l int32 - var f *LSym - var pcln *Pcln - if p.As == ATEXT || p.As == ANOP || p.As == AUSEFIELD || p.Lineno == 0 || phase == 1 { return oldval } + var l int32 + var f *LSym linkgetline(ctxt, p.Lineno, &f, &l) if f == nil { // print("getline failed for %s %P\n", ctxt->cursym->name, p); @@ -165,12 +154,13 @@ if arg == nil { return l } - pcln = arg.(*Pcln) + pcln := arg.(*Pcln) if f == pcln.Lastfile { return int32(pcln.Lastindex) } + var i int32 for i = 0; i < int32(len(pcln.File)); i++ { file := pcln.File[i] if file == f { @@ -222,20 +212,14 @@ } func linkpcln(ctxt *Link, cursym *LSym) { - var p *Prog - var pcln *Pcln - var i int - var npcdata int - var nfuncdata int - ctxt.Cursym = cursym - pcln = new(Pcln) + pcln := new(Pcln) cursym.Pcln = pcln - npcdata = 0 - nfuncdata = 0 - for p = cursym.Text; p != nil; p = p.Link { + npcdata := 0 + nfuncdata := 0 + for p := cursym.Text; p != nil; p = p.Link { if p.As == APCDATA && p.From.Offset >= int64(npcdata) { npcdata = int(p.From.Offset + 1) } @@ -257,7 +241,7 @@ // tabulate which pc and func data we have. havepc := make([]uint32, (npcdata+31)/32) havefunc := make([]uint32, (nfuncdata+31)/32) - for p = cursym.Text; p != nil; p = p.Link { + for p := cursym.Text; p != nil; p = p.Link { if p.As == AFUNCDATA { if (havefunc[p.From.Offset/32]>>uint64(p.From.Offset%32))&1 != 0 { ctxt.Diag("multiple definitions for FUNCDATA $%d", p.From.Offset) @@ -271,7 +255,7 @@ } // pcdata. - for i = 0; i < npcdata; i++ { + for i := 0; i < npcdata; i++ { if (havepc[i/32]>>uint(i%32))&1 == 0 { continue } @@ -280,7 +264,8 @@ // funcdata if nfuncdata > 0 { - for p = cursym.Text; p != nil; p = p.Link { + var i int + for p := cursym.Text; p != nil; p = p.Link { if p.As == AFUNCDATA { i = int(p.From.Offset) pcln.Funcdataoff[i] = p.To.Offset @@ -297,13 +282,9 @@ // iteration over encoded pcdata tables. func getvarint(pp *[]byte) uint32 { - var p []byte - var shift int - var v uint32 - - v = 0 - p = *pp - for shift = 0; ; shift += 7 { + v := uint32(0) + p := *pp + for shift := 0; ; shift += 7 { v |= uint32(p[0]&0x7F) << uint(shift) tmp7 := p p = p[1:] @@ -317,9 +298,6 @@ } func pciternext(it *Pciter) { - var v uint32 - var dv int32 - it.pc = it.nextpc if it.done != 0 { return @@ -330,7 +308,7 @@ } // value delta - v = getvarint(&it.p) + v := getvarint(&it.p) if v == 0 && it.start == 0 { it.done = 1 @@ -338,7 +316,7 @@ } it.start = 0 - dv = int32(v>>1) ^ (int32(v<<31) >> 31) + dv := int32(v>>1) ^ (int32(v<<31) >> 31) it.value += dv // pc delta
diff --git a/src/cmd/internal/obj/sym.go b/src/cmd/internal/obj/sym.go index 30d0eb1..d9df440 100644 --- a/src/cmd/internal/obj/sym.go +++ b/src/cmd/internal/obj/sym.go
@@ -101,9 +101,7 @@ } func headtype(name string) int { - var i int - - for i = 0; i < len(headers); i++ { + for i := 0; i < len(headers); i++ { if name == headers[i].name { return headers[i].val } @@ -114,9 +112,7 @@ var headstr_buf string func Headstr(v int) string { - var i int - - for i = 0; i < len(headers); i++ { + for i := 0; i < len(headers); i++ { if v == headers[i].val { return headers[i].name } @@ -126,13 +122,11 @@ } func Linknew(arch *LinkArch) *Link { - var ctxt *Link - var p string var buf string linksetexp() - ctxt = new(Link) + ctxt := new(Link) ctxt.Arch = arch ctxt.Version = HistVersion ctxt.Goroot = Getgoroot() @@ -211,7 +205,7 @@ // On arm, record goarm. if ctxt.Arch.Thechar == '5' { - p = Getgoarm() + p := Getgoarm() if p != "" { ctxt.Goarm = int32(Atoi(p)) } else { @@ -223,9 +217,7 @@ } func linknewsym(ctxt *Link, symb string, v int) *LSym { - var s *LSym - - s = new(LSym) + s := new(LSym) *s = LSym{} s.Dynid = -1 @@ -246,17 +238,14 @@ } func _lookup(ctxt *Link, symb string, v int, creat int) *LSym { - var s *LSym - var h uint32 - - h = uint32(v) + h := uint32(v) for i := 0; i < len(symb); i++ { c := int(symb[i]) h = h + h + h + uint32(c) } h &= 0xffffff h %= LINKHASH - for s = ctxt.Hash[h]; s != nil; s = s.Hash { + for s := ctxt.Hash[h]; s != nil; s = s.Hash { if int(s.Version) == v && s.Name == symb { return s } @@ -265,7 +254,7 @@ return nil } - s = linknewsym(ctxt, symb, v) + s := linknewsym(ctxt, symb, v) s.Extname = s.Name s.Hash = ctxt.Hash[h] ctxt.Hash[h] = s