* 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
}
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)
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)
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)
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)
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)
// 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)
// 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)
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)
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
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)
// unary
case gc.OCOM:
- a = optoas(gc.OXOR, nl.Type)
+ a := optoas(gc.OXOR, nl.Type)
regalloc(&n1, nl.Type, nil)
cgen(nl, &n1)
break
}
+ var n1 gc.Node
if nl.Addable != 0 && !gc.Is64(nl.Type) {
regalloc(&n1, nl.Type, res)
gmove(nl, &n1)
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 {
gc.OINDEX,
gc.OIND,
gc.ONAME: // PHEAP or PPARAMREF var
+ var n1 gc.Node
igen(n, &n1, res)
gmove(&n1, res)
// interface table is first word of interface value
case gc.OITAB:
+ var n1 gc.Node
igen(nl, &n1, res)
n1.Type = n.Type
// 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)
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
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]
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
}
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)
// 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) {
sbop: // symmetric binary
if nl.Ullman < nr.Ullman {
- r = nl
+ r := nl
nl = nr
nr = r
}
* 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 {
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)
* 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)
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)
}
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)
// 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 {
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)
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)
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)
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)
* 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)
}
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)
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) {
* 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)
}
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
gmove(&n1, a)
* 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,
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
agen(&n1, a)
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])
}
}
} 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)
agenr(nl, &n3, res)
}
} else {
+ var tmp gc.Node
gc.Tempname(&tmp, gc.Types[gc.TINT32])
p2 = cgenindex(nr, &tmp, bounded)
nr = &tmp
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)
}
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) {
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)
}
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 {
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)
* 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)
}
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 {
switch n.Op {
default:
- a = gc.ONE
+ a := gc.ONE
if !true_ {
a = gc.OEQ
}
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)
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
// 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
}
break
}
+ var n1 gc.Node
igen(nl, &n1, nil)
n1.Xoffset += int64(gc.Array_array)
n1.Type = gc.Types[gc.Tptr]
break
}
+ var n1 gc.Node
igen(nl, &n1, nil)
n1.Type = gc.Types[gc.Tptr]
n1.Xoffset += 0
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
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)
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)
}
* 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
}
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
* 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)
if w == 0 {
// evaluate side effects only.
+ var dst gc.Node
regalloc(&dst, gc.Types[gc.Tptr], nil)
agen(res, &dst)
// 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)
}
// 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))
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)
// 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
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
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)
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)
// 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)
// 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
gc.Patch(gc.Gbranch(arm.ABNE, nil, 0), ploop)
regfree(&nend)
} else {
+ var p *obj.Prog
for {
tmp14 := c
c--
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) {
// 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
}
}
} 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)
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 {
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 {
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
* 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)
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)
}
// 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.
// 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)
// 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)
// 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.
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
// 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
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)
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)
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
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 {
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
}
case gc.OXOR,
gc.OAND,
gc.OOR:
+ var n1 gc.Node
regalloc(&n1, lo1.Type, nil)
gins(arm.AMOVW, &lo1, &al)
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)
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))
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
}
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
}
}
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))
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
}
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
* 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)
}
// 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)
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
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
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)
* 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))
}
// 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)
}
if i.Addable == 0 {
+ var tmpi gc.Node
gc.Tempname(&tmpi, i.Type)
cgen(i, &tmpi)
i = &tmpi
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)
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]
}
* 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
}
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
// 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
* 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
* 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
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)
* 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
}
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
* 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] {
// 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 {
* 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)
}
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) {
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)
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)
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)
// 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.
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)
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
}
}
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
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)
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
}
}
+ var p *obj.Prog
for c > 0 {
p = gins(arm.AMOVB, &nz, &dst)
p.To.Type = obj.TYPE_MEM
// 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
}
}
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))
}
}
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
}
* 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++
}
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,
}
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")
}
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++
}
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
}
* 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))
}
default:
switch n.Op {
default:
+ var n1 gc.Node
if !dotaddable(n, &n1) {
igen(n, &n1, nil)
sclean[nsclean-1] = n1
case gc.ONAME:
if n.Class == gc.PPARAMREF {
+ var n1 gc.Node
cgen(n.Heapaddr, &n1)
sclean[nsclean-1] = n1
n = &n1
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 {
}
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)
// 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)
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)
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)
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)
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
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)
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
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,
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:
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,
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)
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)
* 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")
}
// 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
}
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
}
* 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
/* 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
* 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))
}
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
* 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
}
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
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]
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")
}
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
// 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)
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 {
/*
}
}
- 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,
* 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
}
}
- t = int(v1.Reg)
+ t := int(int(v1.Reg))
v1.Reg = v2.Reg
v2.Reg = int16(t)
if gc.Debug['P'] != 0 {
* 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
}
}
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")
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 {
* 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 {
* 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
* ..
*/
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")
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
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)
}
/* 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 {
/* make the substitution */
p2.From.Reg = 0
- o = int(p.Reg)
+ o := int(int(p.Reg))
if o == 0 {
o = int(p.To.Reg)
}
}
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
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++ {
}
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)
* 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:
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
}
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
}
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)
}
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)
}
func excise(r *gc.Flow) {
- var p *obj.Prog
-
- p = r.Prog
+ p := (*obj.Prog)(r.Prog)
obj.Nopout(p)
}
* 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
}
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)
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)
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)
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 {
goto ret
}
+ var f int
if res.Ullman >= gc.UINF {
goto gen
}
}
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)
}
gen:
+ var n1 gc.Node
igen(res, &n1, nil)
cgen(n, &n1)
regfree(&n1)
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
}
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)
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)
// 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)
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)
}
}
+ var n1 gc.Node
regalloc(&n1, nl.Type, res)
+ var n2 gc.Node
regalloc(&n2, n.Type, &n1)
cgen(nl, &n1)
gc.OINDEX,
gc.OIND,
gc.ONAME: // PHEAP or PPARAMREF var
+ var n1 gc.Node
igen(n, &n1, res)
gmove(&n1, res)
// interface table is first word of interface value
case gc.OITAB:
+ var n1 gc.Node
igen(nl, &n1, res)
n1.Type = n.Type
// 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)
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
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]]
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
}
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)
}
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)
*/
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
}
* 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)
}
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
gmove(&n1, a)
* 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,
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
agen(&n1, a)
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
}
} else {
if nl.Addable == 0 {
// igen will need an addressable node.
+ var tmp2 gc.Node
gc.Tempname(&tmp2, nl.Type)
cgen(nl, &tmp2)
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)
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)
}
}
// 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)
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)
} 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
}
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
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
* 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)
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)
}
if n.Addable != 0 {
+ var n1 gc.Node
regalloc(&n1, gc.Types[gc.Tptr], res)
gins(x86.ALEAQ, n, &n1)
gmove(&n1, res)
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)
* 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)
}
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
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)
* 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)
}
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 {
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
}
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)
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
// 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
}
}
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)
}
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)
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)
// 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
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)
* 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
}
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
* 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)
// 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)
}
if w == 0 {
// evaluate side effects only
+ var nodr gc.Node
regalloc(&nodr, gc.Types[gc.Tptr], nil)
agen(ns, &nodr)
}
// 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)
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 {
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
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))
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) {
// 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
}
}
} 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)
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 {
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 {
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
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
}
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
}
}
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)) {
}
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
* 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)
}
// 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)
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
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)
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)
}
* 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))
}
i = i.Left // interface
if i.Addable == 0 {
+ var tmpi gc.Node
gc.Tempname(&tmpi, i.Type)
cgen(i, &tmpi)
i = &tmpi
// 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
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]
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")
* 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
}
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
// 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
* 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
* 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
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)
* 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
}
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
* 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.
// 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)) {
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)
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
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")
}
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)
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)
* 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
* 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
goto longdiv
case gc.TUINT64:
+ var m gc.Magic
m.W = w
m.Ud = uint64(gc.Mpgetfix(nr.Val.U.Xval))
gc.Umagic(&m)
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)
return
case gc.TINT64:
+ var m gc.Magic
m.W = w
m.Sd = gc.Mpgetfix(nr.Val.U.Xval)
gc.Smagic(&m)
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)
// 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
}
if !gc.Smallintconst(nr) {
+ var n3 gc.Node
regalloc(&n3, nl.Type, nil)
cgen(nr, &n3)
gins(a, &n3, &n2)
* 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)
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)
}
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
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)
* 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.
}
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.
// 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
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)
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))
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
}
// 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
}
}
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]]++
}
}
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 {
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))
}
}
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
}
* 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,
}
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")
}
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
}
*/
func ginscon(as int, c int64, n2 *gc.Node) {
var n1 gc.Node
- var ntmp gc.Node
switch as {
case x86.AADDL,
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)
* 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)
}
// 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
// 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)
// 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)
* 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;
}
}
- 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
}
fmt.Printf("%v\n", p)
}
- w = 0
+ w := int32(0)
switch as {
case x86.AMOVB:
w = 1
}
func fixlargeoffset(n *gc.Node) {
- var a gc.Node
-
if n == nil {
return
}
}
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]
* 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))
* 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
}
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
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]
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")
}
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
}
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 {
}
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
}
// 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,
}
}
+ 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)
// 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) {
// 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,
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 {
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
}
}
- t = *r0.Prog
+ t := obj.Prog(*r0.Prog)
for r = gc.Uniqp(r0); ; r = gc.Uniqp(r) {
p0 = r.Link.Prog
p = r.Prog
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
}
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)
}
// 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 {
// 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)
* 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))
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))
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)
}
}
- t = int(v1.Reg)
+ t := int(int(v1.Reg))
v1.Reg = v2.Reg
v2.Reg = int16(t)
if gc.Debug['P'] != 0 {
* 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
}
}
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")
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 {
* 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 {
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 {
* 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)
}
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 */
}
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)
}
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 {
* 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 {
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)
}
* 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)
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)
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)
// 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)
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)
// 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)
// 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
return
}
+ var a int
switch n.Op {
default:
gc.Dump("cgen", n)
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)
break
}
+ var n2 gc.Node
gc.Tempname(&n2, n.Type)
+ var n1 gc.Node
mgen(nl, &n1, res)
gmove(&n1, &n2)
gmove(&n2, res)
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)
// 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)
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
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]
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
}
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)
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)
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)
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)
return
uop: // unary
+ var n1 gc.Node
gc.Tempname(&n1, nl.Type)
cgen(nl, &n1)
* 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.
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)
return nil
}
+ var zero gc.Node
gc.Nodconst(&zero, gc.Types[gc.TINT32], 0)
gins(i386.ACMPL, &hi, &zero)
splitclean()
* 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)
// 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)
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)
}
// let's compute
- nl = n.Left
+ nl := n.Left
- nr = n.Right
+ nr := n.Right
switch n.Op {
default:
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) {
}
// 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)
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)
}
}
// 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]
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 {
}
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)
}
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
} 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
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)
}
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)
}
* 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)
}
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n.Left, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
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
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)
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 {
* 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)
}
}
}
- 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)
}
}
- 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)
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
}
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)
gc.OGT,
gc.OLE,
gc.OGE:
- a = int(n.Op)
+ a := int(n.Op)
if !true_ {
a = gc.Brcom(a)
true_ = !true_
// 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
}
}
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)
}
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)
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
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
}
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
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
}
* 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
}
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)
* 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)
if w == 0 {
// evaluate side effects only.
+ var tdst gc.Node
gc.Tempname(&tdst, gc.Types[gc.Tptr])
agen(res, &tdst)
// 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)
}
}
// 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)
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)
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
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,
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) {
// 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
}
}
} 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)
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 {
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 {
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
* 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)
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)
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)
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)
}
// 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.
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.
// 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
} 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)
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()
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)
// 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))
// 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)
}
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()
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)
// 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))
// 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)
}
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 {
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)
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))
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
}
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
}
}
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) {
}
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
}
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.
// 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
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)
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))
* 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)
}
// 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)
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
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)
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)
}
* 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))
}
i = i.Left // interface
if i.Addable == 0 {
+ var tmpi gc.Node
gc.Tempname(&tmpi, i.Type)
cgen(i, &tmpi)
i = &tmpi
// 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
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]
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")
* 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
}
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
// 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
* 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
* 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
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)
* 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
}
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
* 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.
// 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) {
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)
cgen(nr, &t2)
}
+ var n1 gc.Node
if !gc.Samereg(ax, res) && !gc.Samereg(dx, res) {
regalloc(&n1, t, res)
} else {
}
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
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")
}
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)
}
if gc.Issigned[t.Etype] == 0 {
+ var nz gc.Node
gc.Nodconst(&nz, t, 0)
gmove(&nz, dx)
} else {
}
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
* 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)
* 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)
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
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 {
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()
* 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]
// 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)
* 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)
* 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)
return
}
+ var n2 gc.Node
gc.Tempname(&n2, n.Type)
+ var n1 gc.Node
mgen(nl, &n1, res)
gmove(&n1, &n2)
gmove(&n2, res)
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 {
}
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)
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)
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)
}
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.
return
}
+ var tmp gc.Node
+ var et int
+ var n2 gc.Node
+ var ax gc.Node
if gc.Use_sse != 0 {
goto sse
} else {
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
// 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)
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
nr = &n2
if nl.Op != gc.OREGISTER {
+ var n3 gc.Node
regalloc(&n3, nl.Type, nil)
gmove(nl, &n3)
nl = &n3
if a == gc.OGE || a == gc.OGT {
// only < and <= work right with NaN; reverse if needed
- r = nr
+ r := nr
nr = nl
nl = r
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)
// 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
}
* 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))
}
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
}
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]]++
}
}
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))
}
}
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
}
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
}
* 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:
}
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")
}
}
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")
}
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
}
* swap node contents
*/
func nswap(a *gc.Node, b *gc.Node) {
- var t gc.Node
-
- t = *a
+ t := *a
*a = *b
*b = t
}
* 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))
}
default:
switch n.Op {
default:
+ var n1 gc.Node
if !dotaddable(n, &n1) {
igen(n, &n1, nil)
sclean[nsclean-1] = n1
case gc.ONAME:
if n.Class == gc.PPARAMREF {
+ var n1 gc.Node
cgen(n.Heapaddr, &n1)
sclean[nsclean-1] = n1
n = &n1
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 {
}
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)
// 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)
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)
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)
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)
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)
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)
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)
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) {
// 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)
goto hardmem
}
+ var r1 gc.Node
gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0)
if ft == gc.TFLOAT32 {
gins(i386.AFMOVF, f, &r1)
}
// 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)
}
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 {
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)
// 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)
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)
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 {
// 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)
} 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)
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)
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:
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 {
}
// 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)
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)
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)
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)
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)
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
* 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")
}
}
}
- 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
}
fmt.Printf("%v\n", p)
}
- w = 0
+ w := 0
switch as {
case i386.AMOVB:
w = 1
}
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
}
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 {
}
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
}
// 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:
}
}
+ 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)
// 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) {
}
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)
}
// 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 {
* 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)
}
}
- t = int(v1.Reg)
+ t := int(v1.Reg)
v1.Reg = v2.Reg
v2.Reg = int16(t)
if gc.Debug['P'] != 0 {
* 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
}
}
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")
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 {
* 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 {
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 {
* 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)
}
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 */
}
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)
}
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 {
* 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
}
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)
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)
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)
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 {
goto ret
}
+ var f int
if res.Ullman >= gc.UINF {
goto gen
}
}
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)
}
gen:
+ var n1 gc.Node
igen(res, &n1, nil)
cgen(n, &n1)
regfree(&n1)
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)
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
}
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)
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)
// 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)
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)
}
}
+ var n1 gc.Node
regalloc(&n1, nl.Type, res)
+ var n2 gc.Node
regalloc(&n2, n.Type, &n1)
cgen(nl, &n1)
gc.OINDEX,
gc.OIND,
gc.ONAME: // PHEAP or PPARAMREF var
+ var n1 gc.Node
igen(n, &n1, res)
gmove(&n1, res)
// interface table is first word of interface value
case gc.OITAB:
+ var n1 gc.Node
igen(nl, &n1, res)
n1.Type = n.Type
// 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)
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
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]]
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
}
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)
}
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)
*/
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
}
* 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)
}
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
gmove(&n1, a)
* 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,
gc.OCALLFUNC,
gc.OCALLMETH,
gc.OCALLINTER:
+ var n1 gc.Node
igen(n, &n1, res)
regalloc(a, gc.Types[gc.Tptr], &n1)
agen(&n1, a)
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])
}
}
} 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)
agenr(nl, &n3, res)
}
} else {
+ var tmp gc.Node
gc.Tempname(&tmp, gc.Types[gc.TINT64])
cgen(nr, &tmp)
nr = &tmp
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)
}
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) {
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
}
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)
}
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 {
* 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)
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)
}
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)
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)
* 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)
}
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
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)
* 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)
}
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 {
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
}
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)
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
// 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
}
}
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)
}
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)
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)
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.
* 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
}
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
* 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 {
// 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)
}
// return;
if w == 0 {
// evaluate side effects only.
+ var dst gc.Node
regalloc(&dst, gc.Types[gc.Tptr], nil)
agen(res, &dst)
// 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))
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)
// 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)
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
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)
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
}
// 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
// generate the offsets directly and eliminate the
// ADDs. That will produce shorter, more
// pipeline-able code.
+ var p *obj.Prog
for {
tmp14 := c
c--
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) {
// 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
}
}
} 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)
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 {
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 {
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
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
}
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))
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)
}
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
* 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)
* 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)
}
// 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)
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
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
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)
* 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))
}
i = i.Left // interface
if i.Addable == 0 {
+ var tmpi gc.Node
gc.Tempname(&tmpi, i.Type)
cgen(i, &tmpi)
i = &tmpi
// 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)
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]
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")
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
}
* 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
}
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
// 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
* 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
* 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
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)
* 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
}
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
* 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.
// 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)) {
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)
if t != t0 {
// Convert
- tl2 = tl
+ tl2 := tl
- tr2 = tr
+ tr2 := tr
tl.Type = t
tr.Type = t
gmove(&tl2, &tl)
}
// 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
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)
gmove(&tl, res)
} else {
// a % (-1) is 0.
+ var nz gc.Node
gc.Nodconst(&nz, t, 0)
gmove(&nz, res)
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
* 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)
}
/*
* 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)
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:
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)
}
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
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)
}
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
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)
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)
// 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)
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)
// 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)
}
}
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]++
}
}
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])
}
}
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
}
* 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++
fmt.Printf("regalloc fix %d flt %d free\n", fixfree, fltfree)
}
+ var i int
switch et {
case gc.TINT8,
gc.TUINT8,
}
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")
}
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")
}
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
}
*/
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)
*/
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)
}
// MOV n1 into register first
+ var ntmp gc.Node
regalloc(&ntmp, gc.Types[gc.TINT64], nil)
gins(ppc64.AMOVD, &n1, &ntmp)
* 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)
}
// 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)
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)
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)
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
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)
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
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)
* 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
}
fmt.Printf("%v\n", p)
}
- w = 0
+ w := int32(0)
switch as {
case ppc64.AMOVB,
ppc64.AMOVBU,
}
func fixlargeoffset(n *gc.Node) {
- var a gc.Node
-
if n == nil {
return
}
// 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
* 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))
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)
/*
* 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:
* 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,
}
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)
}
* 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
}
}
- t = int(v1.Reg)
+ t := int(int(v1.Reg))
v1.Reg = v2.Reg
v2.Reg = int16(t)
if gc.Debug['P'] != 0 {
* 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)
// 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")
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 {
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
// 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
}
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
// 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
}
}
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)
}
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))
}
}
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))
}
}
func dowidth(t *Type) {
- var et int32
- var w int64
- var lno int
- var t1 *Type
-
if Widthptr == 0 {
Fatal("dowidth without betypeinit")
}
}
if t.Width == -2 {
- lno = int(lineno)
+ lno := int(lineno)
lineno = int32(t.Lineno)
if t.Broke == 0 {
t.Broke = 1
// 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,
}
}
- w = 0
+ w := int64(0)
switch et {
default:
Fatal("dowidth: unknown type: %v", Tconv(t, 0))
// 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)")
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))
}
// make fake type to check later to
// trigger function argument computation.
case TFUNC:
- t1 = typ(TFUNCARGS)
+ t1 := typ(TFUNCARGS)
t1.Type = t
checkwidth(t1)
// 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)
var tlq *TypeList
func checkwidth(t *Type) {
- var l *TypeList
-
if t == nil {
return
}
}
t.Deferwidth = 1
- l = tlfree
+ l := tlfree
if l != nil {
tlfree = l.next
} else {
}
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)
}
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)
}
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)
Tptr = TPTR64
}
- for i = TINT8; i <= TUINT64; i++ {
+ for i := TINT8; i <= TUINT64; i++ {
Isint[i] = 1
}
Isint[TINT] = 1
/*
* 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
okforcmp[TSTRING] = 1
+ var i int
for i = 0; i < len(okfor); i++ {
okfor[i] = okfornone[:]
}
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)
*/
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 {
}
*/
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
}
}
*/
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)
}
func blsh(n uint) Bits {
- var c Bits
-
- c = zbits
+ c := zbits
c.b[n/64] = 1 << (n % 64)
return c
}
}
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
}
var fp string
var i int
- var first int
- first = 1
+ first := 1
for bany(&bits) {
i = bnum(bits)
}
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)
}
// 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
}
}
// 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
}
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
}
}
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
}
}
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
}
* 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
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)
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)
}
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_)
// 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)
}
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
}
}
- 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
// 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
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"
}
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
// 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
}
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"
}
// 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
// }(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
xfunc.Type = f.Type // update type of ODCLFUNC
} else {
// The closure is not called, so it is going to stay as closure.
- nvar = 0
-
- body = nil
- offset = int64(Widthptr)
- for l = func_.Cvars; l != nil; l = l.Next {
+ nvar := 0
+
+ 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
}
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
// 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
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)
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
}
Fatal("missing base type for %v", Tconv(rcvrtype, 0))
}
- spkg = nil
+ spkg := (*Pkg)(nil)
if basetype.Sym != nil {
spkg = basetype.Sym.Pkg
}
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))
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))
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
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)
}
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:
//
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))
* 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)
}
* (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
}
}
if n.Op == OLITERAL {
- nn = Nod(OXXX, nil, nil)
+ nn := Nod(OXXX, nil, nil)
*nn = *n
n = nn
*np = n
return
}
- ct = consttype(n)
+ ct := consttype(n)
+ var et int
if ct < 0 {
goto bad
}
CTRUNE,
CTFLT,
CTCPLX:
- ct = int(n.Val.Ctype)
+ ct := int(n.Val.Ctype)
if Isint[et] != 0 {
switch ct {
default:
}
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
}
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
}
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))
}
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))
}
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))
}
}
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
}
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.
}
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
* 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 {
// 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)
}
// 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
}
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
}
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:
}
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:
}
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
// 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
}
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 {
}
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 {
}
if n.Val.Ctype == CTSTR {
- t1 = Types[TSTRING]
+ t1 := Types[TSTRING]
Convlit(np, t1)
break
}
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
}
* 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
}
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])
* 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)
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))
// 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
}
case OLEN,
OCAP:
- l = n.Left
+ l := n.Left
if isgoconst(l) {
return true
}
// 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
}
case ONAME:
- l = n.Sym.Def
+ l := n.Sym.Def
if l != nil && l.Op == OLITERAL && n.Val.Ctype != CTNIL {
return true
}
// Only constant calls are unsafe.Alignof, Offsetof, and Sizeof.
case OCALL:
- l = n.Left
+ l := n.Left
for l.Op == OPAREN {
l = l.Left
}
func hascallchan(n *Node) bool {
- var l *NodeList
-
if n == nil {
return false
}
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
}
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 {
}
if nr.Addable == 0 {
+ var tnr Node
Tempname(&tnr, nr.Type)
Thearch.Cgen(nr, &tnr)
nr = &tnr
// 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]
// 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)
// 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
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
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)
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
}
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)
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))
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)
}
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)
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)
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)
}
// 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
}
if res.Addable == 0 {
+ var n1 Node
Thearch.Igen(res, &n1, nil)
Thearch.Cgen(n, &n1)
Thearch.Regfree(&n1)
OCALLFUNC,
OCALLMETH,
OCALLINTER:
+ var n1 Node
Thearch.Igen(n, &n1, res)
Complexmove(&n1, res)
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)
}
if nr.Addable == 0 {
+ var tnr Node
Tempname(&tnr, nr.Type)
Thearch.Cgen(nr, &tnr)
nr = &tnr
}
func push() *Sym {
- var d *Sym
-
- d = new(Sym)
+ d := new(Sym)
d.Lastlineno = lineno
d.Link = dclstack
dclstack = d
}
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)
}
func markdcl() {
- var d *Sym
-
- d = push()
+ d := push()
d.Name = "" // used as a mark in fifo
d.Block = block
// 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 == "" {
}
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()
}
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 {
} 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
var declare_typegen int
func declare(n *Node, ctxt int) {
- var s *Sym
- var gen int
-
if ctxt == PDISCARD {
return
}
}
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 {
Yyerror("cannot declare init - must be func", s)
}
- gen = 0
+ gen := 0
if ctxt == PEXTERN {
externdcl = list(externdcl, n)
if dflag() {
* 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
return list(init, as2)
}
+ var v *Node
+ var e *Node
for ; vl != nil; vl = vl.Next {
if doexpr {
if el == nil {
* 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")
cl = listtreecopy(cl)
+ var v *Node
+ var c *Node
for ; vl != nil; vl = vl.Next {
if cl == nil {
Yyerror("missing value in const declaration")
* 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
* 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
}
* 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.
// 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
}
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
}
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
}
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))
}
// 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))
}
}
}
- 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))
}
// 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 {
* 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
}
}
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
}
}
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
}
* 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
}
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 {
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) {
* 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
}
}
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
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
}
}
func interfacefield(n *Node) *Type {
- var f *Type
- var lno int
-
- lno = int(lineno)
+ lno := int(lineno)
lineno = n.Lineno
if n.Op != ODCLFIELD {
Yyerror("interface method cannot have annotation")
}
- f = typ(TFIELD)
+ f := typ(TFIELD)
f.Isddd = n.Isddd
if n.Right != nil {
}
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)
}
}
- 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
}
}
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 {
}
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
}
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 {
}
}
- 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
}
func fakethis() *Node {
- var n *Node
-
- n = Nod(ODCLFIELD, nil, typenod(Ptrto(typ(TSTRUCT))))
+ n := Nod(ODCLFIELD, nil, typenod(Ptrto(typ(TSTRUCT))))
return n
}
* (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
}
* 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)
}
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
}
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
}
}
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
}
}
func methodname1(n *Node, t *Node) *Node {
- var star string
- var p string
-
- star = ""
+ star := ""
if t.Op == OIND {
star = "*"
t = t.Left
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 {
* 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
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
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))
}
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)
)
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
visitgen++
n.Walkgen = visitgen
visitgen++
- min = visitgen
+ min := visitgen
- l = new(NodeList)
+ l := new(NodeList)
l.Next = stack
l.N = n
stack = l
// 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)
}
}
func visitcode(n *Node, min uint32) uint32 {
- var fn *Node
- var m uint32
-
if n == nil {
return min
}
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
}
}
if n.Op == OCLOSURE {
- m = visit(n.Closure)
+ m := visit(n.Closure)
if m < min {
min = m
}
var tags [16]*Strlit
func mktag(mask int) *Strlit {
- var s *Strlit
- var buf string
-
switch mask & EscMask {
case EscNone,
EscReturn:
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
}
}
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
}
}
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
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)
}
// 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 {
}
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 {
}
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
}
// 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)
}
}
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)
// 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
// 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
}
dst = &e.theSink
}
- lno = int(setlineno(src))
+ lno := int(setlineno(src))
e.pdepth++
switch src.Op {
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)
}
func escassignfromtag(e *EscState, note *Strlit, dsts *NodeList, src *Node) int {
var em int
- var em0 int
em = parsetag(note)
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)
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")
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
}
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 {
}
// 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++
// 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.
// 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:
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)
}
)
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
}
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 {
}
}
- newlevel = level
+ newlevel := level
if level > MinLevel {
newlevel--
}
case ODOTPTR,
OINDEXMAP,
OIND:
- newlevel = level
+ newlevel := level
if level > MinLevel {
newlevel++
}
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)
}
}
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)
}
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
}
}
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"
}
}
func reexportdep(n *Node) {
- var t *Type
-
if n == nil {
return
}
// 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 {
}
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
OMAKEMAP,
OMAKESLICE,
OMAKECHAN:
- t = n.Type
+ t := n.Type
if t.Sym == nil && t.Type != nil {
t = t.Type
}
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) {
}
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 {
}
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
}
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")
}
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 {
}
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)
}
}
- for l = exportlist; l != nil; l = l.Next {
+ for l := exportlist; l != nil; l = l.Next {
lineno = l.N.Lineno
dumpsym(l.N.Sym)
}
* 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)
}
* 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)
}
// 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++
}
func importconst(s *Sym, t *Type, n *Node) {
- var n1 *Node
-
importsym(s, OLITERAL)
Convlit(&n, t)
}
if n.Sym != nil {
- n1 = Nod(OXXX, nil, nil)
+ n1 := Nod(OXXX, nil, nil)
*n1 = *n
n = n1
}
}
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) {
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)
}
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.
}
if pt.Etype == TFORW {
- n = pt.Nod
+ n := pt.Nod
copytype(pt.Nod, t)
pt.Nod = n // unzero nod
pt.Sym.Importdef = importpkg
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
//
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 {
// 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
}
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)
}
if n.Class != 0 {
- s = ""
+ s := ""
if n.Class&PHEAP != 0 {
s = ",heap"
}
// 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:])
// 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
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
}
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
}
}
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
}
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
}
}
if t == errortype {
+ var fp string
fp += "error"
return fp
}
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
}
// 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 "
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))
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 {
}
}
} 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 {
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 {
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.
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 += "{"
}
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
}
// 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
// _ 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
}
// 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
}
//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
}
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 {
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
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
ODOTINTER,
ODOTMETH,
OCALLPART:
+ var f string
f += exprfmt(n.Left, nprec)
if n.Right == nil || n.Right.Sym == nil {
f += ".<nil>"
case ODOTTYPE,
ODOTTYPE2:
+ var f string
f += exprfmt(n.Left, nprec)
if n.Right != nil {
f += fmt.Sprintf(".(%v)", Nconv(n.Right, 0))
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
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
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
OCALLFUNC,
OCALLINTER,
OCALLMETH:
+ var f string
f += exprfmt(n.Left, nprec)
if n.Isddd != 0 {
f += fmt.Sprintf("(%v...)", Hconv(n.List, obj.FmtComma))
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
OIND,
ONOT,
ORECV:
+ var f string
if n.Left.Op == n.Op {
f += fmt.Sprintf("%v ", Oconv(int(n.Op), obj.FmtSharp))
} else {
OSEND,
OSUB,
OXOR:
+ var f string
f += exprfmt(n.Left, nprec)
f += fmt.Sprintf(" %v ", Oconv(int(n.Op), obj.FmtSharp))
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(" + ")
}
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
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
}
return stmtfmt(n)
}
+ var f string
f += exprfmt(n, 0)
return f
}
}
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 {
// 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
// '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++
flag |= obj.FmtUnsigned
}
+ var r int
_ = r
str := typefmt(t, flag)
// 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 {
// 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 {
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
}
* 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);
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
}
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
}
}
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 {
}
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
}
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 {
* generate discard of value
*/
func cgen_discard(nr *Node) {
- var tmp Node
-
if nr == nil {
return
}
// special enough to just evaluate
default:
+ var tmp Node
Tempname(&tmp, nr.Type)
Cgen_as(&tmp, nr)
* 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
case TFLOAT32,
TFLOAT64:
+ var zero Mpflt
Mpmovecflt(&zero, 0.0)
z.Val.Ctype = CTFLT
z.Val.U.Fval = &zero
* 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)
* 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
}
// 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)
// 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)
}
// dst.array = src.array [ + lo *width ]
- dst = *res
+ dst := *res
dst.Xoffset += int64(Array_array)
dst.Type = Types[Tptr]
* 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")
}
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
}
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()
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)
}
// 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)
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
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
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
}
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
}
}
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
}
}
func Cgen_as(nl *Node, nr *Node) {
- var tl *Type
-
if Debug['g'] != 0 {
Dump("cgen_as", nl)
Dump("cgen_as = ", nr)
return
}
- tl = nl.Type
+ tl := nl.Type
if tl == nil {
return
}
return
}
- tl = nl.Type
+ tl := nl.Type
if tl == nil {
return
}
}
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
}
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))
* 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' {
}
func fixautoused(p *obj.Prog) {
- var lp **obj.Prog
-
- for lp = &p; ; {
+ for lp := &p; ; {
p = *lp
if p == nil {
break
}
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
}
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)
}
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)
}
}
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)
}
func Naddr(n *Node, a *obj.Addr, canemitcode int) {
- var s *Sym
-
*a = obj.Addr{}
if n == nil {
return
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)
}
func newplist() *obj.Plist {
- var pl *obj.Plist
-
- pl = obj.Linknewplist(Ctxt)
+ pl := obj.Linknewplist(Ctxt)
Pc = Ctxt.NewProg()
Clearp(Pc)
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")
}
}
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
}
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
* }
*/
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,
}
// 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
}
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
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)
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)
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))
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
// (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 {
// 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
// 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
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
// 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))
}
// 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
// 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))
}
}
func inlcopy(n *Node) *Node {
- var m *Node
-
if n == nil {
return nil
}
return n
}
- m = Nod(OXXX, nil, nil)
+ m := Nod(OXXX, nil, nil)
*m = *n
m.Inl = nil
m.Left = inlcopy(n.Left)
// 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 {
// 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
}
// 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
}
// 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
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)
}
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)
}
// 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)
}
// 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)
}
}
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)
}
}
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
// 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
typecheckinl(fn)
}
- n = *np
+ n := *np
// Bingo, we have a function node, and it has an inlineable body
if Debug['m'] > 1 {
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 {
}
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
}
}
// 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)
}
// 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))
}
// 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
}
// 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 {
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 {
}
// 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))
}
// 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++ {
}
} 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
// 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)
as.Right = nodnil()
as.Right.Type = varargtype
} else {
- vararrtype = typ(TARRAY)
+ vararrtype := typ(TARRAY)
vararrtype.Type = varargtype.Type
vararrtype.Bound = int64(varargcount)
}
// 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)
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))
//dumplist("ninit post", ninit);
- call = Nod(OINLCALL, nil, nil)
+ call := Nod(OINLCALL, nil, nil)
call.Ninit = ninit
call.Nbody = body
// 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)
}
// 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
// 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
// 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
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
}
// 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))
}
}
func inlsubst(n *Node) *Node {
- var p string
- var m *Node
- var as *Node
- var ll *NodeList
-
if n == nil {
return nil
}
// 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)
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
}
func doversion() {
- var p string
- var sep string
-
- p = obj.Expstring()
+ p := obj.Expstring()
if p == "X:none" {
p = ""
}
- sep = ""
+ sep := ""
if p != "" {
sep = " "
}
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)
}
if Thearch.Thechar == '8' {
- p = obj.Getgo386()
+ p := obj.Getgo386()
if p == "387" {
Use_sse = 0
} else if p == "sse2" {
// 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)
}
// 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)
}
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
// 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)
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)
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)
}
// 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)
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)
}
}
// 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)
}
}
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
}
}
/* symbol table may be first; skip it */
- sz = arsize(b, "__.GOSYMDEF")
+ sz := arsize(b, "__.GOSYMDEF")
if sz >= 0 {
obj.Bseek(b, int64(sz), 1)
}
func addidir(dir string) {
- var pp **Idir
-
if dir == "" {
return
}
+ var pp **Idir
for pp = &idirs; *pp != nil; pp = &(*pp).link {
}
*pp = new(Idir)
}
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
// 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
}
if goroot != "" {
- suffix = ""
- suffixsep = ""
+ suffix := ""
+ suffixsep := ""
if flag_installsuffix != "" {
suffixsep = "_"
suffix = flag_installsuffix
}
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()
return
}
- path_ = f.U.Sval
+ path_ := f.U.Sval
if islocalname(path_) {
if path_.S[0] == '/' {
Yyerror("import path cannot be absolute path")
return
}
- prefix = Ctxt.Pathname
+ prefix := Ctxt.Pathname
if localimport != "" {
prefix = localimport
}
- cleanbuf = prefix
+ cleanbuf := prefix
cleanbuf += "/"
cleanbuf += path_.S
cleanbuf = path.Clean(cleanbuf)
// 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
}
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)
}
// 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 ") {
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()
curio.nlsemi = 0
typecheckok = 1
+ var c int32
for {
c = int32(getc())
if c == EOF {
cp.Reset()
for {
-
if escchar('"', &escflag, &v) {
break
}
cp.Reset()
for {
-
c = int(getr())
if c == '\r' {
continue
case '/':
c1 = getc()
if c1 == '*' {
- var nl int
-
- nl = 0
+ nl := 0
for {
c = int(getr())
if c == '\n' {
*/
talph:
for {
-
if c >= utf8.RuneSelf {
ungetc(c)
rune_ = uint(getr())
cp.Reset()
if c != '0' {
for {
-
cp.WriteByte(byte(c))
c = getc()
if yy_isdigit(c) {
c = getc()
if c == 'x' || c == 'X' {
for {
-
cp.WriteByte(byte(c))
c = getc()
if yy_isdigit(c) {
c1 = 0
for {
-
if !yy_isdigit(c) {
break
}
casedot:
for {
-
cp.WriteByte(byte(c))
c = getc()
if !yy_isdigit(c) {
Yyerror("malformed fp constant exponent")
}
for yy_isdigit(c) {
-
cp.WriteByte(byte(c))
c = getc()
}
*/
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
// 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
// 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
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
}
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
}
}
if verb == "cgo_import_static" {
- local = getimpsym(&q)
+ local := getimpsym(&q)
if local == "" || more(&q) {
goto err4
}
if verb == "cgo_ldflag" {
var ok bool
+ var p string
p, ok = getquoted(&q)
if !ok {
goto err5
}
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
}
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
curio.cp = curio.cp[1:]
}
} else {
+ var c1 int
+ var c2 int
loop:
c = obj.Bgetc(curio.bin)
if c == 0xef {
}
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")
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
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'
}
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)
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
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
var lex int
var etype int
var i int
- var v Val
for i = 0; i < len(syms); i++ {
lex = syms[i].lexical
s = Lookup("nil")
if s.Def == nil {
+ var v Val
v.Ctype = CTNIL
s.Def = nodlit(v)
s.Def.Sym = s
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
}
}
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:]
}
}
func mkpackage(pkgname string) {
- var s *Sym
- var h int32
- var p string
-
if localpkg.Name == "" {
if pkgname == "_" {
Yyerror("invalid package name _")
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
}
if outfile == "" {
- p = infile
+ p := infile
if i := strings.LastIndex(p, "/"); i >= 0 {
p = p[i+1:]
}
}
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
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
}
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))
// 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)
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
// 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
// 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
// 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
// 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
/// 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)
}
// 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)
}
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 {
}
// 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
}
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:]
}
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'
// 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
}
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 == '-' {
}
if mpcmpfltc(a, 0.0) != 0 {
if ex >= dp {
+ var b Mpflt
mppow10flt(&b, ex-dp)
mpmulfltflt(a, &b)
} else {
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)
}
//
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)
}
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))
buf[p] = '0'
} else {
// Decimal
+ var ten Mpint
Mpmovecfix(&ten, 10)
for {
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("+")
}
// 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
return fp
}
+ var fv Mpflt
+ var buf string
if sigfig(fvp) == 0 {
buf = fmt.Sprintf("0p+0")
goto out
buf = fmt.Sprintf("%vp-%d", Bconv(&fv.Val, obj.FmtSharp), -fv.Exp)
out:
+ var fp string
fp += buf
return fp
}
// 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
}
//
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 {
// 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 {
//
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
// 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]
}
// 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")
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
//
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 {
/// 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")
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 {
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 {
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 {
}
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")
// 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
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 {
}
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")
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 {
}
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")
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
}
}
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")
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
}
}
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")
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
}
}
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")
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
}
}
func mplshfixfix(a *Mpint, b *Mpint) {
- var s int64
-
if a.Ovf != 0 || b.Ovf != 0 {
if nsavederrors+nerrors == 0 {
Yyerror("ovf in mporfixfix")
return
}
- s = Mpgetfix(b)
+ s := Mpgetfix(b)
if s < 0 || s >= Mpprec*Mpscale {
Yyerror("stupid shift: %d", s)
Mpmovecfix(a, 0)
}
func mprshfixfix(a *Mpint, b *Mpint) {
- var s int64
-
if a.Ovf != 0 || b.Ovf != 0 {
if nsavederrors+nerrors == 0 {
Yyerror("ovf in mprshfixfix")
return
}
- s = Mpgetfix(b)
+ s := Mpgetfix(b)
if s < 0 || s >= Mpprec*Mpscale {
Yyerror("stupid shift: %d", s)
if a.Neg != 0 {
}
func Mpgetfix(a *Mpint) int64 {
- var v int64
-
if a.Ovf != 0 {
if nsavederrors+nerrors == 0 {
Yyerror("constant overflow")
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 {
}
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
}
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
}
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
}
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
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
* 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
}
// 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 {
/// 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
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)
}
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
return
}
- sb = sigfig(b)
+ sb := sigfig(b)
if sb == 0 {
// zero
mpmovefltflt(a, b)
}
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
return
}
- sa = sigfig(a)
+ sa := sigfig(a)
if sa == 0 {
// zero
a.Exp = 0
}
// adjust b to top
+ var c Mpflt
mpmovefltflt(&c, b)
Mpshiftfix(&c.Val, Mpscale)
}
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
}
// 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
}
// 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
}
v += v & 1
v >>= 2
- f = float64(v)
+ f := float64(v)
f = math.Ldexp(f, e)
if a.Val.Neg != 0 {
}
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
}
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)
}
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 {
}
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 {
errorexit()
}
- startobj = 0
+ startobj := int64(0)
+ var arhdr [ArhdrSize]byte
if writearchive != 0 {
obj.Bwritestring(bout, "!<arch>\n")
arhdr = [ArhdrSize]byte{}
if writearchive != 0 {
obj.Bflush(bout)
- size = obj.Boffset(bout) - startobj
+ size := obj.Boffset(bout) - startobj
if size&1 != 0 {
obj.Bputc(bout, 0)
}
fmt.Fprintf(bout, "\n!\n")
- externs = nil
+ externs := (*NodeList)(nil)
if externdcl != nil {
externs = externdcl.End
}
dumptypestructs()
// Dump extra globals.
- tmp = externdcl
+ tmp := externdcl
if externs != nil {
externdcl = externs.Next
dumpglobls()
externdcl = tmp
- zero = Pkglookup("zerovalue", Runtimepkg)
+ zero := Pkglookup("zerovalue", Runtimepkg)
ggloblsym(zero, int32(zerosize), obj.DUPOK|obj.RODATA)
dumpdata()
if writearchive != 0 {
obj.Bflush(bout)
- size = obj.Boffset(bout) - startobj
+ size := obj.Boffset(bout) - startobj
if size&1 != 0 {
obj.Bputc(bout, 0)
}
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
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)
}
func Linksym(s *Sym) *obj.LSym {
- var p string
-
if s == nil {
return nil
}
} 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)
}
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
pkg = gostringpkg
}
- sym = Pkglookup(namebuf, pkg)
+ sym := Pkglookup(namebuf, pkg)
// SymUniq flag indicates that data is generated already
if sym.Flags&SymUniq != 0 {
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
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
}
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)
* 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)
}
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)
}
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)
}
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)
}
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)
}
func gdata(nam *Node, nr *Node, wid int) {
- var p *obj.Prog
-
if nr.Op == OLITERAL {
switch nr.Val.Ctype {
case CTCPLX:
}
}
- 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
}
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
// 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)
}
// 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)
}
// 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_
//
// 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
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
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
// 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
}
// 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)
// 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
// 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
// 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)
// 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 {
// 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)
// 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))
// 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)
}
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) {
// 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)
OPRINTN,
ORECOVER,
ORECV:
- t = marktemp(order)
+ t := marktemp(order)
orderexpr(&n.Left, order)
orderexpr(&n.Right, order)
orderexprlist(n.List, order)
// 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
}
// 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)
// 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)
// 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)
// 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)
case OCALLFUNC,
OCALLINTER,
OCALLMETH:
- t = marktemp(order)
+ t := marktemp(order)
ordercall(n, order)
order.out = list(order.out, n)
// 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.
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)
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
// 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)
// 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
// 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) {
// 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 {
// 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)
// 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)
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)
// 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))
}
// 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
// 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)
// 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))
}
// 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 {
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)
// 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
}
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)
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.
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)
}
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
}
}
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)
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])
}
}
// 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
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
}
// 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
}
// 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
}
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
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
}
// 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
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
}
}
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)
}
func Cgen_checknil(n *Node) {
- var reg Node
-
if Disable_checknil != 0 {
return
}
}
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)
* 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")
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)
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 {
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
}
func xmalloc(size uint32) interface{} {
- var result interface{}
-
- result = make([]byte, size)
+ result := (interface{})(make([]byte, size))
if result == nil {
Fatal("malloc failed")
}
// 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
// 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
// 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
// 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
// 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.
// 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)
}
// 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)
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))
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
}
// 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")
// 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)
}
// 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")
// 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 {
// 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
// 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
// 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)
}
// 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)
// 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:
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:
}
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,
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,
// 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)
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)
// 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++ {
}
}
// 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 = "@"
}
// 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])
}
// 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)
}
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)
}
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)
// 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
}
}
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 {
}
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")
// 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)
}
// 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))
}
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)
}
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)
// 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
// 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)
// 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
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)
// 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
// 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 {
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++ {
// so low that it hardly seems to be worth the complexity.
change = 1
+ var succ *BasicBlock
for change != 0 {
change = 0
// 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
}
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
-
- for i = 0; i < int32(len(lv.cfg)); i++ {
+ 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 := int32(0); i < int32(len(lv.cfg)); i++ {
bb = lv.cfg[i]
// Compute avarinitany and avarinitall for entry to block.
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] != '.' {
)
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)
// 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)
// 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 {
}
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
}
// 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")
}
// 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
// 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
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)
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
}
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)
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
}
/* 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 {
/* 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
}
}
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)
}
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.
// 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)
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")
// 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 {
}
// 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
}
}
// 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 {
}
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
}
}
* 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)
}
}
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
}
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
}
}
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
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) {
}
}
- 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 {
}
func Uniqs(r *Flow) *Flow {
- var r1 *Flow
-
- r1 = r.S1
+ r1 := r.S1
if r1 == nil {
r1 = r.S2
if r1 == nil {
}
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
}
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]
// 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)
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
// 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) {
}
// 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_)]))
// 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)
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 {
}
// 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 {
}
// Delete merged nodes from declaration list.
- for lp = &Curfn.Dcl; ; {
+ var l *NodeList
+ for lp := &Curfn.Dcl; ; {
l = *lp
if l == nil {
break
}
// Clear aux structures.
- for i = 0; i < len(var_); i++ {
+ for i := 0; i < len(var_); i++ {
var_[i].node.Opt = nil
}
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 {
}
}
- 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)
}
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 {
}
}
- for f = f0; f != f1; f = f.S1 {
+ for f := f0; f != f1; f = f.S1 {
varkillwalk(v, f.S2, gen)
}
}
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
}
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
}
}
- 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)
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) {
nilwalkback(fcheck, f2, gen);
*/
func nilwalkfwd(fcheck *Flow) {
- var f *Flow
- var last *Flow
var p *obj.Prog
var info ProgInfo
// 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)
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
}
}
func racewalk(fn *Node) {
- var nd *Node
- var nodpc *Node
- var s string
-
if ispkgin(omit_pkgs) || isforkfunc(fn) {
return
}
// 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)
// 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
// 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)
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)
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) {
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)
}
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);
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)
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"
}
}
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])
}
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
// 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.
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),
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)
}
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)
}
}
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
}
// to avoid erroneous processing by racewalk.
n.List = nil
- hv2 = nil
+ hv2 := (*Node)(nil)
+ var body *NodeList
switch t.Etype {
default:
Fatal("walkrange")
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) {
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)
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))
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)
}
// 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)))
}
} 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)
// 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
// 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)
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)
// 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))
// 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))
}
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
}
}
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 {
l2 = l2.link
}
- le = l
+ le := l
for {
if l1 == nil {
)
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
}
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 {
}
// 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
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
// 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])
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
}
func hiter(t *Type) *Type {
- var n int32
- var field [12]*Type
- var i *Type
-
if t.Hiter != nil {
return t.Hiter
}
// 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))
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
* 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
* 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
expandmeth(mt)
// type stored in interface word
- it = t
+ it := t
if !isdirectiface(it) {
it = Ptrto(t)
// 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))
}
*/
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")
}
var dimportpath_gopkg *Pkg
func dimportpath(p *Pkg) {
- var nam string
- var n *Node
-
if p.Pathsym != nil {
return
}
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
* ../../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
}
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 {
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)
}
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,
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
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 {
// 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.
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
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 {
// gc
if gcprog {
+ var gcprog1 *Sym
+ var gcprog0 *Sym
gengcprog(t, &gcprog0, &gcprog1)
if gcprog0 != nil {
ot = dsymptr(s, ot, gcprog0, 0)
}
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)
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
}
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);
}
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.
// 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);
}
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);
}
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
}
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
}
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);
* 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,
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
}
}
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
Fatal("dtypesym %v", Tconv(t, 0))
}
- s = typesym(t)
+ s := typesym(t)
if s.Flags&SymSiggen != 0 {
return s
}
// 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
}
}
ok:
- ot = 0
- xt = 0
+ ot := 0
+ xt := 0
switch t.Etype {
default:
ot = dcommontype(s, ot, t)
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)
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
// ../../runtime/type.go:/ChanType
case TCHAN:
- s1 = dtypesym(t.Type)
+ s1 := dtypesym(t.Type)
ot = dcommontype(s, ot, t)
xt = ot - 3*Widthptr
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)
}
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++
}
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)
// ../../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)
}
// ../../runtime/type.go:/PtrType
- s1 = dtypesym(t.Type)
+ s1 := dtypesym(t.Type)
ot = dcommontype(s, ot, t)
xt = ot - 3*Widthptr
case TARRAY,
TCHAN,
TMAP:
- slink = typelinksym(t)
+ slink := typelinksym(t)
dsymptr(slink, 0, s, 0)
ggloblsym(slink, int32(Widthptr), int8(dupok|obj.RODATA))
}
}
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
}
// 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
}
// 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)
// 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]))
}
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)
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)
// 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)
}
// ../../runtime/alg.go:/typeAlg
- ot = 0
+ ot := 0
ot = dsymptr(s, ot, hashfunc, 0)
ot = dsymptr(s, ot, eqfunc, 0)
}
func usegcprog(t *Type) bool {
- var size int64
- var nptr int64
-
if !haspointers(t) {
return false
}
}
// 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
}
// 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) {
}
// 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)
// 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
// 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)
}
// 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
}
// 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,
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)
}
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
}
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
}
func walkvardef(n *Node, f *Flow, active int) {
var f1 *Flow
- var f2 *Flow
var bn int
var v *Var
}
}
- 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)
}
* 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
}
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
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
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
}
}
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 {
// 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
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]
}
}
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
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 {
}
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]
}
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:
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)
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)
}
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
}
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
}
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
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
}
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) {
}
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 {
}
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
}
* 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]))
}
* 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
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
}
}
- 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++ {
* (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++
* iterate propagating usage
* back until flow graph is complete
*/
+ var f1 *Flow
+ var i int
+ var f *Flow
loop1:
change = 0
* 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
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 {
}
}
- 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])
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)
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)
}
/*
* 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)
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)
/*
* 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
}
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)
}
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
// 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))
}
// 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))
// 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
// 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
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:
// 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)
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 }
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)
}
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
// 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]))))
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])))
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))
// 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)
}
// 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
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 {
// reached a new unvisited node.
n.Initorder = InitPending
- l = new(NodeList)
+ l := new(NodeList)
if l == nil {
Flusherrors()
Yyerror("out of memory")
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 {
// 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
* 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
}
if r.Defn.Op != OAS {
return false
}
- orig = r
+ orig := r
r = r.Defn.Right
switch r.Op {
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)
// 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
}
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);
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
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))
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
}
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)
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
* 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
}
}
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)
)
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) {
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 {
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))
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))
}
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
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)
// 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
*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))
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 {
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
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 {
}
// 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 {
}
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")
Fatal("anylit: not ptr")
}
+ var r *Node
if n.Right != nil {
r = Nod(OADDR, n.Right, nil)
typecheck(&r, Erv)
}
walkexpr(&r, init)
- a = Nod(OAS, var_, r)
+ a := Nod(OAS, var_, r)
typecheck(&a, Etop)
*init = list(*init, a)
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)
// 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)
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)
// 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)
}
func stataddr(nam *Node, n *Node) bool {
- var l int
-
if n == nil {
goto no
}
if !stataddr(nam, n.Left) {
break
}
- l = getlit(n.Right)
+ l := getlit(n.Right)
if l < 0 {
break
}
}
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")
}
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")
}
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")
}
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
// 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
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 {
// 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
}
nr = n.Right
nl = n.Left
if nr == nil {
+ var nam Node
if !stataddr(&nam, nl) {
goto no
}
}
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))
}
}
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
}
}
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)
}
var yyerror_lastsyntax int
func Yyerror(fmt_ string, args ...interface{}) {
- var i int
-
if fmt_ == "%s" && len(args) == 1 && args[0] == "syntax error" {
nsyntaxerrors++
}
}
// 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
}
func Warn(fmt_ string, args ...interface{}) {
-
adderr(parserline(), fmt_, args)
hcrash()
}
func Fatal(fmt_ string, args ...interface{}) {
-
Flusherrors()
fmt.Printf("%v: internal compiler error: ", Ctxt.Line(int(lineno)))
}
func setlineno(n *Node) int32 {
- var lno int32
-
- lno = lineno
+ lno := lineno
if n != nil {
switch n.Op {
case ONAME,
}
func stringhash(p string) uint32 {
- var h uint32
var c int
- h = 0
+ h := uint32(0)
for {
c, p = intstarstringplusplus(p)
if c == 0 {
}
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
}
}
}
- s = new(Sym)
+ s := new(Sym)
s.Name = name
s.Pkg = pkg
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
}
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")
}
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
}
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
}
}
func algtype1(t *Type, bad **Type) int {
- var a int
- var ret int
- var t1 *Type
-
if bad != nil {
*bad = nil
}
return ANOEQ
}
- a = algtype1(t.Type, bad)
+ a := algtype1(t.Type, bad)
if a == ANOEQ || a == AMEM {
if a == ANOEQ && bad != nil {
*bad = t
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)
}
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
}
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 {
}
}
- 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)
}
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
}
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
}
}
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++
}
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)
}
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)
}
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
}
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) {
}
// fixed array
- r = typ(TARRAY)
+ r := typ(TARRAY)
r.Type = t
r.Bound = bound
}
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)
}
func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) bool {
- var l TypePairList
-
if t1 == t2 {
return true
}
if onlist(assumed_equal, t1, t2) {
return true
}
+ var l TypePairList
l.next = assumed_equal
l.t1 = t1
l.t2 = t2
// 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 = ""
}
// 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
}
}
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"
}
// 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 = ""
}
}
// 1. src can be assigned to dst.
- op = assignop(src, dst, why)
+ op := assignop(src, dst, why)
if op != 0 {
return op
}
// 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
}
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--
// 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
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
* 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,
}
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
}
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
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)
}
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)
}
return s.Def
}
- n = Nod(0, nil, nil)
+ n := Nod(0, nil, nil)
*n = *s.Def
n.Type = deep(s.Def.Type)
*/
func typehash(t *Type) uint32 {
var p string
- var d MD5
if t.Thistuple != 0 {
// hide method receiver from Tpretty
}
//print("typehash: %s\n", p);
+ var d MD5
md5reset(&d)
md5write(&d, []byte(p), len(p))
}
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)
func frame(context int) {
var l *NodeList
- var n *Node
- var w int64
if context != 0 {
fmt.Printf("--- external frame ---\n")
return
}
+ var n *Node
+ var w int64
for ; l != nil; l = l.Next {
n = l.N
w = -1
* 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
}
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))
}
}
}
- s = fmt_
+ s := fmt_
Yyerror("illegal types for operand: %v%s", Oconv(int(o), 0), s)
}
* 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
}
}
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
}
}
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))
* 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
}
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)
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)
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
}
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)
}
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))
}
// 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
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
// 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
}
d--
- for f = u.Type; f != nil; f = f.Down {
+ for f := u.Type; f != nil; f = f.Down {
if f.Embedded == 0 {
continue
}
// 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
}
}
// 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))
}
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
}
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
}
}
func expand1(t *Type, d int, followptr int) {
- var f *Type
- var u *Type
-
if t.Trecur != 0 {
return
}
expand0(t, followptr)
}
- u = t
+ u := t
if Isptr[u.Etype] != 0 {
followptr = 1
u = u.Type
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
}
}
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
}
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)
}
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)
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
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))
}
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
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))
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) {
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
}
}
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])))
}
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")
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])))
* 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))
}
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)
// 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
// h *= mul
// Same multipliers as in runtime.memhash.
+ var mul int64
if Widthptr == 4 {
mul = 3267000013
} else {
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)
// Walk the struct using memhash for runs of AMEM
// and calling specific hash functions for the others.
case TSTRUCT:
- first = nil
-
- offend = 0
- for t1 = t.Type; ; t1 = t1.Down {
+ first := (*Type)(nil)
+
+ 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 {
}
}
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, nh)
fn.Nbody = list(fn.Nbody, r)
// 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)
// 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 {
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
}
// 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
* 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))
}
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)
// 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
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)
// 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 {
}
// 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)
// 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)
}
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))
}
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
}
// 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) {
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) {
* 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
}
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
}
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 {
// 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
}
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))
}
}
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
* return nelem of list
*/
func count(l *NodeList) int {
- var n int64
-
- n = 0
+ n := int64(0)
for ; l != nil; l = l.Next {
n++
}
* 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++
}
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
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
}
v = -v
b = 1
- for i = 0; i < 64; i++ {
+ for i := 0; i < 64; i++ {
if b == v {
return i + 1000
}
* 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 {
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)
}
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
* 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
mask = 0xffffffffffffffff
}
- two31 = mask ^ (mask >> 1)
+ two31 := mask ^ (mask >> 1)
m.Ud &= mask
if m.Ud == 0 || m.Ud == two31 {
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 {
}
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]
}
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.
}
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 {
}
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)
}
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")
}
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
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)
}
// sort by constant value
- n = 0
+ n := 0
switch ct {
case CTFLT:
}
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 {
l2 = l2.link
}
- le = l
+ le := l
for {
if l1 == nil {
* 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 {
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)
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
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
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
}
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))
}
// 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))
* 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 {
}
walkexpr(&sw.Ntest, &sw.Ninit)
- t = sw.Type
+ t := sw.Type
if t == nil {
return
}
*/
exprname = nil
- cas = nil
+ cas := (*NodeList)(nil)
if arg == Strue || arg == Sfalse {
exprname = Nodbool(arg == Strue)
} else if consttype(sw.Ntest) >= 0 {
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
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)
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
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)
}
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")
}
// 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))
* 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
}
return
}
- cas = nil
+ cas := (*NodeList)(nil)
/*
* predeclare temporary variables
*/
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)
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 {
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
/*
* 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:
/*
* 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
*/
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
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) {
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 {
* 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
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
}
* 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)
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 {
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:
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_)
n.Typecheck = 2
+ var l *NodeList
if typecheck_tcfree != nil {
l = typecheck_tcfree
typecheck_tcfree = l.Next
// 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
}
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
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 {
}
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 {
} else {
typechecklist(n.List, Erv)
}
- t = l.Type
+ t := l.Type
if t == nil {
goto error
}
// 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")
}
}
- 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 {
}
ok |= Erv
if t.Outtuple == 1 {
- t = getoutargx(l.Type).Type
+ t := getoutargx(l.Type).Type
if t == nil {
goto error
}
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
}
goto badcall1
}
if Isconst(l, CTCPLX) {
- r = n
+ r := n
if n.Op == OREAL {
n = nodfltconst(&l.Val.U.Cval.Real)
} else {
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
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
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 {
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
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)
}
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
}
goto ret
case ODELETE:
- args = n.List
+ args := n.List
if args == nil {
Yyerror("missing arguments to delete")
goto error
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
case OAPPEND:
ok |= Erv
- args = n.List
+ args := n.List
if args == nil {
Yyerror("missing arguments to append")
goto error
typechecklist(args, Erv)
}
- t = args.N.Type
+ t := args.N.Type
if t == nil {
goto error
}
case OCOPY:
ok |= Etop | Erv
- args = n.List
+ args := n.List
if args == nil || args.Next == nil {
Yyerror("missing arguments to copy")
goto error
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
}
l = args.N
args = args.Next
typecheck(&l, Erv)
- r = nil
+ r := (*Node)(nil)
if args != nil {
r = args.N
args = args.Next
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
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
}
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])
case OITAB:
ok |= Erv
typecheck(&n.Left, Erv)
- t = n.Left.Type
+ t := n.Left.Type
if t == nil {
goto error
}
case OSPTR:
ok |= Erv
typecheck(&n.Left, Erv)
- t = n.Left.Type
+ t := n.Left.Type
if t == nil {
goto error
}
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))
}
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))
}
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
}
func checksliceindex(l *Node, r *Node, tp *Type) int {
- var t *Type
-
- t = r.Type
+ t := r.Type
if t == nil {
return -1
}
}
func checkdefergo(n *Node) {
- var what string
-
- what = "defer"
+ what := "defer"
if n.Op == OPROC {
what = "go"
}
}
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
}
}
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
}
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
}
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
}
// 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
}
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 {
}
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")
}
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
}
}
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++
}
*/
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
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
}
}
}
- 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 {
}
}
- 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 {
* 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
}
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
}
return // we dont check variables
}
+ var b uint32
switch n.Val.Ctype {
default: // unknown, bool, nil
b = 23
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)
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
}
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)
}
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
}
}
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++
}
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
}
}
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 {
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 {
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 {
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 {
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 {
}
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 {
}
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.
}
}
- 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 {
}
checkassignlist(n, n.List)
+ var l *Node
+ var r *Node
if cl == cr {
// easy
ll = n.List
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)
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)
}
* 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
}
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
// 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
}
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)
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
}
// Double-check use of type as embedded type.
- lno = int(lineno)
+ lno := int(lineno)
if embedlineno != 0 {
lineno = int32(embedlineno)
}
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
// try to resolve the method types for the interfaces
// we just read.
if ntypecheckdeftype == 1 {
+ var l *NodeList
for {
l = methodqueue
if l == nil {
}
}
- 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])
}
}
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 {
return n
}
- l = new(NodeList)
+ l := new(NodeList)
l.N = n
l.Next = typecheckdefstack
typecheckdefstack = l
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")
}
}
- e = n.Defn
+ e := n.Defn
n.Defn = nil
if e == nil {
lineno = n.Lineno
goto ret
}
- t = n.Type
+ t := n.Type
if t != nil {
if okforconst[t.Etype] == 0 {
Yyerror("invalid constant type %v", Tconv(t, 0))
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,
}
func markbreak(n *Node, implicit *Node) {
- var lab *Label
-
if n == nil {
return
}
implicit.Hasbreak = 1
}
} else {
- lab = n.Left.Sym.Label
+ lab := n.Left.Sym.Label
if lab != nil {
lab.Def.Hasbreak = 1
}
}
func isterminating(l *NodeList, top int) bool {
- var def int
- var n *Node
-
if l == nil {
return false
}
for l.Next != nil {
l = l.Next
}
- n = l.N
+ n := l.N
if n == nil {
return false
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
*/
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
if s.Name == "Sizeof" {
typecheck(&r, Erv)
defaultlit(&r, nil)
- tr = r.Type
+ tr := r.Type
if tr == nil {
goto bad
}
// first to track it correctly.
typecheck(&r.Left, Erv)
- base = r.Left
+ base := r.Left
typecheck(&r, Erv)
switch r.Op {
case ODOT,
v = 0
// add offsets for inserted dots.
+ var r1 *Node
for r1 = r; r1.Left != base; r1 = r1.Left {
switch r1.Op {
case ODOT:
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]
// 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]
)
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
}
}
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)
}
}
}
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:
// 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")
}
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
}
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)
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)
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)
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
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))
// 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:
}
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
return
}
- lno = setlineno(n)
+ lno := setlineno(n)
if Debug['w'] > 1 {
Dump("walk-before", n)
// 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
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")
// 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)
// 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)
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
// 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
}
}
}
- 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
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)
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"
}
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)
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)
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)
*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))
*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)
*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,
}
}
+ var key *Node
if p != "" {
// fast versions take key by value
key = r.Right
// 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,
// 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)
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
*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.Etype = 1 // addr does not escape
- from = "I"
+ from := "I"
- to = "T"
+ to := "T"
if isnilinter(r.Left.Type) {
from = "E"
}
} 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
}
// 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
// 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) {
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))
}
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
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)
* 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
/*
* 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
// 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)
if n.Bounded {
goto ret
}
- t = n.Left.Type
+ t := n.Left.Type
if t != nil && Isptr[t.Etype] != 0 {
t = t.Type
}
// 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
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,
}
}
+ var key *Node
if p != "" {
// fast versions take key by value
key = n.Right
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)
// 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
// 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
goto ret
}
+ var r *Node
if n.Etype == OEQ || n.Etype == ONE {
// prepare for rewrite below
n.Left = cheapexpr(n.Left, init)
// 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)
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)
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]))
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)
}
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)
}
// 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)
}
// 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)
}
// 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)
}
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 {
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)
}
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)
// 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
}
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
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
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 })() {
* 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
}
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
* 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
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
}
* 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 {
}
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 {
* 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))
// 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)
}
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))
}
}
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
}
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)
} 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)
}
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))
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
}
}
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
}
}
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)
* 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)
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)
* 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.
* 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)
* 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
}
// 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
* is the name l mentioned in r?
*/
func vmatch2(l *Node, r *Node) bool {
- var ll *NodeList
-
if r == nil {
return false
}
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
}
* called by sinit.c
*/
func vmatch1(l *Node, r *Node) bool {
- var ll *NodeList
-
/*
* isolate all left sides
*/
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
}
* 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
* 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
* 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)
}
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)
}
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)
}
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)
}
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))
}
// 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]))
}
// 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)
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)
//
// 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))))
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)
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 {
}
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)
}
// }
// 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
// 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 {
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))
// 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
cb = nil
}
- bounded = int(n.Etype)
+ bounded := int(n.Etype)
+ var bound *Node
if n.Op == OSLICESTR {
bound = Nod(OLEN, src, nil)
} else {
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) {
}
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
// 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]
}
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 {
// offs = [width *] lo, but omit if zero
if lb != nil {
+ var w int64
if n.Op == OSLICESTR {
w = 1
} else {
}
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])))
}
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
// 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
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)
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)
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
}
}
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
}
}
// 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
}
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
* 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
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)
* 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
return
}
+ var n1 *Node
+ var m Magic
+ var n2 *Node
if pow < 0 {
goto divbymul
}
// 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)
}
// 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))
}
break
}
- nc = Nod(OXXX, nil, nil)
+ nc := Nod(OXXX, nil, nil)
if n.Op == OMOD {
// n = nl & (nr-1)
n.Op = OAND
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
// 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)
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 {
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.
// 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) {
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
}
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
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
}
}
func usefield(n *Node) {
- var field *Type
- var l *Type
-
if obj.Fieldtrack_enabled == 0 {
return
}
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))
}
Yyerror("tracked field must be exported (upper case)")
}
- l = typ(0)
+ l := typ(0)
l.Type = field
l.Down = Curfn.Paramfld
Curfn.Paramfld = l
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)
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))
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))
fn.Nname.Ntype = t
declare(fn.Nname, PFUNC)
- oldfn = Curfn
+ oldfn := Curfn
Curfn = nil
funchdr(fn)
}
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)
}
}
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
}
}
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)
}
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
}
func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 {
- var r *Reloc
-
if s.Type == 0 {
s.Type = SDATA
}
Symgrow(ctxt, s, s.Size)
}
- r = Addrel(s)
+ r := Addrel(s)
r.Sym = t
r.Off = int32(off)
r.Siz = uint8(ctxt.Arch.Ptrsize)
}
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)
}
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
}
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
)
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 {
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
}
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
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
}
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
// 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])
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
}
return
}
n--
+ var dlno int32
+ var file string
if a[n].line != nil {
file = a[n].line.Name
dlno = a[n].ldel - 1
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 {
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
}
func Linklinehist(ctxt *Link, lineno int, f string, offset int) {
- var h *Hist
-
if false { // debug['f']
if f != "" {
if offset != 0 {
}
}
- h = new(Hist)
+ h := new(Hist)
*h = Hist{}
h.Name = f
h.Line = int32(lineno)
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
}
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))
}
}
* 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
// 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
// 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)
}
// 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
}
}
// 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)
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)
}
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)
}
}
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 {
}
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])
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 {
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))
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 {
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:]
// 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
}
}
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
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)
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)
// 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;
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)
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")
// 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);
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 {
}
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)
}
// 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)
}
// pcdata.
- for i = 0; i < npcdata; i++ {
+ for i := 0; i < npcdata; i++ {
if (havepc[i/32]>>uint(i%32))&1 == 0 {
continue
}
// 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
// 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:]
}
func pciternext(it *Pciter) {
- var v uint32
- var dv int32
-
it.pc = it.nextpc
if it.done != 0 {
return
}
// value delta
- v = getvarint(&it.p)
+ v := getvarint(&it.p)
if v == 0 && it.start == 0 {
it.done = 1
}
it.start = 0
- dv = int32(v>>1) ^ (int32(v<<31) >> 31)
+ dv := int32(v>>1) ^ (int32(v<<31) >> 31)
it.value += dv
// pc delta
}
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
}
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
}
}
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()
// On arm, record goarm.
if ctxt.Arch.Thechar == '5' {
- p = Getgoarm()
+ p := Getgoarm()
if p != "" {
ctxt.Goarm = int32(Atoi(p))
} else {
}
func linknewsym(ctxt *Link, symb string, v int) *LSym {
- var s *LSym
-
- s = new(LSym)
+ s := new(LSym)
*s = LSym{}
s.Dynid = -1
}
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
}
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