aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/8g/cgen.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/8g/cgen.go')
-rw-r--r--src/cmd/8g/cgen.go254
1 files changed, 128 insertions, 126 deletions
diff --git a/src/cmd/8g/cgen.go b/src/cmd/8g/cgen.go
index 9f736b1745..d36bef7f01 100644
--- a/src/cmd/8g/cgen.go
+++ b/src/cmd/8g/cgen.go
@@ -19,8 +19,6 @@ import "cmd/internal/gc"
* 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 @@ func mgen(n *gc.Node, n1 *gc.Node, rg *gc.Node) {
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 @@ func mfree(n *gc.Node) {
* 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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
// 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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
// 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 @@ func cgen(n *gc.Node, res *gc.Node) {
// 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 @@ func cgen(n *gc.Node, res *gc.Node) {
return
}
+ var a int
switch n.Op {
default:
gc.Dump("cgen", n)
@@ -243,11 +237,11 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
// 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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ func cgen(n *gc.Node, res *gc.Node) {
}
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 @@ func cgen(n *gc.Node, res *gc.Node) {
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 @@ abop: // asymmetric binary
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 @@ abop: // asymmetric binary
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 @@ abop: // asymmetric binary
return
uop: // unary
+ var n1 gc.Node
gc.Tempname(&n1, nl.Type)
cgen(nl, &n1)
@@ -491,11 +505,6 @@ uop: // unary
* 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 @@ func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
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 @@ func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
return nil
}
+ var zero gc.Node
gc.Nodconst(&zero, gc.Types[gc.TINT32], 0)
gins(i386.ACMPL, &hi, &zero)
splitclean()
@@ -530,20 +543,6 @@ func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
* 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 @@ func agen(n *gc.Node, res *gc.Node) {
// 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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
}
// let's compute
- nl = n.Left
+ nl := n.Left
- nr = n.Right
+ nr := n.Right
switch n.Op {
default:
@@ -611,19 +613,24 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
}
// 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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
}
// 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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
}
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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
} 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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
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 @@ func agen(n *gc.Node, res *gc.Node) {
* 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 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
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 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
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 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
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 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
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 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
* 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
}
- 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
}
- 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
// 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
if nl.Addable == 0 {
+ var n1 gc.Node
gc.Tempname(&n1, nl.Type)
cgen(nl, &n1)
nl = &n1
@@ -1189,6 +1202,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
}
if nr.Addable == 0 {
+ var tmp gc.Node
gc.Tempname(&tmp, nr.Type)
cgen(nr, &tmp)
nr = &tmp
@@ -1211,11 +1225,13 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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 @@ def:
* 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 @@ func stkof(n *gc.Node) int32 {
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 @@ func stkof(n *gc.Node) int32 {
* 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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
// 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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
}
// 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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
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 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
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 cadable(n *gc.Node) bool {
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 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool {
// 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 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool {
}
} 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 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool {
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 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool {
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 @@ func componentgen(nr *gc.Node, nl *gc.Node) bool {
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
7apu2bq3rhoylwmucxizk54afw5jyda7pho4j5zdcqpwkufke7zdzwad.onion