[dev.cc] cmd/5g etc: code cleanup: delay var decls and eliminate dead code
Ran rsc.io/grind rev 6f0e601 on the source files.
The cleanups move var declarations as close to the use
as possible, splitting disjoint uses of the var into separate
variables. They also remove dead code (especially in
func sudoaddable), which helps with the var moving.
There's more cleanup to come, but this alone cuts the
time spent compiling html/template on my 2013 MacBook Pro
from 3.1 seconds to 2.3 seconds.
Change-Id: I4de499f47b1dd47a560c310bbcde6b08d425cfd6
Reviewed-on: https://go-review.googlesource.com/5637
Reviewed-by: Rob Pike <r@golang.org>
diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go
index dba7dc3..f7c07584 100644
--- a/src/cmd/internal/gc/subr.go
+++ b/src/cmd/internal/gc/subr.go
@@ -44,12 +44,10 @@
}
func adderrorname(n *Node) {
- var old string
-
if n.Op != ODOT {
return
}
- old = fmt.Sprintf("%v: undefined: %v\n", n.Line(), Nconv(n.Left, 0))
+ old := fmt.Sprintf("%v: undefined: %v\n", n.Line(), Nconv(n.Left, 0))
if len(errors) > 0 && int32(errors[len(errors)-1].lineno) == n.Lineno && errors[len(errors)-1].msg == old {
errors[len(errors)-1].msg = fmt.Sprintf("%v: undefined: %v in %v\n", n.Line(), Nconv(n.Left, 0), Nconv(n, 0))
}
@@ -74,11 +72,8 @@
}
func (x errcmp) Less(i, j int) bool {
- var a *Error
- var b *Error
-
- a = &x[i]
- b = &x[j]
+ a := &x[i]
+ b := &x[j]
if a.lineno != b.lineno {
return a.lineno-b.lineno < 0
}
@@ -89,14 +84,12 @@
}
func Flusherrors() {
- var i int
-
obj.Bflush(&bstdout)
if len(errors) == 0 {
return
}
sort.Sort(errcmp(errors[:len(errors)]))
- for i = 0; i < len(errors); i++ {
+ for i := 0; i < len(errors); i++ {
if i == 0 || errors[i].msg != errors[i-1].msg {
fmt.Printf("%s", errors[i].msg)
}
@@ -134,8 +127,6 @@
var yyerror_lastsyntax int
func Yyerror(fmt_ string, args ...interface{}) {
- var i int
-
if fmt_ == "%s" && len(args) == 1 && args[0] == "syntax error" {
nsyntaxerrors++
}
@@ -169,7 +160,7 @@
}
// look for parse state-specific errors in list (see go.errors).
- for i = 0; i < len(yymsg); i++ {
+ for i := 0; i < len(yymsg); i++ {
if yymsg[i].yystate == yystate && yymsg[i].yychar == yychar_subr {
yyerrorl(int(lexlineno), "syntax error: %s", yymsg[i].msg)
return
@@ -204,7 +195,6 @@
}
func Warn(fmt_ string, args ...interface{}) {
-
adderr(parserline(), fmt_, args)
hcrash()
@@ -218,7 +208,6 @@
}
func Fatal(fmt_ string, args ...interface{}) {
-
Flusherrors()
fmt.Printf("%v: internal compiler error: ", Ctxt.Line(int(lineno)))
@@ -259,9 +248,7 @@
}
func setlineno(n *Node) int32 {
- var lno int32
-
- lno = lineno
+ lno := lineno
if n != nil {
switch n.Op {
case ONAME,
@@ -285,10 +272,9 @@
}
func stringhash(p string) uint32 {
- var h uint32
var c int
- h = 0
+ h := uint32(0)
for {
c, p = intstarstringplusplus(p)
if c == 0 {
@@ -312,13 +298,9 @@
}
func Pkglookup(name string, pkg *Pkg) *Sym {
- var s *Sym
- var h uint32
- var c int
-
- h = stringhash(name) % NHASH
- c = int(name[0])
- for s = hash[h]; s != nil; s = s.Link {
+ h := stringhash(name) % NHASH
+ c := int(name[0])
+ for s := hash[h]; s != nil; s = s.Link {
if int(s.Name[0]) != c || s.Pkg != pkg {
continue
}
@@ -327,7 +309,7 @@
}
}
- s = new(Sym)
+ s := new(Sym)
s.Name = name
s.Pkg = pkg
@@ -351,12 +333,10 @@
func importdot(opkg *Pkg, pack *Node) {
var s *Sym
var s1 *Sym
- var h uint32
- var n int
var pkgerror string
- n = 0
- for h = 0; h < NHASH; h++ {
+ n := 0
+ for h := uint32(0); h < NHASH; h++ {
for s = hash[h]; s != nil; s = s.Link {
if s.Pkg != opkg {
continue
@@ -389,14 +369,11 @@
}
func gethunk() {
- var h string
- var nh int32
-
- nh = NHUNK
+ nh := int32(NHUNK)
if thunk >= 10*NHUNK {
nh = 10 * NHUNK
}
- h = string(make([]byte, nh))
+ h := string(make([]byte, nh))
if h == "" {
Flusherrors()
Yyerror("out of memory")
@@ -409,9 +386,7 @@
}
func Nod(op int, nleft *Node, nright *Node) *Node {
- var n *Node
-
- n = new(Node)
+ n := new(Node)
n.Op = uint8(op)
n.Left = nleft
n.Right = nright
@@ -423,12 +398,10 @@
}
func saveorignode(n *Node) {
- var norig *Node
-
if n.Orig != nil {
return
}
- norig = Nod(int(n.Op), nil, nil)
+ norig := Nod(int(n.Op), nil, nil)
*norig = *n
n.Orig = norig
}
@@ -447,10 +420,6 @@
}
func algtype1(t *Type, bad **Type) int {
- var a int
- var ret int
- var t1 *Type
-
if bad != nil {
*bad = nil
}
@@ -523,7 +492,7 @@
return ANOEQ
}
- a = algtype1(t.Type, bad)
+ a := algtype1(t.Type, bad)
if a == ANOEQ || a == AMEM {
if a == ANOEQ && bad != nil {
*bad = t
@@ -539,8 +508,9 @@
return algtype1(t.Type.Type, bad)
}
- ret = AMEM
- for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ ret := AMEM
+ var a int
+ for t1 := t.Type; t1 != nil; t1 = t1.Down {
// All fields must be comparable.
a = algtype1(t1.Type, bad)
@@ -564,9 +534,7 @@
}
func algtype(t *Type) int {
- var a int
-
- a = algtype1(t, nil)
+ a := algtype1(t, nil)
if a == AMEM || a == ANOEQ {
if Isslice(t) {
return ASLICE
@@ -596,13 +564,10 @@
}
func maptype(key *Type, val *Type) *Type {
- var t *Type
- var bad *Type
- var atype int
- var mtype int
-
if key != nil {
- atype = algtype1(key, &bad)
+ var bad *Type
+ atype := algtype1(key, &bad)
+ var mtype int
if bad == nil {
mtype = int(key.Etype)
} else {
@@ -631,16 +596,14 @@
}
}
- t = typ(TMAP)
+ t := typ(TMAP)
t.Down = key
t.Type = val
return t
}
func typ(et int) *Type {
- var t *Type
-
- t = new(Type)
+ t := new(Type)
t.Etype = uint8(et)
t.Width = BADWIDTH
t.Lineno = int(lineno)
@@ -659,12 +622,8 @@
}
func (x methcmp) Less(i, j int) bool {
- var a *Type
- var b *Type
- var k int
-
- a = x[i]
- b = x[j]
+ a := x[i]
+ b := x[j]
if a.Sym == nil && b.Sym == nil {
return false
}
@@ -674,12 +633,12 @@
if b.Sym == nil {
return 1 < 0
}
- k = stringsCompare(a.Sym.Name, b.Sym.Name)
+ k := stringsCompare(a.Sym.Name, b.Sym.Name)
if k != 0 {
return k < 0
}
if !exportname(a.Sym.Name) {
- k = stringsCompare(a.Sym.Pkg.Path.S, b.Sym.Pkg.Path.S)
+ k := stringsCompare(a.Sym.Pkg.Path.S, b.Sym.Pkg.Path.S)
if k != 0 {
return k < 0
}
@@ -689,20 +648,17 @@
}
func sortinter(t *Type) *Type {
- var f *Type
- var i int
- var a []*Type
-
if t.Type == nil || t.Type.Down == nil {
return t
}
- i = 0
- for f = t.Type; f != nil; f = f.Down {
+ i := 0
+ for f := t.Type; f != nil; f = f.Down {
i++
}
- a = make([]*Type, i)
+ a := make([]*Type, i)
i = 0
+ var f *Type
for f = t.Type; f != nil; f = f.Down {
a[i] = f
i++
@@ -723,9 +679,7 @@
}
func Nodintconst(v int64) *Node {
- var c *Node
-
- c = Nod(OLITERAL, nil, nil)
+ c := Nod(OLITERAL, nil, nil)
c.Addable = 1
c.Val.U.Xval = new(Mpint)
Mpmovecfix(c.Val.U.Xval, v)
@@ -736,9 +690,7 @@
}
func nodfltconst(v *Mpflt) *Node {
- var c *Node
-
- c = Nod(OLITERAL, nil, nil)
+ c := Nod(OLITERAL, nil, nil)
c.Addable = 1
c.Val.U.Fval = new(Mpflt)
mpmovefltflt(c.Val.U.Fval, v)
@@ -764,18 +716,14 @@
}
func nodnil() *Node {
- var c *Node
-
- c = Nodintconst(0)
+ c := Nodintconst(0)
c.Val.Ctype = CTNIL
c.Type = Types[TNIL]
return c
}
func Nodbool(b bool) *Node {
- var c *Node
-
- c = Nodintconst(0)
+ c := Nodintconst(0)
c.Val.Ctype = CTBOOL
c.Val.U.Bval = int16(bool2int(b))
c.Type = idealbool
@@ -783,10 +731,7 @@
}
func aindex(b *Node, t *Type) *Type {
- var r *Type
- var bound int64
-
- bound = -1 // open bound
+ bound := int64(-1) // open bound
typecheck(&b, Erv)
if b != nil {
switch consttype(b) {
@@ -803,7 +748,7 @@
}
// fixed array
- r = typ(TARRAY)
+ r := typ(TARRAY)
r.Type = t
r.Bound = bound
@@ -811,12 +756,11 @@
}
func treecopy(n *Node) *Node {
- var m *Node
-
if n == nil {
return nil
}
+ var m *Node
switch n.Op {
default:
m = Nod(OXXX, nil, nil)
@@ -1023,8 +967,6 @@
}
func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) bool {
- var l TypePairList
-
if t1 == t2 {
return true
}
@@ -1053,6 +995,7 @@
if onlist(assumed_equal, t1, t2) {
return true
}
+ var l TypePairList
l.next = assumed_equal
l.t1 = t1
l.t2 = t2
@@ -1159,10 +1102,6 @@
// If so, return op code to use in conversion.
// If not, return 0.
func assignop(src *Type, dst *Type, why *string) int {
- var missing *Type
- var have *Type
- var ptr int
-
if why != nil {
*why = ""
}
@@ -1197,6 +1136,9 @@
// 3. dst is an interface type and src implements dst.
if dst.Etype == TINTER && src.Etype != TNIL {
+ var missing *Type
+ var ptr int
+ var have *Type
if implements(src, dst, &missing, &have, &ptr) {
return OCONVIFACE
}
@@ -1233,6 +1175,9 @@
}
if src.Etype == TINTER && dst.Etype != TBLANK {
+ var have *Type
+ var ptr int
+ var missing *Type
if why != nil && implements(dst, src, &missing, &have, &ptr) {
*why = ": need type assertion"
}
@@ -1281,8 +1226,6 @@
// If so, return op code to use in conversion (maybe OCONVNOP).
// If not, return 0.
func convertop(src *Type, dst *Type, why *string) int {
- var op int
-
if why != nil {
*why = ""
}
@@ -1295,7 +1238,7 @@
}
// 1. src can be assigned to dst.
- op = assignop(src, dst, why)
+ op := assignop(src, dst, why)
if op != 0 {
return op
}
@@ -1381,11 +1324,6 @@
// Convert node n for assignment to type t.
func assignconv(n *Node, t *Type, context string) *Node {
- var op int
- var r *Node
- var old *Node
- var why string
-
if n == nil || n.Type == nil || n.Type.Broke != 0 {
return n
}
@@ -1394,7 +1332,7 @@
Yyerror("use of untyped nil")
}
- old = n
+ old := n
old.Diag++ // silence errors about n; we'll issue one below
defaultlit(&n, t)
old.Diag--
@@ -1406,7 +1344,7 @@
// if the next step is non-bool (like interface{}).
if n.Type == idealbool && t.Etype != TBOOL {
if n.Op == ONAME || n.Op == OLITERAL {
- r = Nod(OCONVNOP, n, nil)
+ r := Nod(OCONVNOP, n, nil)
r.Type = Types[TBOOL]
r.Typecheck = 1
r.Implicit = 1
@@ -1418,13 +1356,14 @@
return n
}
- op = assignop(n.Type, t, &why)
+ var why string
+ op := assignop(n.Type, t, &why)
if op == 0 {
Yyerror("cannot use %v as type %v in %s%s", Nconv(n, obj.FmtLong), Tconv(t, 0), context, why)
op = OCONV
}
- r = Nod(op, n, nil)
+ r := Nod(op, n, nil)
r.Type = t
r.Typecheck = 1
r.Implicit = 1
@@ -1517,11 +1456,8 @@
* Is a conversion between t1 and t2 a no-op?
*/
func Noconv(t1 *Type, t2 *Type) bool {
- var e1 int
- var e2 int
-
- e1 = int(Simtype[t1.Etype])
- e2 = int(Simtype[t2.Etype])
+ e1 := int(Simtype[t1.Etype])
+ e2 := int(Simtype[t2.Etype])
switch e1 {
case TINT8,
@@ -1560,12 +1496,10 @@
}
func shallow(t *Type) *Type {
- var nt *Type
-
if t == nil {
return nil
}
- nt = typ(0)
+ nt := typ(0)
*nt = *t
if t.Orig == t {
nt.Orig = nt
@@ -1574,13 +1508,11 @@
}
func deep(t *Type) *Type {
- var nt *Type
- var xt *Type
-
if t == nil {
return nil
}
+ var nt *Type
switch t.Etype {
default:
nt = t // share from here down
@@ -1610,7 +1542,7 @@
case TSTRUCT:
nt = shallow(t)
nt.Type = shallow(t.Type)
- xt = nt.Type
+ xt := nt.Type
for t = t.Type; t != nil; t = t.Down {
xt.Type = deep(t.Type)
@@ -1623,10 +1555,7 @@
}
func syslook(name string, copy int) *Node {
- var s *Sym
- var n *Node
-
- s = Pkglookup(name, Runtimepkg)
+ s := Pkglookup(name, Runtimepkg)
if s == nil || s.Def == nil {
Fatal("syslook: can't find runtime.%s", name)
}
@@ -1635,7 +1564,7 @@
return s.Def
}
- n = Nod(0, nil, nil)
+ n := Nod(0, nil, nil)
*n = *s.Def
n.Type = deep(s.Def.Type)
@@ -1656,7 +1585,6 @@
*/
func typehash(t *Type) uint32 {
var p string
- var d MD5
if t.Thistuple != 0 {
// hide method receiver from Tpretty
@@ -1669,6 +1597,7 @@
}
//print("typehash: %s\n", p);
+ var d MD5
md5reset(&d)
md5write(&d, []byte(p), len(p))
@@ -1677,12 +1606,10 @@
}
func Ptrto(t *Type) *Type {
- var t1 *Type
-
if Tptr == 0 {
Fatal("ptrto: no tptr")
}
- t1 = typ(Tptr)
+ t1 := typ(Tptr)
t1.Type = t
t1.Width = int64(Widthptr)
t1.Align = uint8(Widthptr)
@@ -1691,8 +1618,6 @@
func frame(context int) {
var l *NodeList
- var n *Node
- var w int64
if context != 0 {
fmt.Printf("--- external frame ---\n")
@@ -1704,6 +1629,8 @@
return
}
+ var n *Node
+ var w int64
for ; l != nil; l = l.Next {
n = l.N
w = -1
@@ -1727,13 +1654,12 @@
* hardest side first to minimize registers.
*/
func ullmancalc(n *Node) {
- var ul int
- var ur int
-
if n == nil {
return
}
+ var ul int
+ var ur int
if n.Ninit != nil {
ul = UINF
goto out
@@ -1788,10 +1714,7 @@
}
func badtype(o int, tl *Type, tr *Type) {
- var fmt_ string
- var s string
-
- fmt_ = ""
+ fmt_ := ""
if tl != nil {
fmt_ += fmt.Sprintf("\n\t%v", Tconv(tl, 0))
}
@@ -1808,7 +1731,7 @@
}
}
- s = fmt_
+ s := fmt_
Yyerror("illegal types for operand: %v%s", Oconv(int(o), 0), s)
}
@@ -1816,10 +1739,9 @@
* iterator to walk a structure declaration
*/
func Structfirst(s *Iter, nn **Type) *Type {
- var n *Type
var t *Type
- n = *nn
+ n := *nn
if n == nil {
goto bad
}
@@ -1854,11 +1776,8 @@
}
func structnext(s *Iter) *Type {
- var n *Type
- var t *Type
-
- n = s.T
- t = n.Down
+ n := s.T
+ t := n.Down
if t == nil {
goto rnil
}
@@ -1907,9 +1826,7 @@
}
func funcnext(s *Iter) *Type {
- var fp *Type
-
- fp = structnext(s)
+ fp := structnext(s)
if fp == nil && s.Done == 0 {
s.Done = 1
fp = Structfirst(s, getinarg(s.Tfunc))
@@ -2004,10 +1921,6 @@
* result is assignable if n is.
*/
func safeexpr(n *Node, init **NodeList) *Node {
- var l *Node
- var r *Node
- var a *Node
-
if n == nil {
return nil
}
@@ -2024,11 +1937,11 @@
return n
case ODOT:
- l = safeexpr(n.Left, init)
+ l := safeexpr(n.Left, init)
if l == n.Left {
return n
}
- r = Nod(OXXX, nil, nil)
+ r := Nod(OXXX, nil, nil)
*r = *n
r.Left = l
typecheck(&r, Erv)
@@ -2037,11 +1950,11 @@
case ODOTPTR,
OIND:
- l = safeexpr(n.Left, init)
+ l := safeexpr(n.Left, init)
if l == n.Left {
return n
}
- a = Nod(OXXX, nil, nil)
+ a := Nod(OXXX, nil, nil)
*a = *n
a.Left = l
walkexpr(&a, init)
@@ -2049,12 +1962,12 @@
case OINDEX,
OINDEXMAP:
- l = safeexpr(n.Left, init)
- r = safeexpr(n.Right, init)
+ l := safeexpr(n.Left, init)
+ r := safeexpr(n.Right, init)
if l == n.Left && r == n.Right {
return n
}
- a = Nod(OXXX, nil, nil)
+ a := Nod(OXXX, nil, nil)
*a = *n
a.Left = l
a.Right = r
@@ -2070,11 +1983,8 @@
}
func copyexpr(n *Node, t *Type, init **NodeList) *Node {
- var a *Node
- var l *Node
-
- l = temp(t)
- a = Nod(OAS, l, n)
+ l := temp(t)
+ a := Nod(OAS, l, n)
typecheck(&a, Etop)
walkexpr(&a, init)
*init = list(*init, a)
@@ -2109,10 +2019,8 @@
}
func Setmaxarg(t *Type, extra int32) {
- var w int64
-
dowidth(t)
- w = t.Argwid
+ w := t.Argwid
if w >= Thearch.MAXWIDTH {
Fatal("bad argwid %v", Tconv(t, 0))
}
@@ -2138,18 +2046,14 @@
// return count of fields+methods
// found with a given name
func lookdot0(s *Sym, t *Type, save **Type, ignorecase int) int {
- var f *Type
- var u *Type
- var c int
-
- u = t
+ u := t
if Isptr[u.Etype] != 0 {
u = u.Type
}
- c = 0
+ c := 0
if u.Etype == TSTRUCT || u.Etype == TINTER {
- for f = u.Type; f != nil; f = f.Down {
+ for f := u.Type; f != nil; f = f.Down {
if f.Sym == s || (ignorecase != 0 && f.Type.Etype == TFUNC && f.Type.Thistuple > 0 && strings.EqualFold(f.Sym.Name, s.Name)) {
if save != nil {
*save = f
@@ -2161,7 +2065,7 @@
u = methtype(t, 0)
if u != nil {
- for f = u.Method; f != nil; f = f.Down {
+ for f := u.Method; f != nil; f = f.Down {
if f.Embedded == 0 && (f.Sym == s || (ignorecase != 0 && strings.EqualFold(f.Sym.Name, s.Name))) {
if save != nil {
*save = f
@@ -2180,16 +2084,14 @@
// answer is in dotlist array and
// count of number of ways is returned.
func adddot1(s *Sym, t *Type, d int, save **Type, ignorecase int) int {
- var f *Type
- var u *Type
- var c int
- var a int
-
if t.Trecur != 0 {
return 0
}
t.Trecur = 1
+ var c int
+ var u *Type
+ var a int
if d == 0 {
c = lookdot0(s, t, save, ignorecase)
goto out
@@ -2205,7 +2107,7 @@
}
d--
- for f = u.Type; f != nil; f = f.Down {
+ for f := u.Type; f != nil; f = f.Down {
if f.Embedded == 0 {
continue
}
@@ -2229,14 +2131,13 @@
// will give shortest unique addressing.
// modify the tree with missing type names.
func adddot(n *Node) *Node {
- var t *Type
var s *Sym
var c int
var d int
typecheck(&n.Left, Etype|Erv)
n.Diag |= n.Left.Diag
- t = n.Left.Type
+ t := n.Left.Type
if t == nil {
goto ret
}
@@ -2270,7 +2171,7 @@
}
// rebuild elided dots
- for c = d - 1; c >= 0; c-- {
+ for c := d - 1; c >= 0; c-- {
n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym))
}
@@ -2298,18 +2199,15 @@
var slist *Symlink
func expand0(t *Type, followptr int) {
- var f *Type
- var u *Type
- var sl *Symlink
-
- u = t
+ u := t
if Isptr[u.Etype] != 0 {
followptr = 1
u = u.Type
}
if u.Etype == TINTER {
- for f = u.Type; f != nil; f = f.Down {
+ var sl *Symlink
+ for f := u.Type; f != nil; f = f.Down {
if f.Sym.Flags&SymUniq != 0 {
continue
}
@@ -2326,7 +2224,8 @@
u = methtype(t, 0)
if u != nil {
- for f = u.Method; f != nil; f = f.Down {
+ var sl *Symlink
+ for f := u.Method; f != nil; f = f.Down {
if f.Sym.Flags&SymUniq != 0 {
continue
}
@@ -2341,9 +2240,6 @@
}
func expand1(t *Type, d int, followptr int) {
- var f *Type
- var u *Type
-
if t.Trecur != 0 {
return
}
@@ -2356,7 +2252,7 @@
expand0(t, followptr)
}
- u = t
+ u := t
if Isptr[u.Etype] != 0 {
followptr = 1
u = u.Type
@@ -2366,7 +2262,7 @@
goto out
}
- for f = u.Type; f != nil; f = f.Down {
+ for f := u.Type; f != nil; f = f.Down {
if f.Embedded == 0 {
continue
}
@@ -2381,17 +2277,13 @@
}
func expandmeth(t *Type) {
- var sl *Symlink
- var f *Type
- var c int
- var d int
-
if t == nil || t.Xmethod != nil {
return
}
// mark top-level method symbols
// so that expand1 doesn't consider them.
+ var f *Type
for f = t.Method; f != nil; f = f.Down {
f.Sym.Flags |= SymUniq
}
@@ -2402,7 +2294,9 @@
expand1(t, len(dotlist)-1, 0)
// check each method to be uniquely reachable
- for sl = slist; sl != nil; sl = sl.link {
+ var c int
+ var d int
+ for sl := slist; sl != nil; sl = sl.link {
sl.field.Sym.Flags &^= SymUniq
for d = 0; d < len(dotlist); d++ {
c = adddot1(sl.field.Sym, t, d, &f, 0)
@@ -2426,7 +2320,7 @@
}
t.Xmethod = t.Method
- for sl = slist; sl != nil; sl = sl.link {
+ for sl := slist; sl != nil; sl = sl.link {
if sl.good != 0 {
// add it to the base type method list
f = typ(TFIELD)
@@ -2449,14 +2343,11 @@
var savet Iter
var a *Node
var n *Node
- var args *NodeList
- var t *Type
var buf string
- var gen int
- args = nil
- gen = 0
- for t = Structfirst(&savet, tl); t != nil; t = structnext(&savet) {
+ args := (*NodeList)(nil)
+ gen := 0
+ for t := Structfirst(&savet, tl); t != nil; t = structnext(&savet) {
n = nil
if mustname != 0 && (t.Sym == nil || t.Sym.Name == "_") {
// invent a name so that we can refer to it in the trampoline
@@ -2505,23 +2396,6 @@
var genwrapper_linehistdone int = 0
func genwrapper(rcvr *Type, method *Type, newnam *Sym, iface int) {
- var this *Node
- var fn *Node
- var call *Node
- var n *Node
- var t *Node
- var pad *Node
- var dot *Node
- var as *Node
- var l *NodeList
- var args *NodeList
- var in *NodeList
- var out *NodeList
- var tpad *Type
- var methodrcvr *Type
- var isddd int
- var v Val
-
if false && Debug['r'] != 0 {
fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", Tconv(rcvr, 0), Tconv(method, 0), Sconv(newnam, 0))
}
@@ -2538,31 +2412,31 @@
dclcontext = PEXTERN
markdcl()
- this = Nod(ODCLFIELD, newname(Lookup(".this")), typenod(rcvr))
+ this := Nod(ODCLFIELD, newname(Lookup(".this")), typenod(rcvr))
this.Left.Ntype = this.Right
- in = structargs(getinarg(method.Type), 1)
- out = structargs(Getoutarg(method.Type), 0)
+ in := structargs(getinarg(method.Type), 1)
+ out := structargs(Getoutarg(method.Type), 0)
- t = Nod(OTFUNC, nil, nil)
- l = list1(this)
+ t := Nod(OTFUNC, nil, nil)
+ l := list1(this)
if iface != 0 && rcvr.Width < Types[Tptr].Width {
// Building method for interface table and receiver
// is smaller than the single pointer-sized word
// that the interface call will pass in.
// Add a dummy padding argument after the
// receiver to make up the difference.
- tpad = typ(TARRAY)
+ tpad := typ(TARRAY)
tpad.Type = Types[TUINT8]
tpad.Bound = Types[Tptr].Width - rcvr.Width
- pad = Nod(ODCLFIELD, newname(Lookup(".pad")), typenod(tpad))
+ pad := Nod(ODCLFIELD, newname(Lookup(".pad")), typenod(tpad))
l = list(l, pad)
}
t.List = concat(l, in)
t.Rlist = out
- fn = Nod(ODCLFUNC, nil, nil)
+ fn := Nod(ODCLFUNC, nil, nil)
fn.Nname = newname(newnam)
fn.Nname.Defn = fn
fn.Nname.Ntype = t
@@ -2570,27 +2444,28 @@
funchdr(fn)
// arg list
- args = nil
+ args := (*NodeList)(nil)
- isddd = 0
- for l = in; l != nil; l = l.Next {
+ isddd := 0
+ for l := in; l != nil; l = l.Next {
args = list(args, l.N.Left)
isddd = int(l.N.Left.Isddd)
}
- methodrcvr = getthisx(method.Type).Type.Type
+ methodrcvr := getthisx(method.Type).Type.Type
// generate nil pointer check for better error
if Isptr[rcvr.Etype] != 0 && rcvr.Type == methodrcvr {
// generating wrapper from *T to T.
- n = Nod(OIF, nil, nil)
+ n := Nod(OIF, nil, nil)
n.Ntest = Nod(OEQ, this.Left, nodnil())
// these strings are already in the reflect tables,
// so no space cost to use them here.
- l = nil
+ l := (*NodeList)(nil)
+ var v Val
v.Ctype = CTSTR
v.U.Sval = newstrlit(rcvr.Type.Sym.Pkg.Name) // package name
l = list(l, nodlit(v))
@@ -2598,13 +2473,13 @@
l = list(l, nodlit(v))
v.U.Sval = newstrlit(method.Sym.Name)
l = list(l, nodlit(v)) // method name
- call = Nod(OCALL, syslook("panicwrap", 0), nil)
+ call := Nod(OCALL, syslook("panicwrap", 0), nil)
call.List = l
n.Nbody = list1(call)
fn.Nbody = list(fn.Nbody, n)
}
- dot = adddot(Nod(OXDOT, this.Left, newname(method.Sym)))
+ dot := adddot(Nod(OXDOT, this.Left, newname(method.Sym)))
// generate call
if flag_race == 0 && Isptr[rcvr.Etype] != 0 && Isptr[methodrcvr.Etype] != 0 && method.Embedded != 0 && !isifacemethod(method.Type) {
@@ -2613,19 +2488,19 @@
if Isptr[dotlist[0].field.Type.Etype] == 0 {
dot = Nod(OADDR, dot, nil)
}
- as = Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil))
+ as := Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil))
as.Right.Type = rcvr
fn.Nbody = list(fn.Nbody, as)
- n = Nod(ORETJMP, nil, nil)
+ n := Nod(ORETJMP, nil, nil)
n.Left = newname(methodsym(method.Sym, methodrcvr, 0))
fn.Nbody = list(fn.Nbody, n)
} else {
fn.Wrapper = 1 // ignore frame for panic+recover matching
- call = Nod(OCALL, dot, nil)
+ call := Nod(OCALL, dot, nil)
call.List = args
call.Isddd = uint8(isddd)
if method.Type.Outtuple > 0 {
- n = Nod(ORETURN, nil, nil)
+ n := Nod(ORETURN, nil, nil)
n.List = list1(call)
call = n
}
@@ -2662,15 +2537,11 @@
}
func hashmem(t *Type) *Node {
- var tfn *Node
- var n *Node
- var sym *Sym
+ sym := Pkglookup("memhash", Runtimepkg)
- sym = Pkglookup("memhash", Runtimepkg)
-
- n = newname(sym)
+ n := newname(sym)
n.Class = PFUNC
- tfn = Nod(OTFUNC, nil, nil)
+ tfn := Nod(OTFUNC, nil, nil)
tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
@@ -2681,12 +2552,9 @@
}
func hashfor(t *Type) *Node {
- var a int
var sym *Sym
- var tfn *Node
- var n *Node
- a = algtype1(t, nil)
+ a := algtype1(t, nil)
switch a {
case AMEM:
Fatal("hashfor with AMEM type")
@@ -2716,9 +2584,9 @@
sym = typesymprefix(".hash", t)
}
- n = newname(sym)
+ n := newname(sym)
n.Class = PFUNC
- tfn = Nod(OTFUNC, nil, nil)
+ tfn := Nod(OTFUNC, nil, nil)
tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn.Rlist = list(tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
@@ -2731,24 +2599,6 @@
* Generate a helper function to compute the hash of a value of type t.
*/
func genhash(sym *Sym, t *Type) {
- var n *Node
- var fn *Node
- var np *Node
- var nh *Node
- var ni *Node
- var call *Node
- var nx *Node
- var na *Node
- var tfn *Node
- var r *Node
- var hashel *Node
- var first *Type
- var t1 *Type
- var old_safemode int
- var size int64
- var mul int64
- var offend int64
-
if Debug['r'] != 0 {
fmt.Printf("genhash %v %v\n", Sconv(sym, 0), Tconv(t, 0))
}
@@ -2758,19 +2608,19 @@
markdcl()
// func sym(p *T, h uintptr) uintptr
- fn = Nod(ODCLFUNC, nil, nil)
+ fn := Nod(ODCLFUNC, nil, nil)
fn.Nname = newname(sym)
fn.Nname.Class = PFUNC
- tfn = Nod(OTFUNC, nil, nil)
+ tfn := Nod(OTFUNC, nil, nil)
fn.Nname.Ntype = tfn
- n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
+ n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
tfn.List = list(tfn.List, n)
- np = n.Left
+ np := n.Left
n = Nod(ODCLFIELD, newname(Lookup("h")), typenod(Types[TUINTPTR]))
tfn.List = list(tfn.List, n)
- nh = n.Left
+ nh := n.Left
n = Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value
tfn.Rlist = list(tfn.Rlist, n)
@@ -2792,10 +2642,10 @@
// An array of pure memory would be handled by the
// standard algorithm, so the element type must not be
// pure memory.
- hashel = hashfor(t.Type)
+ hashel := hashfor(t.Type)
- n = Nod(ORANGE, nil, Nod(OIND, np, nil))
- ni = newname(Lookup("i"))
+ n := Nod(ORANGE, nil, Nod(OIND, np, nil))
+ ni := newname(Lookup("i"))
ni.Type = Types[TINT]
n.List = list1(ni)
n.Colas = 1
@@ -2809,6 +2659,7 @@
// h *= mul
// Same multipliers as in runtime.memhash.
+ var mul int64
if Widthptr == 4 {
mul = 3267000013
} else {
@@ -2817,11 +2668,11 @@
n.Nbody = list(n.Nbody, Nod(OAS, nh, Nod(OMUL, nh, Nodintconst(mul))))
// h = hashel(&p[i], h)
- call = Nod(OCALL, hashel, nil)
+ call := Nod(OCALL, hashel, nil)
- nx = Nod(OINDEX, np, ni)
+ nx := Nod(OINDEX, np, ni)
nx.Bounded = true
- na = Nod(OADDR, nx, nil)
+ na := Nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
call.List = list(call.List, na)
call.List = list(call.List, nh)
@@ -2832,10 +2683,15 @@
// Walk the struct using memhash for runs of AMEM
// and calling specific hash functions for the others.
case TSTRUCT:
- first = nil
+ first := (*Type)(nil)
- offend = 0
- for t1 = t.Type; ; t1 = t1.Down {
+ offend := int64(0)
+ var size int64
+ var call *Node
+ var nx *Node
+ var na *Node
+ var hashel *Node
+ for t1 := t.Type; ; t1 = t1.Down {
if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) {
offend = t1.Width + t1.Type.Width
if first == nil {
@@ -2906,7 +2762,7 @@
}
}
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, nh)
fn.Nbody = list(fn.Nbody, r)
@@ -2926,7 +2782,7 @@
// In this case it can happen if we need to generate an ==
// for a struct containing a reflect.Value, which itself has
// an unexported field of type unsafe.Pointer.
- old_safemode = safemode
+ old_safemode := safemode
safemode = 0
funccompile(fn)
@@ -2936,23 +2792,17 @@
// Return node for
// if p.field != q.field { return false }
func eqfield(p *Node, q *Node, field *Node) *Node {
- var nif *Node
- var nx *Node
- var ny *Node
- var r *Node
-
- nx = Nod(OXDOT, p, field)
- ny = Nod(OXDOT, q, field)
- nif = Nod(OIF, nil, nil)
+ nx := Nod(OXDOT, p, field)
+ ny := Nod(OXDOT, q, field)
+ nif := Nod(OIF, nil, nil)
nif.Ntest = Nod(ONE, nx, ny)
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, Nodbool(false))
nif.Nbody = list(nif.Nbody, r)
return nif
}
func eqmemfunc(size int64, type_ *Type, needsize *int) *Node {
- var buf string
var fn *Node
switch size {
@@ -2965,7 +2815,7 @@
4,
8,
16:
- buf = fmt.Sprintf("memequal%d", int(size)*8)
+ buf := fmt.Sprintf("memequal%d", int(size)*8)
fn = syslook(buf, 1)
*needsize = 0
}
@@ -2978,31 +2828,26 @@
// Return node for
// if !memequal(&p.field, &q.field [, size]) { return false }
func eqmem(p *Node, q *Node, field *Node, size int64) *Node {
- var nif *Node
- var nx *Node
- var ny *Node
- var call *Node
- var r *Node
var needsize int
- nx = Nod(OADDR, Nod(OXDOT, p, field), nil)
+ nx := Nod(OADDR, Nod(OXDOT, p, field), nil)
nx.Etype = 1 // does not escape
- ny = Nod(OADDR, Nod(OXDOT, q, field), nil)
+ ny := Nod(OADDR, Nod(OXDOT, q, field), nil)
ny.Etype = 1 // does not escape
typecheck(&nx, Erv)
typecheck(&ny, Erv)
- call = Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil)
+ call := Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil)
call.List = list(call.List, nx)
call.List = list(call.List, ny)
if needsize != 0 {
call.List = list(call.List, Nodintconst(size))
}
- nif = Nod(OIF, nil, nil)
+ nif := Nod(OIF, nil, nil)
nif.Ninit = list(nif.Ninit, call)
nif.Ntest = Nod(ONOT, call, nil)
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, Nodbool(false))
nif.Nbody = list(nif.Nbody, r)
return nif
@@ -3012,23 +2857,6 @@
* Generate a helper function to check equality of two values of type t.
*/
func geneq(sym *Sym, t *Type) {
- var n *Node
- var fn *Node
- var np *Node
- var nq *Node
- var tfn *Node
- var nif *Node
- var ni *Node
- var nx *Node
- var ny *Node
- var nrange *Node
- var r *Node
- var t1 *Type
- var first *Type
- var old_safemode int
- var size int64
- var offend int64
-
if Debug['r'] != 0 {
fmt.Printf("geneq %v %v\n", Sconv(sym, 0), Tconv(t, 0))
}
@@ -3038,19 +2866,19 @@
markdcl()
// func sym(p, q *T) bool
- fn = Nod(ODCLFUNC, nil, nil)
+ fn := Nod(ODCLFUNC, nil, nil)
fn.Nname = newname(sym)
fn.Nname.Class = PFUNC
- tfn = Nod(OTFUNC, nil, nil)
+ tfn := Nod(OTFUNC, nil, nil)
fn.Nname.Ntype = tfn
- n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
+ n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
tfn.List = list(tfn.List, n)
- np = n.Left
+ np := n.Left
n = Nod(ODCLFIELD, newname(Lookup("q")), typenod(Ptrto(t)))
tfn.List = list(tfn.List, n)
- nq = n.Left
+ nq := n.Left
n = Nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
tfn.Rlist = list(tfn.Rlist, n)
@@ -3073,9 +2901,9 @@
// pure memory. Even if we unrolled the range loop,
// each iteration would be a function call, so don't bother
// unrolling.
- nrange = Nod(ORANGE, nil, Nod(OIND, np, nil))
+ nrange := Nod(ORANGE, nil, Nod(OIND, np, nil))
- ni = newname(Lookup("i"))
+ ni := newname(Lookup("i"))
ni.Type = Types[TINT]
nrange.List = list1(ni)
nrange.Colas = 1
@@ -3083,15 +2911,15 @@
ni = nrange.List.N
// if p[i] != q[i] { return false }
- nx = Nod(OINDEX, np, ni)
+ nx := Nod(OINDEX, np, ni)
nx.Bounded = true
- ny = Nod(OINDEX, nq, ni)
+ ny := Nod(OINDEX, nq, ni)
ny.Bounded = true
- nif = Nod(OIF, nil, nil)
+ nif := Nod(OIF, nil, nil)
nif.Ntest = Nod(ONE, nx, ny)
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, Nodbool(false))
nif.Nbody = list(nif.Nbody, r)
nrange.Nbody = list(nrange.Nbody, nif)
@@ -3101,10 +2929,11 @@
// and calling specific equality tests for the others.
// Skip blank-named fields.
case TSTRUCT:
- first = nil
+ first := (*Type)(nil)
- offend = 0
- for t1 = t.Type; ; t1 = t1.Down {
+ offend := int64(0)
+ var size int64
+ for t1 := t.Type; ; t1 = t1.Down {
if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) {
offend = t1.Width + t1.Type.Width
if first == nil {
@@ -3153,7 +2982,7 @@
}
// return true
- r = Nod(ORETURN, nil, nil)
+ r := Nod(ORETURN, nil, nil)
r.List = list(r.List, Nodbool(true))
fn.Nbody = list(fn.Nbody, r)
@@ -3174,7 +3003,7 @@
// In this case it can happen if we need to generate an ==
// for a struct containing a reflect.Value, which itself has
// an unexported field of type unsafe.Pointer.
- old_safemode = safemode
+ old_safemode := safemode
safemode = 0
funccompile(fn)
@@ -3182,18 +3011,16 @@
}
func ifacelookdot(s *Sym, t *Type, followptr *int, ignorecase int) *Type {
- var i int
- var c int
- var d int
- var m *Type
-
*followptr = 0
if t == nil {
return nil
}
- for d = 0; d < len(dotlist); d++ {
+ var m *Type
+ var i int
+ var c int
+ for d := 0; d < len(dotlist); d++ {
c = adddot1(s, t, d, &m, ignorecase)
if c > 1 {
Yyerror("%v.%v is ambiguous", Tconv(t, 0), Sconv(s, 0))
@@ -3221,14 +3048,7 @@
}
func implements(t *Type, iface *Type, m **Type, samename **Type, ptr *int) bool {
- var t0 *Type
- var im *Type
- var tm *Type
- var rcvr *Type
- var imtype *Type
- var followptr int
-
- t0 = t
+ t0 := t
if t == nil {
return false
}
@@ -3238,7 +3058,8 @@
// and then do one loop.
if t.Etype == TINTER {
- for im = iface.Type; im != nil; im = im.Down {
+ var tm *Type
+ for im := iface.Type; im != nil; im = im.Down {
for tm = t.Type; tm != nil; tm = tm.Down {
if tm.Sym == im.Sym {
if Eqtype(tm.Type, im.Type) {
@@ -3265,7 +3086,11 @@
if t != nil {
expandmeth(t)
}
- for im = iface.Type; im != nil; im = im.Down {
+ var tm *Type
+ var imtype *Type
+ var followptr int
+ var rcvr *Type
+ for im := iface.Type; im != nil; im = im.Down {
imtype = methodfunc(im.Type, nil)
tm = ifacelookdot(im.Sym, t, &followptr, 0)
if tm == nil || tm.Nointerface || !Eqtype(methodfunc(tm.Type, nil), imtype) {
@@ -3303,13 +3128,11 @@
* all the invalid conversions (like ptr -> bool)
*/
func Simsimtype(t *Type) int {
- var et int
-
if t == nil {
return 0
}
- et = int(Simtype[t.Etype])
+ et := int(Simtype[t.Etype])
switch et {
case TPTR32:
et = TUINT32
@@ -3339,21 +3162,19 @@
}
func list1(n *Node) *NodeList {
- var l *NodeList
-
if n == nil {
return nil
}
if n.Op == OBLOCK && n.Ninit == nil {
// Flatten list and steal storage.
// Poison pointer to catch errant uses.
- l = n.List
+ l := n.List
n.List = nil
return l
}
- l = new(NodeList)
+ l := new(NodeList)
l.N = n
l.End = l
return l
@@ -3364,16 +3185,12 @@
}
func listsort(l **NodeList, f func(*Node, *Node) int) {
- var l1 *NodeList
- var l2 *NodeList
- var le *NodeList
-
if *l == nil || (*l).Next == nil {
return
}
- l1 = *l
- l2 = *l
+ l1 := *l
+ l2 := *l
for {
l2 = l2.Next
if l2 == nil {
@@ -3405,6 +3222,7 @@
// now l1 == *l; and l1 < l2
+ var le *NodeList
for (l1 != nil) && (l2 != nil) {
for (l1.Next != nil) && f(l1.Next.N, l2.N) < 0 {
l1 = l1.Next
@@ -3427,9 +3245,7 @@
}
func listtreecopy(l *NodeList) *NodeList {
- var out *NodeList
-
- out = nil
+ out := (*NodeList)(nil)
for ; l != nil; l = l.Next {
out = list(out, treecopy(l.N))
}
@@ -3437,9 +3253,7 @@
}
func liststmt(l *NodeList) *Node {
- var n *Node
-
- n = Nod(OBLOCK, nil, nil)
+ n := Nod(OBLOCK, nil, nil)
n.List = l
if l != nil {
n.Lineno = l.N.Lineno
@@ -3451,9 +3265,7 @@
* return nelem of list
*/
func count(l *NodeList) int {
- var n int64
-
- n = 0
+ n := int64(0)
for ; l != nil; l = l.Next {
n++
}
@@ -3468,10 +3280,9 @@
* return nelem of list
*/
func structcount(t *Type) int {
- var v int
var s Iter
- v = 0
+ v := 0
for t = Structfirst(&s, &t); t != nil; t = structnext(&s) {
v++
}
@@ -3486,7 +3297,6 @@
func powtwo(n *Node) int {
var v uint64
var b uint64
- var i int
if n == nil || n.Op != OLITERAL || n.Type == nil {
goto no
@@ -3497,7 +3307,7 @@
v = uint64(Mpgetfix(n.Val.U.Xval))
b = 1
- for i = 0; i < 64; i++ {
+ for i := 0; i < 64; i++ {
if b == v {
return i
}
@@ -3510,7 +3320,7 @@
v = -v
b = 1
- for i = 0; i < 64; i++ {
+ for i := 0; i < 64; i++ {
if b == v {
return i + 1000
}
@@ -3559,17 +3369,7 @@
* see hacker's delight chapter 10
*/
func Smagic(m *Magic) {
- var p int
- var ad uint64
- var anc uint64
- var delta uint64
- var q1 uint64
- var r1 uint64
- var q2 uint64
- var r2 uint64
- var t uint64
var mask uint64
- var two31 uint64
m.Bad = 0
switch m.W {
@@ -3590,10 +3390,10 @@
mask = 0xffffffffffffffff
}
- two31 = mask ^ (mask >> 1)
+ two31 := mask ^ (mask >> 1)
- p = m.W - 1
- ad = uint64(m.Sd)
+ p := m.W - 1
+ ad := uint64(m.Sd)
if m.Sd < 0 {
ad = -uint64(m.Sd)
}
@@ -3604,22 +3404,23 @@
return
}
- t = two31
+ t := two31
ad &= mask
- anc = t - 1 - t%ad
+ anc := t - 1 - t%ad
anc &= mask
- q1 = two31 / anc
- r1 = two31 - q1*anc
+ q1 := two31 / anc
+ r1 := two31 - q1*anc
q1 &= mask
r1 &= mask
- q2 = two31 / ad
- r2 = two31 - q2*ad
+ q2 := two31 / ad
+ r2 := two31 - q2*ad
q2 &= mask
r2 &= mask
+ var delta uint64
for {
p++
q1 <<= 1
@@ -3665,15 +3466,7 @@
* see hacker's delight chapter 10
*/
func Umagic(m *Magic) {
- var p int
- var nc uint64
- var delta uint64
- var q1 uint64
- var r1 uint64
- var q2 uint64
- var r2 uint64
var mask uint64
- var two31 uint64
m.Bad = 0
m.Ua = 0
@@ -3696,7 +3489,7 @@
mask = 0xffffffffffffffff
}
- two31 = mask ^ (mask >> 1)
+ two31 := mask ^ (mask >> 1)
m.Ud &= mask
if m.Ud == 0 || m.Ud == two31 {
@@ -3704,19 +3497,20 @@
return
}
- nc = mask - (-m.Ud&mask)%m.Ud
- p = m.W - 1
+ nc := mask - (-m.Ud&mask)%m.Ud
+ p := m.W - 1
- q1 = two31 / nc
- r1 = two31 - q1*nc
+ q1 := two31 / nc
+ r1 := two31 - q1*nc
q1 &= mask
r1 &= mask
- q2 = (two31 - 1) / m.Ud
- r2 = (two31 - 1) - q2*m.Ud
+ q2 := (two31 - 1) / m.Ud
+ r2 := (two31 - 1) - q2*m.Ud
q2 &= mask
r2 &= mask
+ var delta uint64
for {
p++
if r1 >= nc-r1 {
@@ -3811,17 +3605,14 @@
}
func mkpkg(path_ *Strlit) *Pkg {
- var p *Pkg
- var h int
-
- h = int(stringhash(path_.S) & uint32(len(phash)-1))
- for p = phash[h]; p != nil; p = p.Link {
+ h := int(stringhash(path_.S) & uint32(len(phash)-1))
+ for p := phash[h]; p != nil; p = p.Link {
if p.Path.S == path_.S {
return p
}
}
- p = new(Pkg)
+ p := new(Pkg)
p.Path = path_
p.Prefix = pathtoprefix(path_.S)
p.Link = phash[h]
@@ -3836,13 +3627,11 @@
}
func addinit(np **Node, init *NodeList) {
- var n *Node
-
if init == nil {
return
}
- n = *np
+ n := *np
switch n.Op {
// There may be multiple refs to this node;
// introduce OCONVNOP to hold init list.
@@ -3865,23 +3654,21 @@
}
func isbadimport(path_ *Strlit) bool {
- var i int
- var s string
- var r uint
-
if len(path_.S) != len(path_.S) {
Yyerror("import path contains NUL")
return true
}
- for i = 0; i < len(reservedimports); i++ {
+ for i := 0; i < len(reservedimports); i++ {
if path_.S == reservedimports[i] {
Yyerror("import path \"%s\" is reserved and cannot be used", path_.S)
return true
}
}
+ var s string
_ = s
+ var r uint
_ = r
for _, r := range path_.S {
if r == utf8.RuneError {
@@ -3914,14 +3701,12 @@
}
func checknil(x *Node, init **NodeList) {
- var n *Node
-
if Isinter(x.Type) {
x = Nod(OITAB, x, nil)
typecheck(&x, Erv)
}
- n = Nod(OCHECKNIL, x, nil)
+ n := Nod(OCHECKNIL, x, nil)
n.Typecheck = 1
*init = list(*init, n)
}
