diff --git a/src/cmd/5g/cgen.go b/src/cmd/5g/cgen.go
index 638c5a6..d9d4892 100644
--- a/src/cmd/5g/cgen.go
+++ b/src/cmd/5g/cgen.go
@@ -25,15 +25,8 @@
 		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
+		return
 	}
 
 	if res == nil || res.Type == nil {
@@ -81,7 +74,7 @@
 			gc.Tempname(&n1, n.Type)
 			cgen(n, &n1)
 			cgen(&n1, res)
-			goto ret
+			return
 		}
 	}
 
@@ -90,7 +83,7 @@
 			gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
 		}
 		sgen(n, res, n.Type.Width)
-		goto ret
+		return
 	}
 
 	// update addressability for string, slice
@@ -124,7 +117,7 @@
 			regfree(&n1)
 		}
 
-		goto ret
+		return
 	}
 
 	// if both are not addressable, use a temporary.
@@ -179,16 +172,16 @@
 			}
 
 			sudoclean()
-			goto ret
+			return
 		}
 	}
 
 	// otherwise, the result is addressable but n is not.
 	// let's do some computation.
 
-	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 {
@@ -198,7 +191,7 @@
 			n2 := *n
 			n2.Left = &n1
 			cgen(&n2, res)
-			goto ret
+			return
 		}
 	}
 
@@ -223,8 +216,34 @@
 		}
 	}
 
+	var a int
+	var f0 gc.Node
+	var n1 gc.Node
+	var n2 gc.Node
 	if nl != nil && gc.Isfloat[n.Type.Etype] != 0 && gc.Isfloat[nl.Type.Etype] != 0 {
-		goto flt
+		// floating-point.
+		regalloc(&f0, nl.Type, res)
+
+		if nr != nil {
+			goto flt2
+		}
+
+		if n.Op == gc.OMINUS {
+			nr = gc.Nodintconst(-1)
+			gc.Convlit(&nr, n.Type)
+			n.Op = gc.OMUL
+			goto flt2
+		}
+
+		// unary
+		cgen(nl, &f0)
+
+		if n.Op != gc.OCONV && n.Op != gc.OPLUS {
+			gins(optoas(int(n.Op), n.Type), &f0, &f0)
+		}
+		gmove(&f0, res)
+		regfree(&f0)
+		return
 	}
 	switch n.Op {
 	default:
@@ -255,11 +274,11 @@
 		bgen(n, true, 0, p2)
 		gmove(gc.Nodbool(false), res)
 		gc.Patch(p3, gc.Pc)
-		goto ret
+		return
 
 	case gc.OPLUS:
 		cgen(nl, res)
-		goto ret
+		return
 
 		// unary
 	case gc.OCOM:
@@ -286,7 +305,13 @@
 		gc.OMUL:
 		a = optoas(int(n.Op), nl.Type)
 
-		goto sbop
+		// symmetric binary
+		if nl.Ullman < nr.Ullman {
+			r := nl
+			nl = nr
+			nr = r
+		}
+		goto abop
 
 		// asymmetric binary
 	case gc.OSUB:
@@ -489,14 +514,7 @@
 		goto abop
 	}
 
-	goto ret
-
-sbop: // symmetric binary
-	if nl.Ullman < nr.Ullman {
-		r := nl
-		nl = nr
-		nr = r
-	}
+	return
 
 	// TODO(kaib): use fewer registers here.
 abop: // asymmetric binary
@@ -561,33 +579,10 @@
 	if n2.Op != gc.OLITERAL {
 		regfree(&n2)
 	}
-	goto ret
-
-flt: // floating-point.
-	regalloc(&f0, nl.Type, res)
-
-	if nr != nil {
-		goto flt2
-	}
-
-	if n.Op == gc.OMINUS {
-		nr = gc.Nodintconst(-1)
-		gc.Convlit(&nr, n.Type)
-		n.Op = gc.OMUL
-		goto flt2
-	}
-
-	// unary
-	cgen(nl, &f0)
-
-	if n.Op != gc.OCONV && n.Op != gc.OPLUS {
-		gins(optoas(int(n.Op), n.Type), &f0, &f0)
-	}
-	gmove(&f0, res)
-	regfree(&f0)
-	goto ret
+	return
 
 flt2: // binary
+	var f1 gc.Node
 	if nl.Ullman >= nr.Ullman {
 		cgen(nl, &f0)
 		regalloc(&f1, n.Type, nil)
@@ -604,9 +599,7 @@
 	gmove(&f1, res)
 	regfree(&f0)
 	regfree(&f1)
-	goto ret
-
-ret:
+	return
 }
 
 /*
@@ -666,7 +659,6 @@
 		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.
@@ -682,7 +674,7 @@
 		gins(arm.AMOVW, &n1, &n2)
 		gmove(&n2, res)
 		regfree(&n2)
-		goto ret
+		return
 	}
 
 	if n.Addable != 0 {
@@ -694,10 +686,10 @@
 		gins(arm.AMOVW, &n1, &n2)
 		gmove(&n2, res)
 		regfree(&n2)
-		goto ret
+		return
 	}
 
-	nl = n.Left
+	nl := n.Left
 
 	switch n.Op {
 	default:
@@ -820,8 +812,6 @@
 			regfree(&n3)
 		}
 	}
-
-ret:
 }
 
 /*
@@ -1195,25 +1185,23 @@
 		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 {
-			goto ret
+			return
 		}
 	}
 
-	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)
-		goto ret
+		return
 	}
 
-	nr = nil
+	nr := (*gc.Node)(nil)
 
+	var nl *gc.Node
 	switch n.Op {
 	default:
 		a := gc.ONE
@@ -1221,14 +1209,14 @@
 			a = gc.OEQ
 		}
 		gencmp0(n, n.Type, a, likely, to)
-		goto ret
+		return
 
 		// need to ask if it is bool?
 	case gc.OLITERAL:
 		if !true_ == (n.Val.U.Bval == 0) {
 			gc.Patch(gc.Gbranch(arm.AB, nil, 0), to)
 		}
-		goto ret
+		return
 
 	case gc.OANDAND,
 		gc.OOROR:
@@ -1246,7 +1234,7 @@
 			bgen(n.Right, true_, likely, to)
 		}
 
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1256,7 +1244,7 @@
 		gc.OGE:
 		nr = n.Right
 		if nr == nil || nr.Type == nil {
-			goto ret
+			return
 		}
 		fallthrough
 
@@ -1264,14 +1252,14 @@
 		nl = n.Left
 
 		if nl == nil || nl.Type == nil {
-			goto ret
+			return
 		}
 	}
 
 	switch n.Op {
 	case gc.ONOT:
 		bgen(nl, !true_, likely, to)
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1293,7 +1281,7 @@
 				n.Ninit = ll
 				gc.Patch(gc.Gbranch(arm.AB, nil, 0), to)
 				gc.Patch(p2, gc.Pc)
-				goto ret
+				return
 			}
 
 			a = gc.Brcom(a)
@@ -1438,9 +1426,7 @@
 		regfree(&n2)
 	}
 
-	goto ret
-
-ret:
+	return
 }
 
 /*
diff --git a/src/cmd/5g/ggen.go b/src/cmd/5g/ggen.go
index 8b7010f..2879805 100644
--- a/src/cmd/5g/ggen.go
+++ b/src/cmd/5g/ggen.go
@@ -329,7 +329,7 @@
 		nod.Type = t
 		ginscall(&nod, proc)
 		regfree(&nod)
-		goto ret
+		return
 	}
 
 	// call pointer
@@ -340,15 +340,13 @@
 		nod.Type = t
 		ginscall(&nod, proc)
 		regfree(&nod)
-		goto ret
+		return
 	}
 
 	// call direct
 	n.Left.Method = 1
 
 	ginscall(n.Left, proc)
-
-ret:
 }
 
 /*
diff --git a/src/cmd/5g/gsubr.go b/src/cmd/5g/gsubr.go
index ce0d5e8..424e164 100644
--- a/src/cmd/5g/gsubr.go
+++ b/src/cmd/5g/gsubr.go
@@ -331,10 +331,8 @@
 
 	// 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
 	}
@@ -387,7 +385,9 @@
 
 	switch uint32(ft)<<16 | uint32(tt) {
 	default:
-		goto fatal
+		// should not happen
+		gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
+		return
 
 		/*
 		 * integer copy and truncate
@@ -784,6 +784,8 @@
 
 	// truncate 64 bit integer
 trunc64:
+	var fhi gc.Node
+	var flo gc.Node
 	split64(f, &flo, &fhi)
 
 	regalloc(&r1, t.Type, nil)
@@ -792,10 +794,6 @@
 	regfree(&r1)
 	splitclean()
 	return
-
-	// should not happen
-fatal:
-	gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
 }
 
 func samaddr(f *gc.Node, t *gc.Node) bool {
@@ -1273,12 +1271,6 @@
 
 	*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) {
@@ -1288,98 +1280,88 @@
 		if v >= 32000 || v <= -32000 {
 			break
 		}
-		goto lit
+		switch as {
+		default:
+			return false
+
+		case arm.AADD,
+			arm.ASUB,
+			arm.AAND,
+			arm.AORR,
+			arm.AEOR,
+			arm.AMOVB,
+			arm.AMOVBS,
+			arm.AMOVBU,
+			arm.AMOVH,
+			arm.AMOVHS,
+			arm.AMOVHU,
+			arm.AMOVW:
+			break
+		}
+
+		cleani += 2
+		reg := &clean[cleani-1]
+		reg1 := &clean[cleani-2]
+		reg.Op = gc.OEMPTY
+		reg1.Op = gc.OEMPTY
+		gc.Naddr(n, a, 1)
+		return true
 
 	case gc.ODOT,
 		gc.ODOTPTR:
 		cleani += 2
-		reg = &clean[cleani-1]
+		reg := &clean[cleani-1]
 		reg1 := &clean[cleani-2]
 		reg.Op = gc.OEMPTY
 		reg1.Op = gc.OEMPTY
-		goto odot
+		var nn *gc.Node
+		var oary [10]int64
+		o := gc.Dotoffset(n, oary[:], &nn)
+		if nn == nil {
+			sudoclean()
+			return false
+		}
+
+		if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+			// directly addressable set of DOTs
+			n1 := *nn
+
+			n1.Type = n.Type
+			n1.Xoffset += oary[0]
+			gc.Naddr(&n1, a, 1)
+			return true
+		}
+
+		regalloc(reg, gc.Types[gc.Tptr], nil)
+		n1 := *reg
+		n1.Op = gc.OINDREG
+		if oary[0] >= 0 {
+			agen(nn, reg)
+			n1.Xoffset = oary[0]
+		} else {
+			cgen(nn, reg)
+			gc.Cgen_checknil(reg)
+			n1.Xoffset = -(oary[0] + 1)
+		}
+
+		for i := 1; i < o; i++ {
+			if oary[i] >= 0 {
+				gc.Fatal("can't happen")
+			}
+			gins(arm.AMOVW, &n1, reg)
+			gc.Cgen_checknil(reg)
+			n1.Xoffset = -(oary[i] + 1)
+		}
+
+		a.Type = obj.TYPE_NONE
+		a.Name = obj.NAME_NONE
+		n1.Type = n.Type
+		gc.Naddr(&n1, a, 1)
+		return true
 
 	case gc.OINDEX:
 		return false
 	}
 
 	return false
-
-lit:
-	switch as {
-	default:
-		return false
-
-	case arm.AADD,
-		arm.ASUB,
-		arm.AAND,
-		arm.AORR,
-		arm.AEOR,
-		arm.AMOVB,
-		arm.AMOVBS,
-		arm.AMOVBU,
-		arm.AMOVH,
-		arm.AMOVHS,
-		arm.AMOVHU,
-		arm.AMOVW:
-		break
-	}
-
-	cleani += 2
-	reg = &clean[cleani-1]
-	reg1 = &clean[cleani-2]
-	reg.Op = gc.OEMPTY
-	reg1.Op = gc.OEMPTY
-	gc.Naddr(n, a, 1)
-	goto yes
-
-odot:
-	o = gc.Dotoffset(n, oary[:], &nn)
-	if nn == nil {
-		goto no
-	}
-
-	if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
-		// directly addressable set of DOTs
-		n1 := *nn
-
-		n1.Type = n.Type
-		n1.Xoffset += oary[0]
-		gc.Naddr(&n1, a, 1)
-		goto yes
-	}
-
-	regalloc(reg, gc.Types[gc.Tptr], nil)
-	n1 = *reg
-	n1.Op = gc.OINDREG
-	if oary[0] >= 0 {
-		agen(nn, reg)
-		n1.Xoffset = oary[0]
-	} else {
-		cgen(nn, reg)
-		gc.Cgen_checknil(reg)
-		n1.Xoffset = -(oary[0] + 1)
-	}
-
-	for i := 1; i < o; i++ {
-		if oary[i] >= 0 {
-			gc.Fatal("can't happen")
-		}
-		gins(arm.AMOVW, &n1, reg)
-		gc.Cgen_checknil(reg)
-		n1.Xoffset = -(oary[i] + 1)
-	}
-
-	a.Type = obj.TYPE_NONE
-	a.Name = obj.NAME_NONE
-	n1.Type = n.Type
-	gc.Naddr(&n1, a, 1)
-	goto yes
-
-yes:
-	return true
-
-no:
-	sudoclean()
-	return false
 }
diff --git a/src/cmd/5g/peep.go b/src/cmd/5g/peep.go
index e28ec02..280cfb7 100644
--- a/src/cmd/5g/peep.go
+++ b/src/cmd/5g/peep.go
@@ -257,9 +257,8 @@
 	if !regtyp(v2) {
 		return false
 	}
-	var r *gc.Flow
 	var info gc.ProgInfo
-	for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+	for r := gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
 		if gc.Uniqs(r) == nil {
 			break
 		}
@@ -289,7 +288,32 @@
 			if p.To.Type == v1.Type {
 				if p.To.Reg == v1.Reg {
 					if p.Scond == arm.C_SCOND_NONE {
-						goto gotit
+						copysub(&p.To, v1, v2, 1)
+						if gc.Debug['P'] != 0 {
+							fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+							if p.From.Type == v2.Type {
+								fmt.Printf(" excise")
+							}
+							fmt.Printf("\n")
+						}
+
+						for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+							p = r.Prog
+							copysub(&p.From, v1, v2, 1)
+							copysub1(p, v1, v2, 1)
+							copysub(&p.To, v1, v2, 1)
+							if gc.Debug['P'] != 0 {
+								fmt.Printf("%v\n", r.Prog)
+							}
+						}
+
+						t := int(int(v1.Reg))
+						v1.Reg = v2.Reg
+						v2.Reg = int16(t)
+						if gc.Debug['P'] != 0 {
+							fmt.Printf("%v last\n", r.Prog)
+						}
+						return true
 					}
 				}
 			}
@@ -304,34 +328,6 @@
 	}
 
 	return false
-
-gotit:
-	copysub(&p.To, v1, v2, 1)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
-		if p.From.Type == v2.Type {
-			fmt.Printf(" excise")
-		}
-		fmt.Printf("\n")
-	}
-
-	for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
-		p = r.Prog
-		copysub(&p.From, v1, v2, 1)
-		copysub1(p, v1, v2, 1)
-		copysub(&p.To, v1, v2, 1)
-		if gc.Debug['P'] != 0 {
-			fmt.Printf("%v\n", r.Prog)
-		}
-	}
-
-	t := int(int(v1.Reg))
-	v1.Reg = v2.Reg
-	v2.Reg = int16(t)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("%v last\n", r.Prog)
-	}
-	return true
 }
 
 /*
diff --git a/src/cmd/5l/asm.go b/src/cmd/5l/asm.go
index 909f682..0cebb6b 100644
--- a/src/cmd/5l/asm.go
+++ b/src/cmd/5l/asm.go
@@ -38,17 +38,14 @@
 import "cmd/internal/ld"
 
 func needlib(name string) int {
-	var p string
-	var s *ld.LSym
-
 	if name[0] == '\x00' {
 		return 0
 	}
 
 	/* reuse hash code in symbol table */
-	p = fmt.Sprintf(".dynlib.%s", name)
+	p := fmt.Sprintf(".dynlib.%s", name)
 
-	s = ld.Linklookup(ld.Ctxt, p, 0)
+	s := ld.Linklookup(ld.Ctxt, p, 0)
 
 	if s.Type == 0 {
 		s.Type = 100 // avoid SDATA, etc.
@@ -73,10 +70,7 @@
 }
 
 func adddynrel(s *ld.LSym, r *ld.Reloc) {
-	var targ *ld.LSym
-	var rel *ld.LSym
-
-	targ = r.Sym
+	targ := r.Sym
 	ld.Ctxt.Cursym = s
 
 	switch r.Type {
@@ -203,7 +197,7 @@
 		}
 		if ld.Iself {
 			adddynsym(ld.Ctxt, targ)
-			rel = ld.Linklookup(ld.Ctxt, ".rel", 0)
+			rel := ld.Linklookup(ld.Ctxt, ".rel", 0)
 			ld.Addaddrplus(ld.Ctxt, rel, s, int64(r.Off))
 			ld.Adduint32(ld.Ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_ARM_GLOB_DAT)) // we need a nil + A dynmic reloc
 			r.Type = ld.R_CONST                                                                // write r->add during relocsym
@@ -217,11 +211,9 @@
 }
 
 func elfreloc1(r *ld.Reloc, sectoff int64) int {
-	var elfsym int32
-
 	ld.Thearch.Lput(uint32(sectoff))
 
-	elfsym = r.Xsym.Elfsym
+	elfsym := r.Xsym.Elfsym
 	switch r.Type {
 	default:
 		return -1
@@ -267,11 +259,8 @@
 }
 
 func elfsetupplt() {
-	var plt *ld.LSym
-	var got *ld.LSym
-
-	plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
-	got = ld.Linklookup(ld.Ctxt, ".got.plt", 0)
+	plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
+	got := ld.Linklookup(ld.Ctxt, ".got.plt", 0)
 	if plt.Size == 0 {
 		// str lr, [sp, #-4]!
 		ld.Adduint32(ld.Ctxt, plt, 0xe52de004)
@@ -298,9 +287,8 @@
 
 func machoreloc1(r *ld.Reloc, sectoff int64) int {
 	var v uint32
-	var rs *ld.LSym
 
-	rs = r.Xsym
+	rs := r.Xsym
 
 	if rs.Type == ld.SHOSTOBJ || r.Type == ld.R_CALLARM {
 		if rs.Dynid < 0 {
@@ -353,15 +341,13 @@
 }
 
 func archreloc(r *ld.Reloc, s *ld.LSym, val *int64) int {
-	var rs *ld.LSym
-
 	if ld.Linkmode == ld.LinkExternal {
 		switch r.Type {
 		case ld.R_CALLARM:
 			r.Done = 0
 
 			// set up addend for eventual relocation via outer symbol.
-			rs = r.Sym
+			rs := r.Sym
 
 			r.Xadd = r.Add
 			if r.Xadd&0x800000 != 0 {
@@ -437,9 +423,7 @@
 }
 
 func addpltreloc(ctxt *ld.Link, plt *ld.LSym, got *ld.LSym, sym *ld.LSym, typ int) *ld.Reloc {
-	var r *ld.Reloc
-
-	r = ld.Addrel(plt)
+	r := ld.Addrel(plt)
 	r.Sym = got
 	r.Off = int32(plt.Size)
 	r.Siz = 4
@@ -454,10 +438,6 @@
 }
 
 func addpltsym(ctxt *ld.Link, s *ld.LSym) {
-	var plt *ld.LSym
-	var got *ld.LSym
-	var rel *ld.LSym
-
 	if s.Plt >= 0 {
 		return
 	}
@@ -465,9 +445,9 @@
 	adddynsym(ctxt, s)
 
 	if ld.Iself {
-		plt = ld.Linklookup(ctxt, ".plt", 0)
-		got = ld.Linklookup(ctxt, ".got.plt", 0)
-		rel = ld.Linklookup(ctxt, ".rel.plt", 0)
+		plt := ld.Linklookup(ctxt, ".plt", 0)
+		got := ld.Linklookup(ctxt, ".got.plt", 0)
+		rel := ld.Linklookup(ctxt, ".rel.plt", 0)
 		if plt.Size == 0 {
 			elfsetupplt()
 		}
@@ -497,13 +477,11 @@
 }
 
 func addgotsyminternal(ctxt *ld.Link, s *ld.LSym) {
-	var got *ld.LSym
-
 	if s.Got >= 0 {
 		return
 	}
 
-	got = ld.Linklookup(ctxt, ".got", 0)
+	got := ld.Linklookup(ctxt, ".got", 0)
 	s.Got = int32(got.Size)
 
 	ld.Addaddrplus(ctxt, got, s, 0)
@@ -515,20 +493,17 @@
 }
 
 func addgotsym(ctxt *ld.Link, s *ld.LSym) {
-	var got *ld.LSym
-	var rel *ld.LSym
-
 	if s.Got >= 0 {
 		return
 	}
 
 	adddynsym(ctxt, s)
-	got = ld.Linklookup(ctxt, ".got", 0)
+	got := ld.Linklookup(ctxt, ".got", 0)
 	s.Got = int32(got.Size)
 	ld.Adduint32(ctxt, got, 0)
 
 	if ld.Iself {
-		rel = ld.Linklookup(ctxt, ".rel", 0)
+		rel := ld.Linklookup(ctxt, ".rel", 0)
 		ld.Addaddrplus(ctxt, rel, got, int64(s.Got))
 		ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_ARM_GLOB_DAT))
 	} else {
@@ -537,10 +512,6 @@
 }
 
 func adddynsym(ctxt *ld.Link, s *ld.LSym) {
-	var d *ld.LSym
-	var t int
-	var name string
-
 	if s.Dynid >= 0 {
 		return
 	}
@@ -549,10 +520,10 @@
 		s.Dynid = int32(ld.Nelfsym)
 		ld.Nelfsym++
 
-		d = ld.Linklookup(ctxt, ".dynsym", 0)
+		d := ld.Linklookup(ctxt, ".dynsym", 0)
 
 		/* name */
-		name = s.Extname
+		name := s.Extname
 
 		ld.Adduint32(ctxt, d, uint32(ld.Addstring(ld.Linklookup(ctxt, ".dynstr", 0), name)))
 
@@ -567,7 +538,7 @@
 		ld.Adduint32(ctxt, d, 0)
 
 		/* type */
-		t = ld.STB_GLOBAL << 4
+		t := ld.STB_GLOBAL << 4
 
 		if (s.Cgoexport&ld.CgoExportDynamic != 0) && s.Type&ld.SMASK == ld.STEXT {
 			t |= ld.STT_FUNC
@@ -589,14 +560,12 @@
 }
 
 func adddynlib(lib string) {
-	var s *ld.LSym
-
 	if needlib(lib) == 0 {
 		return
 	}
 
 	if ld.Iself {
-		s = ld.Linklookup(ld.Ctxt, ".dynstr", 0)
+		s := ld.Linklookup(ld.Ctxt, ".dynstr", 0)
 		if s.Size == 0 {
 			ld.Addstring(s, "")
 		}
@@ -609,13 +578,6 @@
 }
 
 func asmb() {
-	var symo uint32
-	var dwarfoff uint32
-	var machlink uint32
-	var sect *ld.Section
-	var sym *ld.LSym
-	var i int
-
 	if ld.Debug['v'] != 0 {
 		fmt.Fprintf(&ld.Bso, "%5.2f asmb\n", obj.Cputime())
 	}
@@ -625,7 +587,7 @@
 		ld.Asmbelfsetup()
 	}
 
-	sect = ld.Segtext.Sect
+	sect := ld.Segtext.Sect
 	ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff))
 	ld.Codeblk(int64(sect.Vaddr), int64(sect.Length))
 	for sect = sect.Next; sect != nil; sect = sect.Next {
@@ -651,14 +613,14 @@
 	ld.Cseek(int64(ld.Segdata.Fileoff))
 	ld.Datblk(int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen))
 
-	machlink = 0
+	machlink := uint32(0)
 	if ld.HEADTYPE == ld.Hdarwin {
 		if ld.Debug['v'] != 0 {
 			fmt.Fprintf(&ld.Bso, "%5.2f dwarf\n", obj.Cputime())
 		}
 
 		if ld.Debug['w'] == 0 {
-			dwarfoff = uint32(ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND)))
+			dwarfoff := uint32(ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND)))
 			ld.Cseek(int64(dwarfoff))
 
 			ld.Segdwarf.Fileoff = uint64(ld.Cpos())
@@ -673,7 +635,7 @@
 	ld.Symsize = 0
 
 	ld.Lcsize = 0
-	symo = 0
+	symo := uint32(0)
 	if ld.Debug['s'] == 0 {
 		// TODO: rationalize
 		if ld.Debug['v'] != 0 {
@@ -719,10 +681,10 @@
 			ld.Asmplan9sym()
 			ld.Cflush()
 
-			sym = ld.Linklookup(ld.Ctxt, "pclntab", 0)
+			sym := ld.Linklookup(ld.Ctxt, "pclntab", 0)
 			if sym != nil {
 				ld.Lcsize = int32(len(sym.P))
-				for i = 0; int32(i) < ld.Lcsize; i++ {
+				for i := 0; int32(i) < ld.Lcsize; i++ {
 					ld.Cput(uint8(sym.P[i]))
 				}
 
diff --git a/src/cmd/5l/obj.go b/src/cmd/5l/obj.go
index 98ebbc2..7eb3b0e 100644
--- a/src/cmd/5l/obj.go
+++ b/src/cmd/5l/obj.go
@@ -81,8 +81,6 @@
 }
 
 func archinit() {
-	var s *ld.LSym
-
 	// getgoextlinkenabled is based on GO_EXTLINK_ENABLED when
 	// Go was built; see ../../make.bash.
 	if ld.Linkmode == ld.LinkAuto && obj.Getgoextlinkenabled() == "0" {
@@ -175,7 +173,7 @@
 	}
 
 	// embed goarm to runtime.goarm
-	s = ld.Linklookup(ld.Ctxt, "runtime.goarm", 0)
+	s := ld.Linklookup(ld.Ctxt, "runtime.goarm", 0)
 
 	s.Type = ld.SRODATA
 	ld.Adduint8(ld.Ctxt, s, uint8(ld.Ctxt.Goarm))
diff --git a/src/cmd/6g/cgen.go b/src/cmd/6g/cgen.go
index cb16039..05bc55b 100644
--- a/src/cmd/6g/cgen.go
+++ b/src/cmd/6g/cgen.go
@@ -29,13 +29,8 @@
 		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
+		return
 	}
 
 	if res == nil || res.Type == nil {
@@ -60,7 +55,7 @@
 		} else {
 			gc.Cgen_slice(n, res)
 		}
-		goto ret
+		return
 
 	case gc.OEFACE:
 		if res.Op != gc.ONAME || res.Addable == 0 {
@@ -71,7 +66,7 @@
 		} else {
 			gc.Cgen_eface(n, res)
 		}
-		goto ret
+		return
 	}
 
 	if n.Ullman >= gc.UINF {
@@ -83,7 +78,7 @@
 			gc.Tempname(&n1, n.Type)
 			cgen(n, &n1)
 			cgen(&n1, res)
-			goto ret
+			return
 		}
 	}
 
@@ -92,7 +87,7 @@
 			gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
 		}
 		sgen(n, res, n.Type.Width)
-		goto ret
+		return
 	}
 
 	if res.Addable == 0 {
@@ -108,7 +103,7 @@
 
 			cgen(&n1, res)
 			regfree(&n1)
-			goto ret
+			return
 		}
 
 		var f int
@@ -118,7 +113,7 @@
 
 		if gc.Complexop(n, res) {
 			gc.Complexgen(n, res)
-			goto ret
+			return
 		}
 
 		f = 1 // gen thru register
@@ -151,7 +146,7 @@
 					fmt.Printf("%v [ignore previous line]\n", p1)
 				}
 				sudoclean()
-				goto ret
+				return
 			}
 		}
 
@@ -160,7 +155,7 @@
 		igen(res, &n1, nil)
 		cgen(n, &n1)
 		regfree(&n1)
-		goto ret
+		return
 	}
 
 	// update addressability for string, slice
@@ -184,16 +179,16 @@
 
 	if gc.Complexop(n, res) {
 		gc.Complexgen(n, res)
-		goto ret
+		return
 	}
 
 	if n.Addable != 0 {
 		gmove(n, res)
-		goto ret
+		return
 	}
 
-	nl = n.Left
-	nr = n.Right
+	nl := n.Left
+	nr := n.Right
 
 	if nl != nil && nl.Ullman >= gc.UINF {
 		if nr != nil && nr.Ullman >= gc.UINF {
@@ -203,7 +198,7 @@
 			n2 := *n
 			n2.Left = &n1
 			cgen(&n2, res)
-			goto ret
+			return
 		}
 	}
 
@@ -224,10 +219,11 @@
 			}
 
 			sudoclean()
-			goto ret
+			return
 		}
 	}
 
+	var a int
 	switch n.Op {
 	default:
 		gc.Dump("cgen", n)
@@ -252,11 +248,11 @@
 		bgen(n, true, 0, p2)
 		gmove(gc.Nodbool(false), res)
 		gc.Patch(p3, gc.Pc)
-		goto ret
+		return
 
 	case gc.OPLUS:
 		cgen(nl, res)
-		goto ret
+		return
 
 		// unary
 	case gc.OCOM:
@@ -270,7 +266,7 @@
 		gins(a, &n2, &n1)
 		gmove(&n1, res)
 		regfree(&n1)
-		goto ret
+		return
 
 	case gc.OMINUS:
 		if gc.Isfloat[nl.Type.Etype] != 0 {
@@ -280,8 +276,16 @@
 			goto sbop
 		}
 
-		a = optoas(int(n.Op), nl.Type)
-		goto uop
+		a := optoas(int(n.Op), nl.Type)
+		// unary
+		var n1 gc.Node
+		regalloc(&n1, nl.Type, res)
+
+		cgen(nl, &n1)
+		gins(a, nil, &n1)
+		gmove(&n1, res)
+		regfree(&n1)
+		return
 
 		// symmetric binary
 	case gc.OAND,
@@ -325,7 +329,7 @@
 				gmove(&n2, res)
 				regfree(&n2)
 				regfree(&n1)
-				goto ret
+				return
 			}
 		}
 
@@ -517,7 +521,7 @@
 		cgen_shift(int(n.Op), n.Bounded, nl, nr, res)
 	}
 
-	goto ret
+	return
 
 	/*
 	 * put simplest on right - we'll generate into left
@@ -543,6 +547,8 @@
 	}
 
 abop: // asymmetric binary
+	var n1 gc.Node
+	var n2 gc.Node
 	if nl.Ullman >= nr.Ullman {
 		regalloc(&n1, nl.Type, res)
 		cgen(nl, &n1)
@@ -588,18 +594,7 @@
 	if n2.Op != gc.OLITERAL {
 		regfree(&n2)
 	}
-	goto ret
-
-uop: // unary
-	regalloc(&n1, nl.Type, res)
-
-	cgen(nl, &n1)
-	gins(a, nil, &n1)
-	gmove(&n1, res)
-	regfree(&n1)
-	goto ret
-
-ret:
+	return
 }
 
 /*
@@ -878,7 +873,6 @@
 		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.
@@ -894,7 +888,7 @@
 		gins(x86.ALEAQ, &n1, &n2)
 		gmove(&n2, res)
 		regfree(&n2)
-		goto ret
+		return
 	}
 
 	if n.Addable != 0 {
@@ -903,10 +897,10 @@
 		gins(x86.ALEAQ, n, &n1)
 		gmove(&n1, res)
 		regfree(&n1)
-		goto ret
+		return
 	}
 
-	nl = n.Left
+	nl := n.Left
 
 	switch n.Op {
 	default:
@@ -981,8 +975,6 @@
 			ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
 		}
 	}
-
-ret:
 }
 
 /*
@@ -1108,27 +1100,21 @@
 		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 {
-			goto ret
+			return
 		}
 	}
 
-	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)
-		goto ret
+		return
 	}
 
-	nr = nil
+	nr := (*gc.Node)(nil)
 
 	for n.Op == gc.OCONVNOP {
 		n = n.Left
@@ -1137,6 +1123,7 @@
 		}
 	}
 
+	var nl *gc.Node
 	switch n.Op {
 	default:
 		goto def
@@ -1146,7 +1133,7 @@
 		if !true_ == (n.Val.U.Bval == 0) {
 			gc.Patch(gc.Gbranch(obj.AJMP, nil, likely), to)
 		}
-		goto ret
+		return
 
 	case gc.ONAME:
 		if n.Addable == 0 {
@@ -1160,7 +1147,7 @@
 			a = x86.AJEQ
 		}
 		gc.Patch(gc.Gbranch(a, n.Type, likely), to)
-		goto ret
+		return
 
 	case gc.OANDAND,
 		gc.OOROR:
@@ -1178,7 +1165,7 @@
 			bgen(n.Right, true_, likely, to)
 		}
 
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1188,7 +1175,7 @@
 		gc.OGE:
 		nr = n.Right
 		if nr == nil || nr.Type == nil {
-			goto ret
+			return
 		}
 		fallthrough
 
@@ -1196,14 +1183,14 @@
 		nl = n.Left
 
 		if nl == nil || nl.Type == nil {
-			goto ret
+			return
 		}
 	}
 
 	switch n.Op {
 	case gc.ONOT:
 		bgen(nl, !true_, likely, to)
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1225,7 +1212,7 @@
 				n.Ninit = ll
 				gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
 				gc.Patch(p2, gc.Pc)
-				goto ret
+				return
 			}
 
 			a = gc.Brcom(a)
@@ -1352,22 +1339,22 @@
 		regfree(&n2)
 	}
 
-	goto ret
+	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 = x86.AJNE
+	a := x86.AJNE
 	if !true_ {
 		a = x86.AJEQ
 	}
 	gc.Patch(gc.Gbranch(a, n.Type, likely), to)
 	regfree(&n1)
-	goto ret
-
-ret:
+	return
 }
 
 /*
diff --git a/src/cmd/6g/ggen.go b/src/cmd/6g/ggen.go
index d0c43d6..c278f02 100644
--- a/src/cmd/6g/ggen.go
+++ b/src/cmd/6g/ggen.go
@@ -786,14 +786,6 @@
  *	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 cx gc.Node
-	var oldcx gc.Node
-	var rcx int
-	var tcount *gc.Type
-
 	a := optoas(op, nl.Type)
 
 	if nr.Op == gc.OLITERAL {
@@ -813,7 +805,7 @@
 		}
 		gmove(&n1, res)
 		regfree(&n1)
-		goto ret
+		return
 	}
 
 	if nl.Ullman >= gc.UINF {
@@ -830,24 +822,27 @@
 		nr = &n5
 	}
 
-	rcx = int(reg[x86.REG_CX])
+	rcx := int(reg[x86.REG_CX])
+	var n1 gc.Node
 	gc.Nodreg(&n1, gc.Types[gc.TUINT32], x86.REG_CX)
 
 	// Allow either uint32 or uint64 as shift type,
 	// to avoid unnecessary conversion from uint32 to uint64
 	// just to do the comparison.
-	tcount = gc.Types[gc.Simtype[nr.Type.Etype]]
+	tcount := gc.Types[gc.Simtype[nr.Type.Etype]]
 
 	if tcount.Etype < gc.TUINT32 {
 		tcount = gc.Types[gc.TUINT32]
 	}
 
 	regalloc(&n1, nr.Type, &n1) // to hold the shift type in CX
-	regalloc(&n3, tcount, &n1)  // to clear high bits of CX
+	var n3 gc.Node
+	regalloc(&n3, tcount, &n1) // to clear high bits of CX
 
+	var cx gc.Node
 	gc.Nodreg(&cx, gc.Types[gc.TUINT64], x86.REG_CX)
 
-	oldcx = gc.Node{}
+	oldcx := gc.Node{}
 	if rcx > 0 && !gc.Samereg(&cx, res) {
 		regalloc(&oldcx, gc.Types[gc.TUINT64], nil)
 		gmove(&cx, &oldcx)
@@ -855,6 +850,7 @@
 
 	cx.Type = tcount
 
+	var n2 gc.Node
 	if gc.Samereg(&cx, res) {
 		regalloc(&n2, nl.Type, nil)
 	} else {
@@ -900,8 +896,6 @@
 
 	regfree(&n1)
 	regfree(&n2)
-
-ret:
 }
 
 /*
diff --git a/src/cmd/6g/gsubr.go b/src/cmd/6g/gsubr.go
index 4a1edf7..807b6b2 100644
--- a/src/cmd/6g/gsubr.go
+++ b/src/cmd/6g/gsubr.go
@@ -1349,12 +1349,6 @@
 
 	*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) {
@@ -1364,118 +1358,108 @@
 		if v >= 32000 || v <= -32000 {
 			break
 		}
-		goto lit
+		switch as {
+		default:
+			return false
+
+		case x86.AADDB,
+			x86.AADDW,
+			x86.AADDL,
+			x86.AADDQ,
+			x86.ASUBB,
+			x86.ASUBW,
+			x86.ASUBL,
+			x86.ASUBQ,
+			x86.AANDB,
+			x86.AANDW,
+			x86.AANDL,
+			x86.AANDQ,
+			x86.AORB,
+			x86.AORW,
+			x86.AORL,
+			x86.AORQ,
+			x86.AXORB,
+			x86.AXORW,
+			x86.AXORL,
+			x86.AXORQ,
+			x86.AINCB,
+			x86.AINCW,
+			x86.AINCL,
+			x86.AINCQ,
+			x86.ADECB,
+			x86.ADECW,
+			x86.ADECL,
+			x86.ADECQ,
+			x86.AMOVB,
+			x86.AMOVW,
+			x86.AMOVL,
+			x86.AMOVQ:
+			break
+		}
+
+		cleani += 2
+		reg := &clean[cleani-1]
+		reg1 := &clean[cleani-2]
+		reg.Op = gc.OEMPTY
+		reg1.Op = gc.OEMPTY
+		gc.Naddr(n, a, 1)
+		return true
 
 	case gc.ODOT,
 		gc.ODOTPTR:
 		cleani += 2
-		reg = &clean[cleani-1]
+		reg := &clean[cleani-1]
 		reg1 := &clean[cleani-2]
 		reg.Op = gc.OEMPTY
 		reg1.Op = gc.OEMPTY
-		goto odot
+		var nn *gc.Node
+		var oary [10]int64
+		o := gc.Dotoffset(n, oary[:], &nn)
+		if nn == nil {
+			sudoclean()
+			return false
+		}
+
+		if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+			// directly addressable set of DOTs
+			n1 := *nn
+
+			n1.Type = n.Type
+			n1.Xoffset += oary[0]
+			gc.Naddr(&n1, a, 1)
+			return true
+		}
+
+		regalloc(reg, gc.Types[gc.Tptr], nil)
+		n1 := *reg
+		n1.Op = gc.OINDREG
+		if oary[0] >= 0 {
+			agen(nn, reg)
+			n1.Xoffset = oary[0]
+		} else {
+			cgen(nn, reg)
+			gc.Cgen_checknil(reg)
+			n1.Xoffset = -(oary[0] + 1)
+		}
+
+		for i := 1; i < o; i++ {
+			if oary[i] >= 0 {
+				gc.Fatal("can't happen")
+			}
+			gins(movptr, &n1, reg)
+			gc.Cgen_checknil(reg)
+			n1.Xoffset = -(oary[i] + 1)
+		}
+
+		a.Type = obj.TYPE_NONE
+		a.Index = obj.TYPE_NONE
+		fixlargeoffset(&n1)
+		gc.Naddr(&n1, a, 1)
+		return true
 
 	case gc.OINDEX:
 		return false
 	}
 
 	return false
-
-lit:
-	switch as {
-	default:
-		return false
-
-	case x86.AADDB,
-		x86.AADDW,
-		x86.AADDL,
-		x86.AADDQ,
-		x86.ASUBB,
-		x86.ASUBW,
-		x86.ASUBL,
-		x86.ASUBQ,
-		x86.AANDB,
-		x86.AANDW,
-		x86.AANDL,
-		x86.AANDQ,
-		x86.AORB,
-		x86.AORW,
-		x86.AORL,
-		x86.AORQ,
-		x86.AXORB,
-		x86.AXORW,
-		x86.AXORL,
-		x86.AXORQ,
-		x86.AINCB,
-		x86.AINCW,
-		x86.AINCL,
-		x86.AINCQ,
-		x86.ADECB,
-		x86.ADECW,
-		x86.ADECL,
-		x86.ADECQ,
-		x86.AMOVB,
-		x86.AMOVW,
-		x86.AMOVL,
-		x86.AMOVQ:
-		break
-	}
-
-	cleani += 2
-	reg = &clean[cleani-1]
-	reg1 = &clean[cleani-2]
-	reg.Op = gc.OEMPTY
-	reg1.Op = gc.OEMPTY
-	gc.Naddr(n, a, 1)
-	goto yes
-
-odot:
-	o = gc.Dotoffset(n, oary[:], &nn)
-	if nn == nil {
-		goto no
-	}
-
-	if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
-		// directly addressable set of DOTs
-		n1 := *nn
-
-		n1.Type = n.Type
-		n1.Xoffset += oary[0]
-		gc.Naddr(&n1, a, 1)
-		goto yes
-	}
-
-	regalloc(reg, gc.Types[gc.Tptr], nil)
-	n1 = *reg
-	n1.Op = gc.OINDREG
-	if oary[0] >= 0 {
-		agen(nn, reg)
-		n1.Xoffset = oary[0]
-	} else {
-		cgen(nn, reg)
-		gc.Cgen_checknil(reg)
-		n1.Xoffset = -(oary[0] + 1)
-	}
-
-	for i := 1; i < o; i++ {
-		if oary[i] >= 0 {
-			gc.Fatal("can't happen")
-		}
-		gins(movptr, &n1, reg)
-		gc.Cgen_checknil(reg)
-		n1.Xoffset = -(oary[i] + 1)
-	}
-
-	a.Type = obj.TYPE_NONE
-	a.Index = obj.TYPE_NONE
-	fixlargeoffset(&n1)
-	gc.Naddr(&n1, a, 1)
-	goto yes
-
-yes:
-	return true
-
-no:
-	sudoclean()
-	return false
 }
diff --git a/src/cmd/6g/peep.go b/src/cmd/6g/peep.go
index ed582d7..f81be87 100644
--- a/src/cmd/6g/peep.go
+++ b/src/cmd/6g/peep.go
@@ -563,8 +563,7 @@
 	}
 
 	var info gc.ProgInfo
-	var r *gc.Flow
-	for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+	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)
 		}
@@ -595,7 +594,31 @@
 		}
 
 		if (info.Flags&gc.Move != 0) && (info.Flags&(gc.SizeL|gc.SizeQ|gc.SizeF|gc.SizeD) != 0) && p.To.Type == v1.Type && p.To.Reg == v1.Reg {
-			goto gotit
+			copysub(&p.To, v1, v2, 1)
+			if gc.Debug['P'] != 0 {
+				fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+				if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
+					fmt.Printf(" excise")
+				}
+				fmt.Printf("\n")
+			}
+
+			for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+				p = r.Prog
+				copysub(&p.From, v1, v2, 1)
+				copysub(&p.To, v1, v2, 1)
+				if gc.Debug['P'] != 0 {
+					fmt.Printf("%v\n", r.Prog)
+				}
+			}
+
+			t := int(int(v1.Reg))
+			v1.Reg = v2.Reg
+			v2.Reg = int16(t)
+			if gc.Debug['P'] != 0 {
+				fmt.Printf("%v last\n", r.Prog)
+			}
+			return true
 		}
 
 		if copyau(&p.From, v2) || copyau(&p.To, v2) {
@@ -617,33 +640,6 @@
 		fmt.Printf("\tran off end; return 0\n")
 	}
 	return false
-
-gotit:
-	copysub(&p.To, v1, v2, 1)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
-		if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
-			fmt.Printf(" excise")
-		}
-		fmt.Printf("\n")
-	}
-
-	for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
-		p = r.Prog
-		copysub(&p.From, v1, v2, 1)
-		copysub(&p.To, v1, v2, 1)
-		if gc.Debug['P'] != 0 {
-			fmt.Printf("%v\n", r.Prog)
-		}
-	}
-
-	t := int(int(v1.Reg))
-	v1.Reg = v2.Reg
-	v2.Reg = int16(t)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("%v last\n", r.Prog)
-	}
-	return true
 }
 
 /*
diff --git a/src/cmd/6l/asm.go b/src/cmd/6l/asm.go
index 72e9dbf..22776b9 100644
--- a/src/cmd/6l/asm.go
+++ b/src/cmd/6l/asm.go
@@ -44,17 +44,14 @@
 var zeroes string
 
 func needlib(name string) int {
-	var p string
-	var s *ld.LSym
-
 	if name[0] == '\x00' {
 		return 0
 	}
 
 	/* reuse hash code in symbol table */
-	p = fmt.Sprintf(".elfload.%s", name)
+	p := fmt.Sprintf(".elfload.%s", name)
 
-	s = ld.Linklookup(ld.Ctxt, p, 0)
+	s := ld.Linklookup(ld.Ctxt, p, 0)
 
 	if s.Type == 0 {
 		s.Type = 100 // avoid SDATA, etc.
@@ -74,11 +71,7 @@
 }
 
 func adddynrel(s *ld.LSym, r *ld.Reloc) {
-	var targ *ld.LSym
-	var rela *ld.LSym
-	var got *ld.LSym
-
-	targ = r.Sym
+	targ := r.Sym
 	ld.Ctxt.Cursym = s
 
 	switch r.Type {
@@ -233,7 +226,7 @@
 		}
 		if ld.Iself {
 			adddynsym(ld.Ctxt, targ)
-			rela = ld.Linklookup(ld.Ctxt, ".rela", 0)
+			rela := ld.Linklookup(ld.Ctxt, ".rela", 0)
 			ld.Addaddrplus(ld.Ctxt, rela, s, int64(r.Off))
 			if r.Siz == 8 {
 				ld.Adduint64(ld.Ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_X86_64_64))
@@ -258,7 +251,7 @@
 			// but we only need to support cgo and that's all it needs.
 			adddynsym(ld.Ctxt, targ)
 
-			got = ld.Linklookup(ld.Ctxt, ".got", 0)
+			got := ld.Linklookup(ld.Ctxt, ".got", 0)
 			s.Type = got.Type | ld.SSUB
 			s.Outer = got
 			s.Sub = got.Sub
@@ -276,11 +269,9 @@
 }
 
 func elfreloc1(r *ld.Reloc, sectoff int64) int {
-	var elfsym int32
-
 	ld.Thearch.Vput(uint64(sectoff))
 
-	elfsym = r.Xsym.Elfsym
+	elfsym := r.Xsym.Elfsym
 	switch r.Type {
 	default:
 		return -1
@@ -337,9 +328,8 @@
 
 func machoreloc1(r *ld.Reloc, sectoff int64) int {
 	var v uint32
-	var rs *ld.LSym
 
-	rs = r.Xsym
+	rs := r.Xsym
 
 	if rs.Type == ld.SHOSTOBJ || r.Type == ld.R_PCREL {
 		if rs.Dynid < 0 {
@@ -406,11 +396,8 @@
 }
 
 func elfsetupplt() {
-	var plt *ld.LSym
-	var got *ld.LSym
-
-	plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
-	got = ld.Linklookup(ld.Ctxt, ".got.plt", 0)
+	plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
+	got := ld.Linklookup(ld.Ctxt, ".got.plt", 0)
 	if plt.Size == 0 {
 		// pushq got+8(IP)
 		ld.Adduint8(ld.Ctxt, plt, 0xff)
@@ -443,13 +430,9 @@
 	adddynsym(ld.Ctxt, s)
 
 	if ld.Iself {
-		var plt *ld.LSym
-		var got *ld.LSym
-		var rela *ld.LSym
-
-		plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
-		got = ld.Linklookup(ld.Ctxt, ".got.plt", 0)
-		rela = ld.Linklookup(ld.Ctxt, ".rela.plt", 0)
+		plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
+		got := ld.Linklookup(ld.Ctxt, ".got.plt", 0)
+		rela := ld.Linklookup(ld.Ctxt, ".rela.plt", 0)
 		if plt.Size == 0 {
 			elfsetupplt()
 		}
@@ -491,10 +474,8 @@
 		// http://networkpx.blogspot.com/2009/09/about-lcdyldinfoonly-command.html
 		// has details about what we're avoiding.
 
-		var plt *ld.LSym
-
 		addgotsym(s)
-		plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
+		plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
 
 		ld.Adduint32(ld.Ctxt, ld.Linklookup(ld.Ctxt, ".linkedit.plt", 0), uint32(s.Dynid))
 
@@ -510,20 +491,17 @@
 }
 
 func addgotsym(s *ld.LSym) {
-	var got *ld.LSym
-	var rela *ld.LSym
-
 	if s.Got >= 0 {
 		return
 	}
 
 	adddynsym(ld.Ctxt, s)
-	got = ld.Linklookup(ld.Ctxt, ".got", 0)
+	got := ld.Linklookup(ld.Ctxt, ".got", 0)
 	s.Got = int32(got.Size)
 	ld.Adduint64(ld.Ctxt, got, 0)
 
 	if ld.Iself {
-		rela = ld.Linklookup(ld.Ctxt, ".rela", 0)
+		rela := ld.Linklookup(ld.Ctxt, ".rela", 0)
 		ld.Addaddrplus(ld.Ctxt, rela, got, int64(s.Got))
 		ld.Adduint64(ld.Ctxt, rela, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_X86_64_GLOB_DAT))
 		ld.Adduint64(ld.Ctxt, rela, 0)
@@ -535,10 +513,6 @@
 }
 
 func adddynsym(ctxt *ld.Link, s *ld.LSym) {
-	var d *ld.LSym
-	var t int
-	var name string
-
 	if s.Dynid >= 0 {
 		return
 	}
@@ -547,13 +521,13 @@
 		s.Dynid = int32(ld.Nelfsym)
 		ld.Nelfsym++
 
-		d = ld.Linklookup(ctxt, ".dynsym", 0)
+		d := ld.Linklookup(ctxt, ".dynsym", 0)
 
-		name = s.Extname
+		name := s.Extname
 		ld.Adduint32(ctxt, d, uint32(ld.Addstring(ld.Linklookup(ctxt, ".dynstr", 0), name)))
 
 		/* type */
-		t = ld.STB_GLOBAL << 4
+		t := ld.STB_GLOBAL << 4
 
 		if s.Cgoexport != 0 && s.Type&ld.SMASK == ld.STEXT {
 			t |= ld.STT_FUNC
@@ -595,14 +569,12 @@
 }
 
 func adddynlib(lib string) {
-	var s *ld.LSym
-
 	if needlib(lib) == 0 {
 		return
 	}
 
 	if ld.Iself {
-		s = ld.Linklookup(ld.Ctxt, ".dynstr", 0)
+		s := ld.Linklookup(ld.Ctxt, ".dynstr", 0)
 		if s.Size == 0 {
 			ld.Addstring(s, "")
 		}
@@ -615,15 +587,6 @@
 }
 
 func asmb() {
-	var magic int32
-	var i int
-	var vl int64
-	var symo int64
-	var dwarfoff int64
-	var machlink int64
-	var sect *ld.Section
-	var sym *ld.LSym
-
 	if ld.Debug['v'] != 0 {
 		fmt.Fprintf(&ld.Bso, "%5.2f asmb\n", obj.Cputime())
 	}
@@ -638,7 +601,7 @@
 		ld.Asmbelfsetup()
 	}
 
-	sect = ld.Segtext.Sect
+	sect := ld.Segtext.Sect
 	ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff))
 	ld.Codeblk(int64(sect.Vaddr), int64(sect.Length))
 	for sect = sect.Next; sect != nil; sect = sect.Next {
@@ -664,13 +627,13 @@
 	ld.Cseek(int64(ld.Segdata.Fileoff))
 	ld.Datblk(int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen))
 
-	machlink = 0
+	machlink := int64(0)
 	if ld.HEADTYPE == ld.Hdarwin {
 		if ld.Debug['v'] != 0 {
 			fmt.Fprintf(&ld.Bso, "%5.2f dwarf\n", obj.Cputime())
 		}
 
-		dwarfoff = ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND))
+		dwarfoff := ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND))
 		ld.Cseek(dwarfoff)
 
 		ld.Segdwarf.Fileoff = uint64(ld.Cpos())
@@ -708,7 +671,7 @@
 	ld.Symsize = 0
 	ld.Spsize = 0
 	ld.Lcsize = 0
-	symo = 0
+	symo := int64(0)
 	if ld.Debug['s'] == 0 {
 		if ld.Debug['v'] != 0 {
 			fmt.Fprintf(&ld.Bso, "%5.2f sym\n", obj.Cputime())
@@ -763,10 +726,10 @@
 			ld.Asmplan9sym()
 			ld.Cflush()
 
-			sym = ld.Linklookup(ld.Ctxt, "pclntab", 0)
+			sym := ld.Linklookup(ld.Ctxt, "pclntab", 0)
 			if sym != nil {
 				ld.Lcsize = int32(len(sym.P))
-				for i = 0; int32(i) < ld.Lcsize; i++ {
+				for i := 0; int32(i) < ld.Lcsize; i++ {
 					ld.Cput(uint8(sym.P[i]))
 				}
 
@@ -795,7 +758,7 @@
 	switch ld.HEADTYPE {
 	default:
 	case ld.Hplan9: /* plan9 */
-		magic = 4*26*26 + 7
+		magic := int32(4*26*26 + 7)
 
 		magic |= 0x00008000                  /* fat header */
 		ld.Lputb(uint32(magic))              /* magic */
@@ -803,7 +766,7 @@
 		ld.Lputb(uint32(ld.Segdata.Filelen))
 		ld.Lputb(uint32(ld.Segdata.Length - ld.Segdata.Filelen))
 		ld.Lputb(uint32(ld.Symsize)) /* nsyms */
-		vl = ld.Entryvalue()
+		vl := ld.Entryvalue()
 		ld.Lputb(PADDR(uint32(vl))) /* va of entry */
 		ld.Lputb(uint32(ld.Spsize)) /* sp offsets */
 		ld.Lputb(uint32(ld.Lcsize)) /* line offsets */
diff --git a/src/cmd/8g/cgen.go b/src/cmd/8g/cgen.go
index ba8953a..1be0928 100644
--- a/src/cmd/8g/cgen.go
+++ b/src/cmd/8g/cgen.go
@@ -254,8 +254,15 @@
 
 	case gc.OMINUS,
 		gc.OCOM:
-		a = optoas(int(n.Op), nl.Type)
-		goto uop
+		a := optoas(int(n.Op), nl.Type)
+		// unary
+		var n1 gc.Node
+		gc.Tempname(&n1, nl.Type)
+
+		cgen(nl, &n1)
+		gins(a, nil, &n1)
+		gmove(&n1, res)
+		return
 
 		// symmetric binary
 	case gc.OAND,
@@ -270,7 +277,13 @@
 			break
 		}
 
-		goto sbop
+		// symmetric binary
+		if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL {
+			r := nl
+			nl = nr
+			nr = r
+		}
+		goto abop
 
 		// asymmetric binary
 	case gc.OSUB:
@@ -443,13 +456,6 @@
 
 	return
 
-sbop: // symmetric binary
-	if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL {
-		r := nl
-		nl = nr
-		nr = r
-	}
-
 abop: // asymmetric binary
 	if gc.Smallintconst(nr) {
 		var n1 gc.Node
@@ -488,15 +494,6 @@
 	}
 
 	return
-
-uop: // unary
-	var n1 gc.Node
-	gc.Tempname(&n1, nl.Type)
-
-	cgen(nl, &n1)
-	gins(a, nil, &n1)
-	gmove(&n1, res)
-	return
 }
 
 /*
diff --git a/src/cmd/8g/cgen64.go b/src/cmd/8g/cgen64.go
index 0755f0e..f0b9e49 100644
--- a/src/cmd/8g/cgen64.go
+++ b/src/cmd/8g/cgen64.go
@@ -199,7 +199,7 @@
 				gins(i386.AMOVL, ncon(0), &lo2)
 				gins(i386.AMOVL, ncon(0), &hi2)
 				splitclean()
-				goto out
+				return
 			}
 
 			if v >= 32 {
@@ -215,7 +215,7 @@
 				gins(i386.AMOVL, ncon(0), &lo2)
 				splitclean()
 				splitclean()
-				goto out
+				return
 			}
 
 			// general shift
@@ -296,7 +296,7 @@
 				}
 
 				splitclean()
-				goto out
+				return
 			}
 
 			if v >= 32 {
@@ -316,7 +316,7 @@
 				}
 				splitclean()
 				splitclean()
-				goto out
+				return
 			}
 
 			// general shift
@@ -482,7 +482,7 @@
 
 			splitclean()
 			splitclean()
-			goto out
+			return
 		}
 
 		gins(i386.AMOVL, &lo1, &ax)
@@ -500,8 +500,6 @@
 	gins(i386.AMOVL, &ax, &lo1)
 	gins(i386.AMOVL, &dx, &hi1)
 	splitclean()
-
-out:
 }
 
 /*
diff --git a/src/cmd/8g/ggen.go b/src/cmd/8g/ggen.go
index ca2a79f..7aba85e 100644
--- a/src/cmd/8g/ggen.go
+++ b/src/cmd/8g/ggen.go
@@ -934,7 +934,27 @@
 	gc.Nodreg(&f0, nl.Type, i386.REG_F0)
 	gc.Nodreg(&f1, n.Type, i386.REG_F0+1)
 	if nr != nil {
-		goto flt2
+		// binary
+		if nl.Ullman >= nr.Ullman {
+			cgen(nl, &f0)
+			if nr.Addable != 0 {
+				gins(foptoas(int(n.Op), n.Type, 0), nr, &f0)
+			} else {
+				cgen(nr, &f0)
+				gins(foptoas(int(n.Op), n.Type, Fpop), &f0, &f1)
+			}
+		} else {
+			cgen(nr, &f0)
+			if nl.Addable != 0 {
+				gins(foptoas(int(n.Op), n.Type, Frev), nl, &f0)
+			} else {
+				cgen(nl, &f0)
+				gins(foptoas(int(n.Op), n.Type, Frev|Fpop), &f0, &f1)
+			}
+		}
+
+		gmove(&f0, res)
+		return
 	}
 
 	// unary
@@ -945,28 +965,6 @@
 	}
 	gmove(&f0, res)
 	return
-
-flt2: // binary
-	if nl.Ullman >= nr.Ullman {
-		cgen(nl, &f0)
-		if nr.Addable != 0 {
-			gins(foptoas(int(n.Op), n.Type, 0), nr, &f0)
-		} else {
-			cgen(nr, &f0)
-			gins(foptoas(int(n.Op), n.Type, Fpop), &f0, &f1)
-		}
-	} else {
-		cgen(nr, &f0)
-		if nl.Addable != 0 {
-			gins(foptoas(int(n.Op), n.Type, Frev), nl, &f0)
-		} else {
-			cgen(nl, &f0)
-			gins(foptoas(int(n.Op), n.Type, Frev|Fpop), &f0, &f1)
-		}
-	}
-
-	gmove(&f0, res)
-	return
 }
 
 func cgen_floatsse(n *gc.Node, res *gc.Node) {
@@ -1064,7 +1062,47 @@
 	var n2 gc.Node
 	var ax gc.Node
 	if gc.Use_sse != 0 {
-		goto 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
+		}
+
+		var n2 gc.Node
+		regalloc(&n2, nr.Type, nil)
+		gmove(nr, &n2)
+		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
+
+			nr = nl
+			nl = r
+			a = gc.Brrev(a)
+		}
+
+		gins(foptoas(gc.OCMP, nr.Type, 0), nl, nr)
+		if nl.Op == gc.OREGISTER {
+			regfree(nl)
+		}
+		regfree(nr)
+		goto ret
 	} else {
 		goto x87
 	}
@@ -1118,47 +1156,6 @@
 
 	goto ret
 
-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
-	}
-
-	regalloc(&n2, nr.Type, nil)
-	gmove(nr, &n2)
-	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
-
-		nr = nl
-		nl = r
-		a = gc.Brrev(a)
-	}
-
-	gins(foptoas(gc.OCMP, nr.Type, 0), nl, nr)
-	if nl.Op == gc.OREGISTER {
-		regfree(nl)
-	}
-	regfree(nr)
-
 ret:
 	if a == gc.OEQ {
 		// neither NE nor P
diff --git a/src/cmd/8g/gsubr.go b/src/cmd/8g/gsubr.go
index 841f4dc..ec00779 100644
--- a/src/cmd/8g/gsubr.go
+++ b/src/cmd/8g/gsubr.go
@@ -403,7 +403,48 @@
 	et := int(gc.Simtype[t.Etype])
 
 	if gc.Use_sse != 0 {
-		goto sse
+		switch uint32(op)<<16 | uint32(et) {
+		default:
+			gc.Fatal("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+
+		case gc.OCMP<<16 | gc.TFLOAT32:
+			a = i386.AUCOMISS
+
+		case gc.OCMP<<16 | gc.TFLOAT64:
+			a = i386.AUCOMISD
+
+		case gc.OAS<<16 | gc.TFLOAT32:
+			a = i386.AMOVSS
+
+		case gc.OAS<<16 | gc.TFLOAT64:
+			a = i386.AMOVSD
+
+		case gc.OADD<<16 | gc.TFLOAT32:
+			a = i386.AADDSS
+
+		case gc.OADD<<16 | gc.TFLOAT64:
+			a = i386.AADDSD
+
+		case gc.OSUB<<16 | gc.TFLOAT32:
+			a = i386.ASUBSS
+
+		case gc.OSUB<<16 | gc.TFLOAT64:
+			a = i386.ASUBSD
+
+		case gc.OMUL<<16 | gc.TFLOAT32:
+			a = i386.AMULSS
+
+		case gc.OMUL<<16 | gc.TFLOAT64:
+			a = i386.AMULSD
+
+		case gc.ODIV<<16 | gc.TFLOAT32:
+			a = i386.ADIVSS
+
+		case gc.ODIV<<16 | gc.TFLOAT64:
+			a = i386.ADIVSD
+		}
+
+		return a
 	}
 
 	// If we need Fpop, it means we're working on
@@ -499,50 +540,6 @@
 
 	gc.Fatal("foptoas %v %v %#x", gc.Oconv(int(op), 0), gc.Tconv(t, 0), flg)
 	return 0
-
-sse:
-	switch uint32(op)<<16 | uint32(et) {
-	default:
-		gc.Fatal("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
-
-	case gc.OCMP<<16 | gc.TFLOAT32:
-		a = i386.AUCOMISS
-
-	case gc.OCMP<<16 | gc.TFLOAT64:
-		a = i386.AUCOMISD
-
-	case gc.OAS<<16 | gc.TFLOAT32:
-		a = i386.AMOVSS
-
-	case gc.OAS<<16 | gc.TFLOAT64:
-		a = i386.AMOVSD
-
-	case gc.OADD<<16 | gc.TFLOAT32:
-		a = i386.AADDSS
-
-	case gc.OADD<<16 | gc.TFLOAT64:
-		a = i386.AADDSD
-
-	case gc.OSUB<<16 | gc.TFLOAT32:
-		a = i386.ASUBSS
-
-	case gc.OSUB<<16 | gc.TFLOAT64:
-		a = i386.ASUBSD
-
-	case gc.OMUL<<16 | gc.TFLOAT32:
-		a = i386.AMULSS
-
-	case gc.OMUL<<16 | gc.TFLOAT64:
-		a = i386.AMULSD
-
-	case gc.ODIV<<16 | gc.TFLOAT32:
-		a = i386.ADIVSS
-
-	case gc.ODIV<<16 | gc.TFLOAT64:
-		a = i386.ADIVSD
-	}
-
-	return a
 }
 
 var resvd = []int{
@@ -928,7 +925,9 @@
 
 	switch uint32(ft)<<16 | uint32(tt) {
 	default:
-		goto fatal
+		// should not happen
+		gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
+		return
 
 		/*
 		 * integer copy and truncate
@@ -1164,10 +1163,6 @@
 	gmove(&r1, t)
 	regfree(&r1)
 	return
-
-	// should not happen
-fatal:
-	gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
 }
 
 func floatmove(f *gc.Node, t *gc.Node) {
diff --git a/src/cmd/8g/peep.go b/src/cmd/8g/peep.go
index 8aa6e94..deb3405 100644
--- a/src/cmd/8g/peep.go
+++ b/src/cmd/8g/peep.go
@@ -371,8 +371,7 @@
 		return false
 	}
 	var info gc.ProgInfo
-	var r *gc.Flow
-	for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+	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)
 		}
@@ -393,7 +392,31 @@
 		}
 
 		if (info.Flags&gc.Move != 0) && (info.Flags&(gc.SizeL|gc.SizeQ|gc.SizeF|gc.SizeD) != 0) && p.To.Type == v1.Type && p.To.Reg == v1.Reg {
-			goto gotit
+			copysub(&p.To, v1, v2, 1)
+			if gc.Debug['P'] != 0 {
+				fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+				if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
+					fmt.Printf(" excise")
+				}
+				fmt.Printf("\n")
+			}
+
+			for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+				p = r.Prog
+				copysub(&p.From, v1, v2, 1)
+				copysub(&p.To, v1, v2, 1)
+				if gc.Debug['P'] != 0 {
+					fmt.Printf("%v\n", r.Prog)
+				}
+			}
+
+			t := int(v1.Reg)
+			v1.Reg = v2.Reg
+			v2.Reg = int16(t)
+			if gc.Debug['P'] != 0 {
+				fmt.Printf("%v last\n", r.Prog)
+			}
+			return true
 		}
 
 		if copyau(&p.From, v2) || copyau(&p.To, v2) {
@@ -405,33 +428,6 @@
 	}
 
 	return false
-
-gotit:
-	copysub(&p.To, v1, v2, 1)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
-		if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
-			fmt.Printf(" excise")
-		}
-		fmt.Printf("\n")
-	}
-
-	for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
-		p = r.Prog
-		copysub(&p.From, v1, v2, 1)
-		copysub(&p.To, v1, v2, 1)
-		if gc.Debug['P'] != 0 {
-			fmt.Printf("%v\n", r.Prog)
-		}
-	}
-
-	t := int(v1.Reg)
-	v1.Reg = v2.Reg
-	v2.Reg = int16(t)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("%v last\n", r.Prog)
-	}
-	return true
 }
 
 /*
diff --git a/src/cmd/8l/asm.go b/src/cmd/8l/asm.go
index 295c62e..d040c03 100644
--- a/src/cmd/8l/asm.go
+++ b/src/cmd/8l/asm.go
@@ -38,17 +38,14 @@
 import "cmd/internal/ld"
 
 func needlib(name string) int {
-	var p string
-	var s *ld.LSym
-
 	if name[0] == '\x00' {
 		return 0
 	}
 
 	/* reuse hash code in symbol table */
-	p = fmt.Sprintf(".dynlib.%s", name)
+	p := fmt.Sprintf(".dynlib.%s", name)
 
-	s = ld.Linklookup(ld.Ctxt, p, 0)
+	s := ld.Linklookup(ld.Ctxt, p, 0)
 
 	if s.Type == 0 {
 		s.Type = 100 // avoid SDATA, etc.
@@ -66,11 +63,7 @@
 }
 
 func adddynrel(s *ld.LSym, r *ld.Reloc) {
-	var targ *ld.LSym
-	var rel *ld.LSym
-	var got *ld.LSym
-
-	targ = r.Sym
+	targ := r.Sym
 	ld.Ctxt.Cursym = s
 
 	switch r.Type {
@@ -210,7 +203,7 @@
 		}
 		if ld.Iself {
 			adddynsym(ld.Ctxt, targ)
-			rel = ld.Linklookup(ld.Ctxt, ".rel", 0)
+			rel := ld.Linklookup(ld.Ctxt, ".rel", 0)
 			ld.Addaddrplus(ld.Ctxt, rel, s, int64(r.Off))
 			ld.Adduint32(ld.Ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_386_32))
 			r.Type = ld.R_CONST // write r->add during relocsym
@@ -231,7 +224,7 @@
 			// but we only need to support cgo and that's all it needs.
 			adddynsym(ld.Ctxt, targ)
 
-			got = ld.Linklookup(ld.Ctxt, ".got", 0)
+			got := ld.Linklookup(ld.Ctxt, ".got", 0)
 			s.Type = got.Type | ld.SSUB
 			s.Outer = got
 			s.Sub = got.Sub
@@ -249,11 +242,9 @@
 }
 
 func elfreloc1(r *ld.Reloc, sectoff int64) int {
-	var elfsym int32
-
 	ld.Thearch.Lput(uint32(sectoff))
 
-	elfsym = r.Xsym.Elfsym
+	elfsym := r.Xsym.Elfsym
 	switch r.Type {
 	default:
 		return -1
@@ -287,9 +278,8 @@
 
 func machoreloc1(r *ld.Reloc, sectoff int64) int {
 	var v uint32
-	var rs *ld.LSym
 
-	rs = r.Xsym
+	rs := r.Xsym
 
 	if rs.Type == ld.SHOSTOBJ {
 		if rs.Dynid < 0 {
@@ -365,11 +355,8 @@
 }
 
 func elfsetupplt() {
-	var plt *ld.LSym
-	var got *ld.LSym
-
-	plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
-	got = ld.Linklookup(ld.Ctxt, ".got.plt", 0)
+	plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
+	got := ld.Linklookup(ld.Ctxt, ".got.plt", 0)
 	if plt.Size == 0 {
 		// pushl got+4
 		ld.Adduint8(ld.Ctxt, plt, 0xff)
@@ -395,10 +382,6 @@
 }
 
 func addpltsym(ctxt *ld.Link, s *ld.LSym) {
-	var plt *ld.LSym
-	var got *ld.LSym
-	var rel *ld.LSym
-
 	if s.Plt >= 0 {
 		return
 	}
@@ -406,9 +389,9 @@
 	adddynsym(ctxt, s)
 
 	if ld.Iself {
-		plt = ld.Linklookup(ctxt, ".plt", 0)
-		got = ld.Linklookup(ctxt, ".got.plt", 0)
-		rel = ld.Linklookup(ctxt, ".rel.plt", 0)
+		plt := ld.Linklookup(ctxt, ".plt", 0)
+		got := ld.Linklookup(ctxt, ".got.plt", 0)
+		rel := ld.Linklookup(ctxt, ".rel.plt", 0)
 		if plt.Size == 0 {
 			elfsetupplt()
 		}
@@ -441,9 +424,7 @@
 	} else if ld.HEADTYPE == ld.Hdarwin {
 		// Same laziness as in 6l.
 
-		var plt *ld.LSym
-
-		plt = ld.Linklookup(ctxt, ".plt", 0)
+		plt := ld.Linklookup(ctxt, ".plt", 0)
 
 		addgotsym(ctxt, s)
 
@@ -461,20 +442,17 @@
 }
 
 func addgotsym(ctxt *ld.Link, s *ld.LSym) {
-	var got *ld.LSym
-	var rel *ld.LSym
-
 	if s.Got >= 0 {
 		return
 	}
 
 	adddynsym(ctxt, s)
-	got = ld.Linklookup(ctxt, ".got", 0)
+	got := ld.Linklookup(ctxt, ".got", 0)
 	s.Got = int32(got.Size)
 	ld.Adduint32(ctxt, got, 0)
 
 	if ld.Iself {
-		rel = ld.Linklookup(ctxt, ".rel", 0)
+		rel := ld.Linklookup(ctxt, ".rel", 0)
 		ld.Addaddrplus(ctxt, rel, got, int64(s.Got))
 		ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_386_GLOB_DAT))
 	} else if ld.HEADTYPE == ld.Hdarwin {
@@ -485,10 +463,6 @@
 }
 
 func adddynsym(ctxt *ld.Link, s *ld.LSym) {
-	var d *ld.LSym
-	var t int
-	var name string
-
 	if s.Dynid >= 0 {
 		return
 	}
@@ -497,10 +471,10 @@
 		s.Dynid = int32(ld.Nelfsym)
 		ld.Nelfsym++
 
-		d = ld.Linklookup(ctxt, ".dynsym", 0)
+		d := ld.Linklookup(ctxt, ".dynsym", 0)
 
 		/* name */
-		name = s.Extname
+		name := s.Extname
 
 		ld.Adduint32(ctxt, d, uint32(ld.Addstring(ld.Linklookup(ctxt, ".dynstr", 0), name)))
 
@@ -515,7 +489,7 @@
 		ld.Adduint32(ctxt, d, 0)
 
 		/* type */
-		t = ld.STB_GLOBAL << 4
+		t := ld.STB_GLOBAL << 4
 
 		if s.Cgoexport != 0 && s.Type&ld.SMASK == ld.STEXT {
 			t |= ld.STT_FUNC
@@ -541,14 +515,12 @@
 }
 
 func adddynlib(lib string) {
-	var s *ld.LSym
-
 	if needlib(lib) == 0 {
 		return
 	}
 
 	if ld.Iself {
-		s = ld.Linklookup(ld.Ctxt, ".dynstr", 0)
+		s := ld.Linklookup(ld.Ctxt, ".dynstr", 0)
 		if s.Size == 0 {
 			ld.Addstring(s, "")
 		}
@@ -561,14 +533,6 @@
 }
 
 func asmb() {
-	var magic int32
-	var symo uint32
-	var dwarfoff uint32
-	var machlink uint32
-	var sect *ld.Section
-	var sym *ld.LSym
-	var i int
-
 	if ld.Debug['v'] != 0 {
 		fmt.Fprintf(&ld.Bso, "%5.2f asmb\n", obj.Cputime())
 	}
@@ -578,7 +542,7 @@
 		ld.Asmbelfsetup()
 	}
 
-	sect = ld.Segtext.Sect
+	sect := ld.Segtext.Sect
 	ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff))
 	ld.Codeblk(int64(sect.Vaddr), int64(sect.Length))
 	for sect = sect.Next; sect != nil; sect = sect.Next {
@@ -604,13 +568,13 @@
 	ld.Cseek(int64(ld.Segdata.Fileoff))
 	ld.Datblk(int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen))
 
-	machlink = 0
+	machlink := uint32(0)
 	if ld.HEADTYPE == ld.Hdarwin {
 		if ld.Debug['v'] != 0 {
 			fmt.Fprintf(&ld.Bso, "%5.2f dwarf\n", obj.Cputime())
 		}
 
-		dwarfoff = uint32(ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND)))
+		dwarfoff := uint32(ld.Rnd(int64(uint64(ld.HEADR)+ld.Segtext.Length), int64(ld.INITRND)) + ld.Rnd(int64(ld.Segdata.Filelen), int64(ld.INITRND)))
 		ld.Cseek(int64(dwarfoff))
 
 		ld.Segdwarf.Fileoff = uint64(ld.Cpos())
@@ -623,7 +587,7 @@
 	ld.Symsize = 0
 	ld.Spsize = 0
 	ld.Lcsize = 0
-	symo = 0
+	symo := uint32(0)
 	if ld.Debug['s'] == 0 {
 		// TODO: rationalize
 		if ld.Debug['v'] != 0 {
@@ -673,10 +637,10 @@
 			ld.Asmplan9sym()
 			ld.Cflush()
 
-			sym = ld.Linklookup(ld.Ctxt, "pclntab", 0)
+			sym := ld.Linklookup(ld.Ctxt, "pclntab", 0)
 			if sym != nil {
 				ld.Lcsize = int32(len(sym.P))
-				for i = 0; int32(i) < ld.Lcsize; i++ {
+				for i := 0; int32(i) < ld.Lcsize; i++ {
 					ld.Cput(uint8(sym.P[i]))
 				}
 
@@ -704,7 +668,7 @@
 	switch ld.HEADTYPE {
 	default:
 	case ld.Hplan9: /* plan9 */
-		magic = 4*11*11 + 7
+		magic := int32(4*11*11 + 7)
 
 		ld.Lputb(uint32(magic))              /* magic */
 		ld.Lputb(uint32(ld.Segtext.Filelen)) /* sizes */
diff --git a/src/cmd/9g/cgen.go b/src/cmd/9g/cgen.go
index 74accf2..61a93da 100644
--- a/src/cmd/9g/cgen.go
+++ b/src/cmd/9g/cgen.go
@@ -26,13 +26,8 @@
 		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
+		return
 	}
 
 	if res == nil || res.Type == nil {
@@ -57,7 +52,7 @@
 		} else {
 			gc.Cgen_slice(n, res)
 		}
-		goto ret
+		return
 
 	case gc.OEFACE:
 		if res.Op != gc.ONAME || res.Addable == 0 {
@@ -68,7 +63,7 @@
 		} else {
 			gc.Cgen_eface(n, res)
 		}
-		goto ret
+		return
 	}
 
 	if n.Ullman >= gc.UINF {
@@ -80,7 +75,7 @@
 			gc.Tempname(&n1, n.Type)
 			cgen(n, &n1)
 			cgen(&n1, res)
-			goto ret
+			return
 		}
 	}
 
@@ -89,7 +84,7 @@
 			gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
 		}
 		sgen(n, res, n.Type.Width)
-		goto ret
+		return
 	}
 
 	if res.Addable == 0 {
@@ -105,7 +100,7 @@
 
 			cgen(&n1, res)
 			regfree(&n1)
-			goto ret
+			return
 		}
 
 		var f int
@@ -115,7 +110,7 @@
 
 		if gc.Complexop(n, res) {
 			gc.Complexgen(n, res)
-			goto ret
+			return
 		}
 
 		f = 1 // gen thru register
@@ -148,7 +143,7 @@
 					fmt.Printf("%v [ignore previous line]\n", p1)
 				}
 				sudoclean()
-				goto ret
+				return
 			}
 		}
 
@@ -157,7 +152,7 @@
 		igen(res, &n1, nil)
 		cgen(n, &n1)
 		regfree(&n1)
-		goto ret
+		return
 	}
 
 	// update addressability for string, slice
@@ -181,7 +176,7 @@
 
 	if gc.Complexop(n, res) {
 		gc.Complexgen(n, res)
-		goto ret
+		return
 	}
 
 	// if both are addressable, move
@@ -196,11 +191,11 @@
 			regfree(&n1)
 		}
 
-		goto ret
+		return
 	}
 
-	nl = n.Left
-	nr = n.Right
+	nl := n.Left
+	nr := n.Right
 
 	if nl != nil && nl.Ullman >= gc.UINF {
 		if nr != nil && nr.Ullman >= gc.UINF {
@@ -210,7 +205,7 @@
 			n2 := *n
 			n2.Left = &n1
 			cgen(&n2, res)
-			goto ret
+			return
 		}
 	}
 
@@ -231,7 +226,7 @@
 			}
 
 			sudoclean()
-			goto ret
+			return
 		}
 	}
 
@@ -239,6 +234,7 @@
 	// OGE, OLE, and ONE ourselves.
 	// if(nl != N && isfloat[n->type->etype] && isfloat[nl->type->etype]) goto flt;
 
+	var a int
 	switch n.Op {
 	default:
 		gc.Dump("cgen", n)
@@ -263,11 +259,11 @@
 		bgen(n, true, 0, p2)
 		gmove(gc.Nodbool(false), res)
 		gc.Patch(p3, gc.Pc)
-		goto ret
+		return
 
 	case gc.OPLUS:
 		cgen(nl, res)
-		goto ret
+		return
 
 		// unary
 	case gc.OCOM:
@@ -281,7 +277,7 @@
 		gins(a, &n2, &n1)
 		gmove(&n1, res)
 		regfree(&n1)
-		goto ret
+		return
 
 	case gc.OMINUS:
 		if gc.Isfloat[nl.Type.Etype] != 0 {
@@ -291,8 +287,16 @@
 			goto sbop
 		}
 
-		a = optoas(int(n.Op), nl.Type)
-		goto uop
+		a := optoas(int(n.Op), nl.Type)
+		// unary
+		var n1 gc.Node
+		regalloc(&n1, nl.Type, res)
+
+		cgen(nl, &n1)
+		gins(a, nil, &n1)
+		gmove(&n1, res)
+		regfree(&n1)
+		return
 
 		// symmetric binary
 	case gc.OAND,
@@ -331,7 +335,7 @@
 				gmove(&n2, res)
 				regfree(&n2)
 				regfree(&n1)
-				goto ret
+				return
 			}
 		}
 
@@ -523,7 +527,7 @@
 		cgen_shift(int(n.Op), n.Bounded, nl, nr, res)
 	}
 
-	goto ret
+	return
 
 	/*
 	 * put simplest on right - we'll generate into left
@@ -549,6 +553,8 @@
 	}
 
 abop: // asymmetric binary
+	var n1 gc.Node
+	var n2 gc.Node
 	if nl.Ullman >= nr.Ullman {
 		regalloc(&n1, nl.Type, res)
 		cgen(nl, &n1)
@@ -610,18 +616,7 @@
 	if n2.Op != gc.OLITERAL {
 		regfree(&n2)
 	}
-	goto ret
-
-uop: // unary
-	regalloc(&n1, nl.Type, res)
-
-	cgen(nl, &n1)
-	gins(a, nil, &n1)
-	gmove(&n1, res)
-	regfree(&n1)
-	goto ret
-
-ret:
+	return
 }
 
 /*
@@ -887,7 +882,6 @@
 		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.
@@ -906,7 +900,7 @@
 		gins(ppc64.AMOVD, &n3, &n2)
 		gmove(&n2, res)
 		regfree(&n2)
-		goto ret
+		return
 	}
 
 	if n.Addable != 0 {
@@ -918,10 +912,10 @@
 		gins(ppc64.AMOVD, &n1, &n2)
 		gmove(&n2, res)
 		regfree(&n2)
-		goto ret
+		return
 	}
 
-	nl = n.Left
+	nl := n.Left
 
 	switch n.Op {
 	default:
@@ -999,8 +993,6 @@
 			ginsadd(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
 		}
 	}
-
-ret:
 }
 
 /*
@@ -1126,24 +1118,21 @@
 		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 {
-			goto ret
+			return
 		}
 	}
 
-	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)
-		goto ret
+		return
 	}
 
-	nr = nil
+	nr := (*gc.Node)(nil)
 
 	for n.Op == gc.OCONVNOP {
 		n = n.Left
@@ -1152,6 +1141,7 @@
 		}
 	}
 
+	var nl *gc.Node
 	switch n.Op {
 	default:
 		var n1 gc.Node
@@ -1166,14 +1156,14 @@
 		}
 		gc.Patch(gc.Gbranch(a, n.Type, likely), to)
 		regfree(&n1)
-		goto ret
+		return
 
 		// need to ask if it is bool?
 	case gc.OLITERAL:
 		if !true_ == (n.Val.U.Bval == 0) {
 			gc.Patch(gc.Gbranch(ppc64.ABR, nil, likely), to)
 		}
-		goto ret
+		return
 
 	case gc.OANDAND,
 		gc.OOROR:
@@ -1191,7 +1181,7 @@
 			bgen(n.Right, true_, likely, to)
 		}
 
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1201,7 +1191,7 @@
 		gc.OGE:
 		nr = n.Right
 		if nr == nil || nr.Type == nil {
-			goto ret
+			return
 		}
 		fallthrough
 
@@ -1209,14 +1199,14 @@
 		nl = n.Left
 
 		if nl == nil || nl.Type == nil {
-			goto ret
+			return
 		}
 	}
 
 	switch n.Op {
 	case gc.ONOT:
 		bgen(nl, !true_, likely, to)
-		goto ret
+		return
 
 	case gc.OEQ,
 		gc.ONE,
@@ -1238,7 +1228,7 @@
 				n.Ninit = ll
 				gc.Patch(gc.Gbranch(ppc64.ABR, nil, 0), to)
 				gc.Patch(p2, gc.Pc)
-				goto ret
+				return
 			}
 
 			a = gc.Brcom(a)
@@ -1365,9 +1355,7 @@
 		regfree(&n2)
 	}
 
-	goto ret
-
-ret:
+	return
 }
 
 /*
diff --git a/src/cmd/9g/ggen.go b/src/cmd/9g/ggen.go
index 2a3dbcb..bd22771 100644
--- a/src/cmd/9g/ggen.go
+++ b/src/cmd/9g/ggen.go
@@ -572,10 +572,7 @@
 func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
 	// TODO(minux): enable division by magic multiply (also need to fix longmod below)
 	//if(nr->op != OLITERAL)
-	goto longdiv
-
 	// division and mod using (slow) hardware instruction
-longdiv:
 	dodiv(op, nl, nr, res)
 
 	return
@@ -639,11 +636,6 @@
  *	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 tcount *gc.Type
-
 	a := int(optoas(op, nl.Type))
 
 	if nr.Op == gc.OLITERAL {
@@ -663,7 +655,7 @@
 		}
 		gmove(&n1, res)
 		regfree(&n1)
-		goto ret
+		return
 	}
 
 	if nl.Ullman >= gc.UINF {
@@ -683,15 +675,18 @@
 	// Allow either uint32 or uint64 as shift type,
 	// to avoid unnecessary conversion from uint32 to uint64
 	// just to do the comparison.
-	tcount = gc.Types[gc.Simtype[nr.Type.Etype]]
+	tcount := gc.Types[gc.Simtype[nr.Type.Etype]]
 
 	if tcount.Etype < gc.TUINT32 {
 		tcount = gc.Types[gc.TUINT32]
 	}
 
+	var n1 gc.Node
 	regalloc(&n1, nr.Type, nil) // to hold the shift type in CX
-	regalloc(&n3, tcount, &n1)  // to clear high bits of CX
+	var n3 gc.Node
+	regalloc(&n3, tcount, &n1) // to clear high bits of CX
 
+	var n2 gc.Node
 	regalloc(&n2, nl.Type, res)
 
 	if nl.Ullman >= nr.Ullman {
@@ -728,8 +723,6 @@
 
 	regfree(&n1)
 	regfree(&n2)
-
-ret:
 }
 
 func clearfat(nl *gc.Node) {
@@ -759,9 +752,8 @@
 	agen(nl, &dst)
 
 	var boff uint64
-	var p *obj.Prog
 	if q > 128 {
-		p = gins(ppc64.ASUB, nil, &dst)
+		p := gins(ppc64.ASUB, nil, &dst)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 8
 
@@ -784,7 +776,7 @@
 		// The loop leaves R3 on the last zeroed dword
 		boff = 8
 	} else if q >= 4 {
-		p = gins(ppc64.ASUB, nil, &dst)
+		p := gins(ppc64.ASUB, nil, &dst)
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = 8
 		f := (*gc.Node)(gc.Sysfunc("duffzero"))
@@ -797,6 +789,7 @@
 		// duffzero leaves R3 on the last zeroed dword
 		boff = 8
 	} else {
+		var p *obj.Prog
 		for t := uint64(0); t < q; t++ {
 			p = gins(ppc64.AMOVD, &r0, &dst)
 			p.To.Type = obj.TYPE_MEM
@@ -806,6 +799,7 @@
 		boff = 8 * q
 	}
 
+	var p *obj.Prog
 	for t := uint64(0); t < c; t++ {
 		p = gins(ppc64.AMOVB, &r0, &dst)
 		p.To.Type = obj.TYPE_MEM
diff --git a/src/cmd/9g/peep.go b/src/cmd/9g/peep.go
index f7c0a95..ecb8fb5 100644
--- a/src/cmd/9g/peep.go
+++ b/src/cmd/9g/peep.go
@@ -407,9 +407,8 @@
 	if !regtyp(v2) {
 		return false
 	}
-	var r *gc.Flow
 	var info gc.ProgInfo
-	for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+	for r := gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
 		if gc.Uniqs(r) == nil {
 			break
 		}
@@ -425,7 +424,32 @@
 		if info.Flags&(gc.RightRead|gc.RightWrite) == gc.RightWrite {
 			if p.To.Type == v1.Type {
 				if p.To.Reg == v1.Reg {
-					goto gotit
+					copysub(&p.To, v1, v2, 1)
+					if gc.Debug['P'] != 0 {
+						fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+						if p.From.Type == v2.Type {
+							fmt.Printf(" excise")
+						}
+						fmt.Printf("\n")
+					}
+
+					for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+						p = r.Prog
+						copysub(&p.From, v1, v2, 1)
+						copysub1(p, v1, v2, 1)
+						copysub(&p.To, v1, v2, 1)
+						if gc.Debug['P'] != 0 {
+							fmt.Printf("%v\n", r.Prog)
+						}
+					}
+
+					t := int(int(v1.Reg))
+					v1.Reg = v2.Reg
+					v2.Reg = int16(t)
+					if gc.Debug['P'] != 0 {
+						fmt.Printf("%v last\n", r.Prog)
+					}
+					return true
 				}
 			}
 		}
@@ -439,34 +463,6 @@
 	}
 
 	return false
-
-gotit:
-	copysub(&p.To, v1, v2, 1)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
-		if p.From.Type == v2.Type {
-			fmt.Printf(" excise")
-		}
-		fmt.Printf("\n")
-	}
-
-	for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
-		p = r.Prog
-		copysub(&p.From, v1, v2, 1)
-		copysub1(p, v1, v2, 1)
-		copysub(&p.To, v1, v2, 1)
-		if gc.Debug['P'] != 0 {
-			fmt.Printf("%v\n", r.Prog)
-		}
-	}
-
-	t := int(int(v1.Reg))
-	v1.Reg = v2.Reg
-	v2.Reg = int16(t)
-	if gc.Debug['P'] != 0 {
-		fmt.Printf("%v last\n", r.Prog)
-	}
-	return true
 }
 
 /*
diff --git a/src/cmd/9l/asm.go b/src/cmd/9l/asm.go
index 176de6f..f0f5b56 100644
--- a/src/cmd/9l/asm.go
+++ b/src/cmd/9l/asm.go
@@ -39,17 +39,14 @@
 import "cmd/internal/ld"
 
 func needlib(name string) int {
-	var p string
-	var s *ld.LSym
-
 	if name[0] == '\x00' {
 		return 0
 	}
 
 	/* reuse hash code in symbol table */
-	p = fmt.Sprintf(".dynlib.%s", name)
+	p := fmt.Sprintf(".dynlib.%s", name)
 
-	s = ld.Linklookup(ld.Ctxt, p, 0)
+	s := ld.Linklookup(ld.Ctxt, p, 0)
 
 	if s.Type == 0 {
 		s.Type = 100 // avoid SDATA, etc.
@@ -163,16 +160,13 @@
 // Construct a call stub in stub that calls symbol targ via its PLT
 // entry.
 func gencallstub(abicase int, stub *ld.LSym, targ *ld.LSym) {
-	var plt *ld.LSym
-	var r *ld.Reloc
-
 	if abicase != 1 {
 		// If we see R_PPC64_TOCSAVE or R_PPC64_REL24_NOTOC
 		// relocations, we'll need to implement cases 2 and 3.
 		log.Fatalf("gencallstub only implements case 1 calls")
 	}
 
-	plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
+	plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
 
 	stub.Type = ld.STEXT
 
@@ -180,7 +174,7 @@
 	ld.Adduint32(ld.Ctxt, stub, 0xf8410018) // std r2,24(r1)
 
 	// Load the function pointer from the PLT.
-	r = ld.Addrel(stub)
+	r := ld.Addrel(stub)
 
 	r.Off = int32(stub.Size)
 	r.Sym = plt
@@ -214,10 +208,7 @@
 }
 
 func adddynrel(s *ld.LSym, r *ld.Reloc) {
-	var targ *ld.LSym
-	var rela *ld.LSym
-
-	targ = r.Sym
+	targ := r.Sym
 	ld.Ctxt.Cursym = s
 
 	switch r.Type {
@@ -251,7 +242,7 @@
 			// These happen in .toc sections
 			adddynsym(ld.Ctxt, targ)
 
-			rela = ld.Linklookup(ld.Ctxt, ".rela", 0)
+			rela := ld.Linklookup(ld.Ctxt, ".rela", 0)
 			ld.Addaddrplus(ld.Ctxt, rela, s, int64(r.Off))
 			ld.Adduint64(ld.Ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_PPC64_ADDR64))
 			ld.Adduint64(ld.Ctxt, rela, uint64(r.Add))
@@ -325,9 +316,7 @@
 }
 
 func elfsetupplt() {
-	var plt *ld.LSym
-
-	plt = ld.Linklookup(ld.Ctxt, ".plt", 0)
+	plt := ld.Linklookup(ld.Ctxt, ".plt", 0)
 	if plt.Size == 0 {
 		// The dynamic linker stores the address of the
 		// dynamic resolver and the DSO identifier in the two
@@ -360,10 +349,6 @@
 }
 
 func archreloc(r *ld.Reloc, s *ld.LSym, val *int64) int {
-	var o1 uint32
-	var o2 uint32
-	var t int64
-
 	if ld.Linkmode == ld.LinkExternal {
 		// TODO(minux): translate R_ADDRPOWER and R_CALLPOWER into standard ELF relocations.
 		// R_ADDRPOWER corresponds to R_PPC_ADDR16_HA and R_PPC_ADDR16_LO.
@@ -386,9 +371,9 @@
 		// The encoding of the immediate x<<16 + y,
 		// where x is the low 16 bits of the first instruction and y is the low 16
 		// bits of the second. Both x and y are signed (int16, not uint16).
-		o1 = uint32(r.Add >> 32)
-		o2 = uint32(r.Add)
-		t = ld.Symaddr(r.Sym)
+		o1 := uint32(r.Add >> 32)
+		o2 := uint32(r.Add)
+		t := ld.Symaddr(r.Sym)
 		if t < 0 {
 			ld.Ctxt.Diag("relocation for %s is too big (>=2G): %d", s.Name, ld.Symaddr(r.Sym))
 		}
@@ -410,13 +395,14 @@
 
 	case ld.R_CALLPOWER:
 		// Bits 6 through 29 = (S + A - P) >> 2
+		var o1 uint32
 		if ld.Ctxt.Arch.ByteOrder == binary.BigEndian {
 			o1 = ld.Be32(s.P[r.Off:])
 		} else {
 			o1 = ld.Le32(s.P[r.Off:])
 		}
 
-		t = ld.Symaddr(r.Sym) + r.Add - (s.Value + int64(r.Off))
+		t := ld.Symaddr(r.Sym) + r.Add - (s.Value + int64(r.Off))
 		if t&3 != 0 {
 			ld.Ctxt.Diag("relocation for %s+%d is not aligned: %d", r.Sym.Name, r.Off, t)
 		}
@@ -439,7 +425,6 @@
 }
 
 func archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 {
-	var o1 uint32
 	switch r.Variant & ld.RV_TYPE_MASK {
 	default:
 		ld.Diag("unexpected relocation variant %d", r.Variant)
@@ -452,6 +437,7 @@
 		if r.Variant&ld.RV_CHECK_OVERFLOW != 0 {
 			// Whether to check for signed or unsigned
 			// overflow depends on the instruction
+			var o1 uint32
 			if ld.Ctxt.Arch.ByteOrder == binary.BigEndian {
 				o1 = ld.Be32(s.P[r.Off-2:])
 			} else {
@@ -485,6 +471,7 @@
 		if r.Variant&ld.RV_CHECK_OVERFLOW != 0 {
 			// Whether to check for signed or unsigned
 			// overflow depends on the instruction
+			var o1 uint32
 			if ld.Ctxt.Arch.ByteOrder == binary.BigEndian {
 				o1 = ld.Be32(s.P[r.Off-2:])
 			} else {
@@ -508,6 +495,7 @@
 		return int64(int16(t))
 
 	case ld.RV_POWER_DS:
+		var o1 uint32
 		if ld.Ctxt.Arch.ByteOrder == binary.BigEndian {
 			o1 = uint32(ld.Be16(s.P[r.Off:]))
 		} else {
@@ -535,23 +523,18 @@
 	adddynsym(ctxt, s)
 
 	if ld.Iself {
-		var plt *ld.LSym
-		var rela *ld.LSym
-		var glink *ld.LSym
-		var r *ld.Reloc
-
-		plt = ld.Linklookup(ctxt, ".plt", 0)
-		rela = ld.Linklookup(ctxt, ".rela.plt", 0)
+		plt := ld.Linklookup(ctxt, ".plt", 0)
+		rela := ld.Linklookup(ctxt, ".rela.plt", 0)
 		if plt.Size == 0 {
 			elfsetupplt()
 		}
 
 		// Create the glink resolver if necessary
-		glink = ensureglinkresolver()
+		glink := ensureglinkresolver()
 
 		// Write symbol resolver stub (just a branch to the
 		// glink resolver stub)
-		r = ld.Addrel(glink)
+		r := ld.Addrel(glink)
 
 		r.Sym = glink
 		r.Off = int32(glink.Size)
@@ -579,11 +562,7 @@
 
 // Generate the glink resolver stub if necessary and return the .glink section
 func ensureglinkresolver() *ld.LSym {
-	var glink *ld.LSym
-	var s *ld.LSym
-	var r *ld.Reloc
-
-	glink = ld.Linklookup(ld.Ctxt, ".glink", 0)
+	glink := ld.Linklookup(ld.Ctxt, ".glink", 0)
 	if glink.Size != 0 {
 		return glink
 	}
@@ -610,7 +589,7 @@
 	ld.Adduint32(ld.Ctxt, glink, 0x7800f082) // srdi r0,r0,2
 
 	// r11 = address of the first byte of the PLT
-	r = ld.Addrel(glink)
+	r := ld.Addrel(glink)
 
 	r.Off = int32(glink.Size)
 	r.Sym = ld.Linklookup(ld.Ctxt, ".plt", 0)
@@ -636,7 +615,7 @@
 
 	// Add DT_PPC64_GLINK .dynamic entry, which points to 32 bytes
 	// before the first symbol resolver stub.
-	s = ld.Linklookup(ld.Ctxt, ".dynamic", 0)
+	s := ld.Linklookup(ld.Ctxt, ".dynamic", 0)
 
 	ld.Elfwritedynentsymplus(s, ld.DT_PPC64_GLINK, glink, glink.Size-32)
 
@@ -644,10 +623,6 @@
 }
 
 func adddynsym(ctxt *ld.Link, s *ld.LSym) {
-	var d *ld.LSym
-	var t int
-	var name string
-
 	if s.Dynid >= 0 {
 		return
 	}
@@ -656,13 +631,13 @@
 		s.Dynid = int32(ld.Nelfsym)
 		ld.Nelfsym++
 
-		d = ld.Linklookup(ctxt, ".dynsym", 0)
+		d := ld.Linklookup(ctxt, ".dynsym", 0)
 
-		name = s.Extname
+		name := s.Extname
 		ld.Adduint32(ctxt, d, uint32(ld.Addstring(ld.Linklookup(ctxt, ".dynstr", 0), name)))
 
 		/* type */
-		t = ld.STB_GLOBAL << 4
+		t := ld.STB_GLOBAL << 4
 
 		if s.Cgoexport != 0 && s.Type&ld.SMASK == ld.STEXT {
 			t |= ld.STT_FUNC
@@ -696,14 +671,12 @@
 }
 
 func adddynlib(lib string) {
-	var s *ld.LSym
-
 	if needlib(lib) == 0 {
 		return
 	}
 
 	if ld.Iself {
-		s = ld.Linklookup(ld.Ctxt, ".dynstr", 0)
+		s := ld.Linklookup(ld.Ctxt, ".dynstr", 0)
 		if s.Size == 0 {
 			ld.Addstring(s, "")
 		}
@@ -714,11 +687,6 @@
 }
 
 func asmb() {
-	var symo uint32
-	var sect *ld.Section
-	var sym *ld.LSym
-	var i int
-
 	if ld.Debug['v'] != 0 {
 		fmt.Fprintf(&ld.Bso, "%5.2f asmb\n", obj.Cputime())
 	}
@@ -728,7 +696,7 @@
 		ld.Asmbelfsetup()
 	}
 
-	sect = ld.Segtext.Sect
+	sect := ld.Segtext.Sect
 	ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff))
 	ld.Codeblk(int64(sect.Vaddr), int64(sect.Length))
 	for sect = sect.Next; sect != nil; sect = sect.Next {
@@ -758,7 +726,7 @@
 	ld.Symsize = 0
 
 	ld.Lcsize = 0
-	symo = 0
+	symo := uint32(0)
 	if ld.Debug['s'] == 0 {
 		// TODO: rationalize
 		if ld.Debug['v'] != 0 {
@@ -801,10 +769,10 @@
 			ld.Asmplan9sym()
 			ld.Cflush()
 
-			sym = ld.Linklookup(ld.Ctxt, "pclntab", 0)
+			sym := ld.Linklookup(ld.Ctxt, "pclntab", 0)
 			if sym != nil {
 				ld.Lcsize = int32(len(sym.P))
-				for i = 0; int32(i) < ld.Lcsize; i++ {
+				for i := 0; int32(i) < ld.Lcsize; i++ {
 					ld.Cput(uint8(sym.P[i]))
 				}
 
diff --git a/src/cmd/internal/asm/asm.go b/src/cmd/internal/asm/asm.go
index 71c6b1a..151a8a5 100644
--- a/src/cmd/internal/asm/asm.go
+++ b/src/cmd/internal/asm/asm.go
@@ -163,11 +163,9 @@
 }
 
 func Main() {
-	var p string
-
 	// Allow GOARCH=Thestring or GOARCH=Thestringsuffix,
 	// but not other values.
-	p = obj.Getgoarch()
+	p := obj.Getgoarch()
 
 	if !strings.HasPrefix(p, Thestring) {
 		log.Fatalf("cannot use %cc with GOARCH=%s", Thechar, p)
@@ -219,8 +217,6 @@
 }
 
 func assemble(file string) int {
-	var i int
-
 	if outfile == "" {
 		outfile = strings.TrimSuffix(filepath.Base(file), ".s") + "." + string(Thechar)
 	}
@@ -235,6 +231,7 @@
 	fmt.Fprintf(&obuf, "go object %s %s %s\n", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion())
 	fmt.Fprintf(&obuf, "!\n")
 
+	var i int
 	for Pass = 1; Pass <= 2; Pass++ {
 		pinit(file)
 		for i = 0; i < len(Dlist); i++ {
diff --git a/src/cmd/internal/asm/lexbody.go b/src/cmd/internal/asm/lexbody.go
index 14a82f8..7943cba 100644
--- a/src/cmd/internal/asm/lexbody.go
+++ b/src/cmd/internal/asm/lexbody.go
@@ -45,61 +45,50 @@
  * common code for all the assemblers
  */
 func pragpack() {
-
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragvararg() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragcgo(name string) {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragfpround() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragtextflag() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragdataflag() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragprofile() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func pragincomplete() {
 	for getnsc() != '\n' {
-
 	}
 }
 
 func setinclude(p string) {
-	var i int
-
 	if p == "" {
 		return
 	}
-	for i = 1; i < len(include); i++ {
+	for i := 1; i < len(include); i++ {
 		if p == include[i] {
 			return
 		}
@@ -117,9 +106,7 @@
 }
 
 func pushio() {
-	var i *Io
-
-	i = iostack
+	i := iostack
 	if i == nil {
 		Yyerror("botch in pushio")
 		errorexit()
@@ -129,10 +116,9 @@
 }
 
 func newio() {
-	var i *Io
 	var pushdepth int = 0
 
-	i = iofree
+	i := iofree
 	if i == nil {
 		pushdepth++
 		if pushdepth > 1000 {
@@ -149,9 +135,7 @@
 }
 
 func newfile(s string, f *os.File) {
-	var i *Io
-
-	i = ionext
+	i := ionext
 	i.Link = iostack
 	iostack = i
 	i.F = f
@@ -175,16 +159,13 @@
 }
 
 func LabelLookup(s *Sym) *Sym {
-	var p string
-	var lab *Sym
-
 	if thetext == nil {
 		s.Labelname = s.Name
 		return s
 	}
 
-	p = string(fmt.Sprintf("%s.%s", thetext.Name, s.Name))
-	lab = Lookup(p)
+	p := string(fmt.Sprintf("%s.%s", thetext.Name, s.Name))
+	lab := Lookup(p)
 
 	lab.Labelname = s.Name
 	return lab
@@ -249,11 +230,10 @@
 }
 
 func Yylex(yylval *Yylval) int {
-	var c int
 	var c1 int
 	var s *Sym
 
-	c = peekc
+	c := peekc
 	if c != IGN {
 		peekc = IGN
 		goto l1
@@ -282,7 +262,48 @@
 		goto aloop
 	}
 	if isdigit(c) {
-		goto tnum
+		yybuf.Reset()
+		if c != '0' {
+			goto dc
+		}
+		yybuf.WriteByte(byte(c))
+		c = GETC()
+		c1 = 3
+		if c == 'x' || c == 'X' {
+			c1 = 4
+			c = GETC()
+		} else if c < '0' || c > '7' {
+			goto dc
+		}
+		yylval.Lval = 0
+		for {
+			if c >= '0' && c <= '9' {
+				if c > '7' && c1 == 3 {
+					break
+				}
+				yylval.Lval = int64(uint64(yylval.Lval) << uint(c1))
+				yylval.Lval += int64(c) - '0'
+				c = GETC()
+				continue
+			}
+
+			if c1 == 3 {
+				break
+			}
+			if c >= 'A' && c <= 'F' {
+				c += 'a' - 'A'
+			}
+			if c >= 'a' && c <= 'f' {
+				yylval.Lval = int64(uint64(yylval.Lval) << uint(c1))
+				yylval.Lval += int64(c) - 'a' + 10
+				c = GETC()
+				continue
+			}
+
+			break
+		}
+
+		goto ncu
 	}
 	switch c {
 	case '\n':
@@ -458,50 +479,6 @@
 	yylval.Sval = last
 	return int(s.Type)
 
-tnum:
-	yybuf.Reset()
-	if c != '0' {
-		goto dc
-	}
-	yybuf.WriteByte(byte(c))
-	c = GETC()
-	c1 = 3
-	if c == 'x' || c == 'X' {
-		c1 = 4
-		c = GETC()
-	} else if c < '0' || c > '7' {
-		goto dc
-	}
-	yylval.Lval = 0
-	for {
-		if c >= '0' && c <= '9' {
-			if c > '7' && c1 == 3 {
-				break
-			}
-			yylval.Lval = int64(uint64(yylval.Lval) << uint(c1))
-			yylval.Lval += int64(c) - '0'
-			c = GETC()
-			continue
-		}
-
-		if c1 == 3 {
-			break
-		}
-		if c >= 'A' && c <= 'F' {
-			c += 'a' - 'A'
-		}
-		if c >= 'a' && c <= 'f' {
-			yylval.Lval = int64(uint64(yylval.Lval) << uint(c1))
-			yylval.Lval += int64(c) - 'a' + 10
-			c = GETC()
-			continue
-		}
-
-		break
-	}
-
-	goto ncu
-
 dc:
 	for {
 		if !(isdigit(c)) {
@@ -529,9 +506,7 @@
 }
 
 func getc() int {
-	var c int
-
-	c = peekc
+	c := peekc
 	if c != IGN {
 		peekc = IGN
 		if c == '\n' {
@@ -571,11 +546,10 @@
 }
 
 func escchar(e int) int {
-	var c int
 	var l int
 
 loop:
-	c = getc()
+	c := getc()
 	if c == '\n' {
 		Yyerror("newline in string")
 		return EOF
@@ -643,11 +617,10 @@
 }
 
 func filbuf() int {
-	var i *Io
 	var n int
 
 loop:
-	i = iostack
+	i := iostack
 	if i == nil {
 		return EOF
 	}
@@ -705,11 +678,10 @@
 }
 
 func GETC() int {
-	var c int
 	if len(fi.P) == 0 {
 		return filbuf()
 	}
-	c = int(fi.P[0])
+	c := int(fi.P[0])
 	fi.P = fi.P[1:]
 	return c
 }
diff --git a/src/cmd/internal/asm/macbody.go b/src/cmd/internal/asm/macbody.go
index 337692a..c488ea1 100644
--- a/src/cmd/internal/asm/macbody.go
+++ b/src/cmd/internal/asm/macbody.go
@@ -43,14 +43,11 @@
 )
 
 func getnsn() int32 {
-	var n int32
-	var c int
-
-	c = getnsc()
+	c := getnsc()
 	if c < '0' || c > '9' {
 		return -1
 	}
-	n = 0
+	n := int32(0)
 	for c >= '0' && c <= '9' {
 		n = n*10 + int32(c) - '0'
 		c = getc()
@@ -61,9 +58,7 @@
 }
 
 func getsym() *Sym {
-	var c int
-
-	c = getnsc()
+	c := getnsc()
 	if !isalpha(c) && c != '_' && c < 0x80 {
 		unget(c)
 		return nil
@@ -84,15 +79,12 @@
 }
 
 func getsymdots(dots *int) *Sym {
-	var c int
-	var s *Sym
-
-	s = getsym()
+	s := getsym()
 	if s != nil {
 		return s
 	}
 
-	c = getnsc()
+	c := getnsc()
 	if c != '.' {
 		unget(c)
 		return nil
@@ -153,10 +145,9 @@
 
 func dodefine(cp string) {
 	var s *Sym
-	var p string
 
 	if i := strings.Index(cp, "="); i >= 0 {
-		p = cp[i+1:]
+		p := cp[i+1:]
 		cp = cp[:i]
 		s = Lookup(cp)
 		s.Macro = &Macro{Text: p}
@@ -186,14 +177,11 @@
 }
 
 func domacro() {
-	var i int
-	var s *Sym
-
-	s = getsym()
+	s := getsym()
 	if s == nil {
 		s = Lookup("endif")
 	}
-	for i = 0; i < len(mactab); i++ {
+	for i := 0; i < len(mactab); i++ {
 		if s.Name == mactab[i].Macname {
 			if mactab[i].Macf != nil {
 				mactab[i].Macf()
@@ -209,9 +197,7 @@
 }
 
 func macund() {
-	var s *Sym
-
-	s = getsym()
+	s := getsym()
 	macend()
 	if s == nil {
 		Yyerror("syntax in #undef")
@@ -226,8 +212,6 @@
 )
 
 func macdef() {
-	var s *Sym
-	var a *Sym
 	var args [NARG]string
 	var n int
 	var i int
@@ -236,7 +220,7 @@
 	var ischr int
 	var base bytes.Buffer
 
-	s = getsym()
+	s := getsym()
 	if s == nil {
 		goto bad
 	}
@@ -251,6 +235,8 @@
 		c = getnsc()
 		if c != ')' {
 			unget(c)
+			var a *Sym
+			var c int
 			for {
 				a = getsymdots(&dots)
 				if a == nil {
@@ -316,7 +302,6 @@
 				ischr = 0
 			}
 		} else {
-
 			if c == '"' || c == '\'' {
 				base.WriteByte(byte(c))
 				ischr = c
@@ -417,20 +402,12 @@
 	if s == nil {
 		Yyerror("syntax in #define")
 	} else {
-
 		Yyerror("syntax in #define: %s", s.Name)
 	}
 	macend()
 }
 
 func macexpand(s *Sym) []byte {
-	var l int
-	var c int
-	var arg []string
-	var out bytes.Buffer
-	var buf bytes.Buffer
-	var cp string
-
 	if s.Macro.Narg == 0 {
 		if debug['m'] != 0 {
 			fmt.Printf("#expand %s %s\n", s.Name, s.Macro.Text)
@@ -441,14 +418,19 @@
 	nargs := s.Macro.Narg - 1
 	dots := s.Macro.Dots
 
-	c = getnsc()
+	c := getnsc()
+	var arg []string
+	var cp string
+	var out bytes.Buffer
 	if c != '(' {
 		goto bad
 	}
 	c = getc()
 	if c != ')' {
 		unget(c)
-		l = 0
+		l := 0
+		var buf bytes.Buffer
+		var c int
 		for {
 			c = getc()
 			if c == '"' {
@@ -595,16 +577,14 @@
 }
 
 func macinc() {
-	var c0 int
 	var c int
-	var i int
 	var buf bytes.Buffer
 	var f *os.File
 	var hp string
 	var str string
 	var symb string
 
-	c0 = getnsc()
+	c0 := getnsc()
 	if c0 != '"' {
 		c = c0
 		if c0 != '<' {
@@ -630,7 +610,7 @@
 		goto bad
 	}
 
-	for i = 0; i < len(include); i++ {
+	for i := 0; i < len(include); i++ {
 		if i == 0 && c0 == '>' {
 			continue
 		}
@@ -663,13 +643,11 @@
 }
 
 func maclin() {
-	var c int
-	var n int32
 	var buf bytes.Buffer
 	var symb string
 
-	n = getnsn()
-	c = getc()
+	n := getnsn()
+	c := getc()
 	if n < 0 {
 		goto bad
 	}
@@ -783,16 +761,43 @@
 }
 
 func macprag() {
-	var s *Sym
-	var c0 int
 	var c int
-	var buf bytes.Buffer
-	var symb string
 
-	s = getsym()
+	s := getsym()
 
 	if s != nil && s.Name == "lib" {
-		goto praglib
+		c0 := getnsc()
+		if c0 != '"' {
+			c = c0
+			if c0 != '<' {
+				goto bad
+			}
+			c0 = '>'
+		}
+
+		var buf bytes.Buffer
+		for {
+			c = getc()
+			if c == c0 {
+				break
+			}
+			if c == '\n' {
+				goto bad
+			}
+			buf.WriteByte(byte(c))
+		}
+		symb := buf.String()
+
+		c = getcom()
+		if c != '\n' {
+			goto bad
+		}
+
+		/*
+		 * put pragma-line in as a funny history
+		 */
+		obj.Linklinehist(Ctxt, int(Lineno), symb, -1)
+		return
 	}
 	if s != nil && s.Name == "pack" {
 		pragpack()
@@ -830,43 +835,9 @@
 	}
 
 	for getnsc() != '\n' {
-
 	}
 	return
 
-praglib:
-	c0 = getnsc()
-	if c0 != '"' {
-		c = c0
-		if c0 != '<' {
-			goto bad
-		}
-		c0 = '>'
-	}
-
-	for {
-		c = getc()
-		if c == c0 {
-			break
-		}
-		if c == '\n' {
-			goto bad
-		}
-		buf.WriteByte(byte(c))
-	}
-	symb = buf.String()
-
-	c = getcom()
-	if c != '\n' {
-		goto bad
-	}
-
-	/*
-	 * put pragma-line in as a funny history
-	 */
-	obj.Linklinehist(Ctxt, int(Lineno), symb, -1)
-	return
-
 bad:
 	unget(c)
 	Yyerror("syntax in #pragma lib")
diff --git a/src/cmd/internal/gc/const.go b/src/cmd/internal/gc/const.go
index 43c8809..4730d7d 100644
--- a/src/cmd/internal/gc/const.go
+++ b/src/cmd/internal/gc/const.go
@@ -582,7 +582,96 @@
 	var v Val
 	var norig *Node
 	if nr == nil {
-		goto unary
+		// copy numeric value to avoid modifying
+		// nl, in case someone still refers to it (e.g. iota).
+		v = nl.Val
+
+		if wl == TIDEAL {
+			v = copyval(v)
+		}
+
+		switch uint32(n.Op)<<16 | uint32(v.Ctype) {
+		default:
+			if n.Diag == 0 {
+				Yyerror("illegal constant expression %v %v", Oconv(int(n.Op), 0), Tconv(nl.Type, 0))
+				n.Diag = 1
+			}
+
+			return
+
+		case OCONV<<16 | CTNIL,
+			OARRAYBYTESTR<<16 | CTNIL:
+			if n.Type.Etype == TSTRING {
+				v = tostr(v)
+				nl.Type = n.Type
+				break
+			}
+			fallthrough
+
+			// fall through
+		case OCONV<<16 | CTINT,
+			OCONV<<16 | CTRUNE,
+			OCONV<<16 | CTFLT,
+			OCONV<<16 | CTSTR:
+			convlit1(&nl, n.Type, true)
+
+			v = nl.Val
+
+		case OPLUS<<16 | CTINT,
+			OPLUS<<16 | CTRUNE:
+			break
+
+		case OMINUS<<16 | CTINT,
+			OMINUS<<16 | CTRUNE:
+			mpnegfix(v.U.Xval)
+
+		case OCOM<<16 | CTINT,
+			OCOM<<16 | CTRUNE:
+			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:
+				Mpmovecfix(&b, -1)
+
+				// unsigned guys invert their bits
+			case TUINT8,
+				TUINT16,
+				TUINT32,
+				TUINT64,
+				TUINT,
+				TUINTPTR:
+				mpmovefixfix(&b, Maxintval[et])
+			}
+
+			mpxorfixfix(v.U.Xval, &b)
+
+		case OPLUS<<16 | CTFLT:
+			break
+
+		case OMINUS<<16 | CTFLT:
+			mpnegflt(v.U.Fval)
+
+		case OPLUS<<16 | CTCPLX:
+			break
+
+		case OMINUS<<16 | CTCPLX:
+			mpnegflt(&v.U.Cval.Real)
+			mpnegflt(&v.U.Cval.Imag)
+
+		case ONOT<<16 | CTBOOL:
+			if v.U.Bval == 0 {
+				goto settrue
+			}
+			goto setfalse
+		}
+		goto ret
 	}
 	if nr.Type == nil {
 		return
@@ -944,97 +1033,6 @@
 
 	goto ret
 
-	// copy numeric value to avoid modifying
-	// nl, in case someone still refers to it (e.g. iota).
-unary:
-	v = nl.Val
-
-	if wl == TIDEAL {
-		v = copyval(v)
-	}
-
-	switch uint32(n.Op)<<16 | uint32(v.Ctype) {
-	default:
-		if n.Diag == 0 {
-			Yyerror("illegal constant expression %v %v", Oconv(int(n.Op), 0), Tconv(nl.Type, 0))
-			n.Diag = 1
-		}
-
-		return
-
-	case OCONV<<16 | CTNIL,
-		OARRAYBYTESTR<<16 | CTNIL:
-		if n.Type.Etype == TSTRING {
-			v = tostr(v)
-			nl.Type = n.Type
-			break
-		}
-		fallthrough
-
-		// fall through
-	case OCONV<<16 | CTINT,
-		OCONV<<16 | CTRUNE,
-		OCONV<<16 | CTFLT,
-		OCONV<<16 | CTSTR:
-		convlit1(&nl, n.Type, true)
-
-		v = nl.Val
-
-	case OPLUS<<16 | CTINT,
-		OPLUS<<16 | CTRUNE:
-		break
-
-	case OMINUS<<16 | CTINT,
-		OMINUS<<16 | CTRUNE:
-		mpnegfix(v.U.Xval)
-
-	case OCOM<<16 | CTINT,
-		OCOM<<16 | CTRUNE:
-		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:
-			Mpmovecfix(&b, -1)
-
-			// unsigned guys invert their bits
-		case TUINT8,
-			TUINT16,
-			TUINT32,
-			TUINT64,
-			TUINT,
-			TUINTPTR:
-			mpmovefixfix(&b, Maxintval[et])
-		}
-
-		mpxorfixfix(v.U.Xval, &b)
-
-	case OPLUS<<16 | CTFLT:
-		break
-
-	case OMINUS<<16 | CTFLT:
-		mpnegflt(v.U.Fval)
-
-	case OPLUS<<16 | CTCPLX:
-		break
-
-	case OMINUS<<16 | CTCPLX:
-		mpnegflt(&v.U.Cval.Real)
-		mpnegflt(&v.U.Cval.Imag)
-
-	case ONOT<<16 | CTBOOL:
-		if v.U.Bval == 0 {
-			goto settrue
-		}
-		goto setfalse
-	}
-
 ret:
 	norig = saveorig(n)
 	*n = *nl
diff --git a/src/cmd/internal/gc/cplx.go b/src/cmd/internal/gc/cplx.go
index c07ba34..02b6c79 100644
--- a/src/cmd/internal/gc/cplx.go
+++ b/src/cmd/internal/gc/cplx.go
@@ -255,10 +255,12 @@
 	}
 
 	if n.Op == OREAL || n.Op == OIMAG {
-		goto yes
+		//dump("\ncomplex-yes", n);
+		return true
 	}
 
-	goto no
+	//dump("\ncomplex-no", n);
+	return false
 
 maybe:
 	switch n.Op {
@@ -270,23 +272,20 @@
 		OCOMPLEX,
 		OREAL,
 		OIMAG:
-		goto yes
+		//dump("\ncomplex-yes", n);
+		return true
 
 	case ODOT,
 		ODOTPTR,
 		OINDEX,
 		OIND,
 		ONAME:
-		goto yes
+		//dump("\ncomplex-yes", n);
+		return true
 	}
 
 	//dump("\ncomplex-no", n);
-no:
 	return false
-
-	//dump("\ncomplex-yes", n);
-yes:
-	return true
 }
 
 func Complexmove(f *Node, t *Node) {
diff --git a/src/cmd/internal/gc/lex.go b/src/cmd/internal/gc/lex.go
index 4e5f011..c03222b 100644
--- a/src/cmd/internal/gc/lex.go
+++ b/src/cmd/internal/gc/lex.go
@@ -844,7 +844,6 @@
 var _yylex_lstk *Loophack
 
 func _yylex(yylval *yySymType) int32 {
-	var c int
 	var c1 int
 	var escflag int
 	var v int64
@@ -857,7 +856,7 @@
 	prevlineno = lineno
 
 l0:
-	c = getc()
+	c := getc()
 	if yy_isspace(c) {
 		if c == '\n' && curio.nlsemi != 0 {
 			ungetc(c)
@@ -887,7 +886,82 @@
 	}
 
 	if yy_isdigit(c) {
-		goto tnum
+		cp = &lexbuf
+		cp.Reset()
+		if c != '0' {
+			for {
+				cp.WriteByte(byte(c))
+				c = getc()
+				if yy_isdigit(c) {
+					continue
+				}
+				if c == '.' {
+					goto casedot
+				}
+				if c == 'e' || c == 'E' || c == 'p' || c == 'P' {
+					goto caseep
+				}
+				if c == 'i' {
+					goto casei
+				}
+				goto ncu
+			}
+		}
+
+		cp.WriteByte(byte(c))
+		c = getc()
+		if c == 'x' || c == 'X' {
+			for {
+				cp.WriteByte(byte(c))
+				c = getc()
+				if yy_isdigit(c) {
+					continue
+				}
+				if c >= 'a' && c <= 'f' {
+					continue
+				}
+				if c >= 'A' && c <= 'F' {
+					continue
+				}
+				if lexbuf.Len() == 2 {
+					Yyerror("malformed hex constant")
+				}
+				if c == 'p' {
+					goto caseep
+				}
+				goto ncu
+			}
+		}
+
+		if c == 'p' { // 0p begins floating point zero
+			goto caseep
+		}
+
+		c1 = 0
+		for {
+			if !yy_isdigit(c) {
+				break
+			}
+			if c < '0' || c > '7' {
+				c1 = 1 // not octal
+			}
+			cp.WriteByte(byte(c))
+			c = getc()
+		}
+
+		if c == '.' {
+			goto casedot
+		}
+		if c == 'e' || c == 'E' {
+			goto caseep
+		}
+		if c == 'i' {
+			goto casei
+		}
+		if c1 != 0 {
+			Yyerror("malformed octal constant")
+		}
+		goto ncu
 	}
 
 	switch c {
@@ -1321,86 +1395,6 @@
 	yylval.sym = s
 	return int32(s.Lexical)
 
-tnum:
-	cp = &lexbuf
-	cp.Reset()
-	if c != '0' {
-		for {
-			cp.WriteByte(byte(c))
-			c = getc()
-			if yy_isdigit(c) {
-				continue
-			}
-			goto dc
-		}
-	}
-
-	cp.WriteByte(byte(c))
-	c = getc()
-	if c == 'x' || c == 'X' {
-		for {
-			cp.WriteByte(byte(c))
-			c = getc()
-			if yy_isdigit(c) {
-				continue
-			}
-			if c >= 'a' && c <= 'f' {
-				continue
-			}
-			if c >= 'A' && c <= 'F' {
-				continue
-			}
-			if lexbuf.Len() == 2 {
-				Yyerror("malformed hex constant")
-			}
-			if c == 'p' {
-				goto caseep
-			}
-			goto ncu
-		}
-	}
-
-	if c == 'p' { // 0p begins floating point zero
-		goto caseep
-	}
-
-	c1 = 0
-	for {
-		if !yy_isdigit(c) {
-			break
-		}
-		if c < '0' || c > '7' {
-			c1 = 1 // not octal
-		}
-		cp.WriteByte(byte(c))
-		c = getc()
-	}
-
-	if c == '.' {
-		goto casedot
-	}
-	if c == 'e' || c == 'E' {
-		goto caseep
-	}
-	if c == 'i' {
-		goto casei
-	}
-	if c1 != 0 {
-		Yyerror("malformed octal constant")
-	}
-	goto ncu
-
-dc:
-	if c == '.' {
-		goto casedot
-	}
-	if c == 'e' || c == 'E' || c == 'p' || c == 'P' {
-		goto caseep
-	}
-	if c == 'i' {
-		goto casei
-	}
-
 ncu:
 	cp = nil
 	ungetc(c)
@@ -1523,31 +1517,90 @@
  */
 func getlinepragma() int {
 	var cmd, verb, name string
-	var n int
-	var cp *bytes.Buffer
-	var linep int
 
 	c := int(getr())
 	if c == 'g' {
-		goto go_
+		cp := &lexbuf
+		cp.Reset()
+		cp.WriteByte('g') // already read
+		for {
+			c = int(getr())
+			if c == EOF || c >= utf8.RuneSelf {
+				return c
+			}
+			if c == '\n' {
+				break
+			}
+			cp.WriteByte(byte(c))
+		}
+
+		cp = nil
+
+		if strings.HasPrefix(lexbuf.String(), "go:cgo_") {
+			pragcgo(lexbuf.String())
+		}
+
+		cmd = lexbuf.String()
+		verb = cmd
+		if i := strings.Index(verb, " "); i >= 0 {
+			verb = verb[:i]
+		}
+
+		if verb == "go:linkname" {
+			if imported_unsafe == 0 {
+				Yyerror("//go:linkname only allowed in Go files that import \"unsafe\"")
+			}
+			f := strings.Fields(cmd)
+			if len(f) != 3 {
+				Yyerror("usage: //go:linkname localname linkname")
+				return c
+			}
+
+			Lookup(f[1]).Linkname = f[2]
+			return c
+		}
+
+		if verb == "go:nointerface" && obj.Fieldtrack_enabled != 0 {
+			nointerface = true
+			return c
+		}
+
+		if verb == "go:noescape" {
+			noescape = true
+			return c
+		}
+
+		if verb == "go:nosplit" {
+			nosplit = true
+			return c
+		}
+
+		if verb == "go:nowritebarrier" {
+			if compiling_runtime == 0 {
+				Yyerror("//go:nowritebarrier only allowed in runtime")
+			}
+			nowritebarrier = true
+			return c
+		}
+		return c
 	}
 	if c != 'l' {
-		goto out
+		return c
 	}
 	for i := 1; i < 5; i++ {
 		c = int(getr())
 		if c != int("line "[i]) {
-			goto out
+			return c
 		}
 	}
 
-	cp = &lexbuf
+	cp := &lexbuf
 	cp.Reset()
-	linep = 0
+	linep := 0
 	for {
 		c = int(getr())
 		if c == EOF {
-			goto out
+			return c
 		}
 		if c == '\n' {
 			break
@@ -1564,9 +1617,9 @@
 	cp = nil
 
 	if linep == 0 {
-		goto out
+		return c
 	}
-	n = 0
+	n := 0
 	for _, c := range lexbuf.String()[linep:] {
 		if c < '0' || c > '9' {
 			goto out
@@ -1579,7 +1632,7 @@
 	}
 
 	if n <= 0 {
-		goto out
+		return c
 	}
 
 	// try to avoid allocating file name over and over
@@ -1587,76 +1640,12 @@
 	for h := Ctxt.Hist; h != nil; h = h.Link {
 		if h.Name != "" && h.Name == name {
 			linehist(h.Name, int32(n), 0)
-			goto out
+			return c
 		}
 	}
 
 	linehist(name, int32(n), 0)
-	goto out
-
-go_:
-	cp = &lexbuf
-	cp.Reset()
-	cp.WriteByte('g') // already read
-	for {
-		c = int(getr())
-		if c == EOF || c >= utf8.RuneSelf {
-			goto out
-		}
-		if c == '\n' {
-			break
-		}
-		cp.WriteByte(byte(c))
-	}
-
-	cp = nil
-
-	if strings.HasPrefix(lexbuf.String(), "go:cgo_") {
-		pragcgo(lexbuf.String())
-	}
-
-	cmd = lexbuf.String()
-	verb = cmd
-	if i := strings.Index(verb, " "); i >= 0 {
-		verb = verb[:i]
-	}
-
-	if verb == "go:linkname" {
-		if imported_unsafe == 0 {
-			Yyerror("//go:linkname only allowed in Go files that import \"unsafe\"")
-		}
-		f := strings.Fields(cmd)
-		if len(f) != 3 {
-			Yyerror("usage: //go:linkname localname linkname")
-			goto out
-		}
-
-		Lookup(f[1]).Linkname = f[2]
-		goto out
-	}
-
-	if verb == "go:nointerface" && obj.Fieldtrack_enabled != 0 {
-		nointerface = true
-		goto out
-	}
-
-	if verb == "go:noescape" {
-		noescape = true
-		goto out
-	}
-
-	if verb == "go:nosplit" {
-		nosplit = true
-		goto out
-	}
-
-	if verb == "go:nowritebarrier" {
-		if compiling_runtime == 0 {
-			Yyerror("//go:nowritebarrier only allowed in runtime")
-		}
-		nowritebarrier = true
-		goto out
-	}
+	return c
 
 out:
 	return c
@@ -1708,14 +1697,12 @@
 		var p string
 		p, ok = getquoted(&q)
 		if !ok {
-			goto err1
+			Yyerror("usage: //go:cgo_dynamic_linker \"path\"")
+			return
 		}
 		pragcgobuf += fmt.Sprintf("cgo_dynamic_linker %v\n", plan9quote(p))
-		goto out
+		return
 
-	err1:
-		Yyerror("usage: //go:cgo_dynamic_linker \"path\"")
-		goto out
 	}
 
 	if verb == "dynexport" {
@@ -1729,7 +1716,7 @@
 		}
 		if !more(&q) {
 			pragcgobuf += fmt.Sprintf("%s %v\n", verb, plan9quote(local))
-			goto out
+			return
 		}
 
 		remote = getimpsym(&q)
@@ -1737,11 +1724,11 @@
 			goto err2
 		}
 		pragcgobuf += fmt.Sprintf("%s %v %v\n", verb, plan9quote(local), plan9quote(remote))
-		goto out
+		return
 
 	err2:
 		Yyerror("usage: //go:%s local [remote]", verb)
-		goto out
+		return
 	}
 
 	if verb == "cgo_import_dynamic" || verb == "dynimport" {
@@ -1754,7 +1741,7 @@
 		}
 		if !more(&q) {
 			pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v\n", plan9quote(local))
-			goto out
+			return
 		}
 
 		remote = getimpsym(&q)
@@ -1763,7 +1750,7 @@
 		}
 		if !more(&q) {
 			pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v %v\n", plan9quote(local), plan9quote(remote))
-			goto out
+			return
 		}
 
 		p, ok = getquoted(&q)
@@ -1771,24 +1758,22 @@
 			goto err3
 		}
 		pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v %v %v\n", plan9quote(local), plan9quote(remote), plan9quote(p))
-		goto out
+		return
 
 	err3:
 		Yyerror("usage: //go:cgo_import_dynamic local [remote [\"library\"]]")
-		goto out
+		return
 	}
 
 	if verb == "cgo_import_static" {
 		local := getimpsym(&q)
 		if local == "" || more(&q) {
-			goto err4
+			Yyerror("usage: //go:cgo_import_static local")
+			return
 		}
 		pragcgobuf += fmt.Sprintf("cgo_import_static %v\n", plan9quote(local))
-		goto out
+		return
 
-	err4:
-		Yyerror("usage: //go:cgo_import_static local")
-		goto out
 	}
 
 	if verb == "cgo_ldflag" {
@@ -1796,17 +1781,13 @@
 		var p string
 		p, ok = getquoted(&q)
 		if !ok {
-			goto err5
+			Yyerror("usage: //go:cgo_ldflag \"arg\"")
+			return
 		}
 		pragcgobuf += fmt.Sprintf("cgo_ldflag %v\n", plan9quote(p))
-		goto out
+		return
 
-	err5:
-		Yyerror("usage: //go:cgo_ldflag \"arg\"")
-		goto out
 	}
-
-out:
 }
 
 type yy struct{}
@@ -1983,7 +1964,6 @@
 
 	u := 0
 	c = int(getr())
-	var l int64
 	var i int
 	switch c {
 	case 'x':
@@ -2010,7 +1990,24 @@
 		'6',
 		'7':
 		*escflg = 1 // it's a byte
-		goto oct
+		l := int64(c) - '0'
+		for i := 2; i > 0; i-- {
+			c = getc()
+			if c >= '0' && c <= '7' {
+				l = l*8 + int64(c) - '0'
+				continue
+			}
+
+			Yyerror("non-octal character in escape sequence: %c", c)
+			ungetc(c)
+		}
+
+		if l > 255 {
+			Yyerror("octal escape value > 255: %d", l)
+		}
+
+		*val = l
+		return false
 
 	case 'a':
 		c = '\a'
@@ -2039,7 +2036,7 @@
 	return false
 
 hex:
-	l = 0
+	l := int64(0)
 	for ; i > 0; i-- {
 		c = getc()
 		if c >= '0' && c <= '9' {
@@ -2069,26 +2066,6 @@
 
 	*val = l
 	return false
-
-oct:
-	l = int64(c) - '0'
-	for i := 2; i > 0; i-- {
-		c = getc()
-		if c >= '0' && c <= '7' {
-			l = l*8 + int64(c) - '0'
-			continue
-		}
-
-		Yyerror("non-octal character in escape sequence: %c", c)
-		ungetc(c)
-	}
-
-	if l > 255 {
-		Yyerror("octal escape value > 255: %d", l)
-	}
-
-	*val = l
-	return false
 }
 
 var syms = []struct {
diff --git a/src/cmd/internal/gc/mparith1.go b/src/cmd/internal/gc/mparith1.go
index 104992f..d728d6a 100644
--- a/src/cmd/internal/gc/mparith1.go
+++ b/src/cmd/internal/gc/mparith1.go
@@ -451,7 +451,6 @@
 //
 func mpatofix(a *Mpint, as string) {
 	var c int
-	var s0 string
 
 	s := as
 	f := 0
@@ -471,7 +470,43 @@
 		fallthrough
 
 	case '0':
-		goto oct
+		var c int
+		c, s = intstarstringplusplus(s)
+		if c == 'x' || c == 'X' {
+			s0 := s
+			var c int
+			c, _ = intstarstringplusplus(s)
+			for c != 0 {
+				if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {
+					s = s[1:]
+					c, _ = intstarstringplusplus(s)
+					continue
+				}
+
+				Yyerror("malformed hex constant: %s", as)
+				goto bad
+			}
+
+			mphextofix(a, s0)
+			if a.Ovf != 0 {
+				Yyerror("constant too large: %s", as)
+				goto bad
+			}
+			goto out
+		}
+		for c != 0 {
+			if c >= '0' && c <= '7' {
+				mpmulcfix(a, 8)
+				mpaddcfix(a, int64(c)-'0')
+				c, s = intstarstringplusplus(s)
+				continue
+			}
+
+			Yyerror("malformed octal constant: %s", as)
+			goto bad
+		}
+
+		goto out
 	}
 
 	for c != 0 {
@@ -488,45 +523,6 @@
 
 	goto out
 
-oct:
-	c, s = intstarstringplusplus(s)
-	if c == 'x' || c == 'X' {
-		goto hex
-	}
-	for c != 0 {
-		if c >= '0' && c <= '7' {
-			mpmulcfix(a, 8)
-			mpaddcfix(a, int64(c)-'0')
-			c, s = intstarstringplusplus(s)
-			continue
-		}
-
-		Yyerror("malformed octal constant: %s", as)
-		goto bad
-	}
-
-	goto out
-
-hex:
-	s0 = s
-	c, _ = intstarstringplusplus(s)
-	for c != 0 {
-		if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {
-			s = s[1:]
-			c, _ = intstarstringplusplus(s)
-			continue
-		}
-
-		Yyerror("malformed hex constant: %s", as)
-		goto bad
-	}
-
-	mphextofix(a, s0)
-	if a.Ovf != 0 {
-		Yyerror("constant too large: %s", as)
-		goto bad
-	}
-
 out:
 	if f != 0 {
 		mpnegfix(a)
diff --git a/src/cmd/internal/gc/mparith2.go b/src/cmd/internal/gc/mparith2.go
index c9c9230..7e12913 100644
--- a/src/cmd/internal/gc/mparith2.go
+++ b/src/cmd/internal/gc/mparith2.go
@@ -187,12 +187,44 @@
 	}
 
 	c := 0
-	var x int
 	if a.Neg != b.Neg {
-		goto sub
+		// perform a-b
+		switch mpcmp(a, b) {
+		case 0:
+			Mpmovecfix(a, 0)
+
+		case 1:
+			var x int
+			for i := 0; i < Mpprec; i++ {
+				x = a.A[i] - b.A[i] - c
+				c = 0
+				if x < 0 {
+					x += Mpbase
+					c = 1
+				}
+
+				a.A[i] = x
+			}
+
+		case -1:
+			a.Neg ^= 1
+			var x int
+			for i := 0; i < Mpprec; i++ {
+				x = b.A[i] - a.A[i] - c
+				c = 0
+				if x < 0 {
+					x += Mpbase
+					c = 1
+				}
+
+				a.A[i] = x
+			}
+		}
+		return
 	}
 
 	// perform a+b
+	var x int
 	for i := 0; i < Mpprec; i++ {
 		x = a.A[i] + b.A[i] + c
 		c = 0
@@ -210,40 +242,6 @@
 	}
 
 	return
-
-	// perform a-b
-sub:
-	switch mpcmp(a, b) {
-	case 0:
-		Mpmovecfix(a, 0)
-
-	case 1:
-		var x int
-		for i := 0; i < Mpprec; i++ {
-			x = a.A[i] - b.A[i] - c
-			c = 0
-			if x < 0 {
-				x += Mpbase
-				c = 1
-			}
-
-			a.A[i] = x
-		}
-
-	case -1:
-		a.Neg ^= 1
-		var x int
-		for i := 0; i < Mpprec; i++ {
-			x = b.A[i] - a.A[i] - c
-			c = 0
-			if x < 0 {
-				x += Mpbase
-				c = 1
-			}
-
-			a.A[i] = x
-		}
-	}
 }
 
 func mpmulfixfix(a *Mpint, b *Mpint) {
diff --git a/src/cmd/internal/gc/plive.go b/src/cmd/internal/gc/plive.go
index 86e7ea0..e6211e1 100644
--- a/src/cmd/internal/gc/plive.go
+++ b/src/cmd/internal/gc/plive.go
@@ -657,7 +657,7 @@
 				PPARAMOUT:
 				pos, ok := to.Node.(*Node).Opt.(int32) // index in vars
 				if !ok {
-					goto Next1
+					return
 				}
 				if pos >= int32(len(vars)) || vars[pos] != to.Node {
 					Fatal("bad bookkeeping in liveness %v %d", Nconv(to.Node.(*Node), 0), pos)
@@ -690,8 +690,6 @@
 			}
 		}
 	}
-
-Next1:
 }
 
 // Constructs a new liveness structure used to hold the global state of the
diff --git a/src/cmd/internal/gc/reg.go b/src/cmd/internal/gc/reg.go
index 5f9586b..e051c25 100644
--- a/src/cmd/internal/gc/reg.go
+++ b/src/cmd/internal/gc/reg.go
@@ -185,32 +185,22 @@
 }
 
 func mkvar(f *Flow, a *obj.Addr) Bits {
-	var v *Var
-	var i int
-	var n int
-	var et int
-	var flag int
-	var w int64
-	var o int64
-	var bit Bits
-	var node *Node
-	var r *Reg
-
 	/*
 	 * mark registers used
 	 */
 	if a.Type == obj.TYPE_NONE {
-		goto none
+		return zbits
 	}
 
-	r = f.Data.(*Reg)
+	r := f.Data.(*Reg)
 	r.use1.b[0] |= Thearch.Doregbits(int(a.Index)) // TODO: Use RtoB
 
+	var n int
 	switch a.Type {
 	default:
 		regu := Thearch.Doregbits(int(a.Reg)) | Thearch.RtoB(int(a.Reg)) // TODO: Use RtoB
 		if regu == 0 {
-			goto none
+			return zbits
 		}
 		bit := zbits
 		bit.b[0] = regu
@@ -227,7 +217,7 @@
 		setaddrs(bit)
 		a.Type = obj.TYPE_ADDR
 		Ostats.Naddr++
-		goto none
+		return zbits
 
 	memcase:
 		fallthrough
@@ -243,7 +233,7 @@
 		*/
 		switch a.Name {
 		default:
-			goto none
+			return zbits
 
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC,
@@ -253,25 +243,27 @@
 		}
 	}
 
+	var node *Node
 	node, _ = a.Node.(*Node)
 	if node == nil || node.Op != ONAME || node.Orig == nil {
-		goto none
+		return zbits
 	}
 	node = node.Orig
 	if node.Orig != node {
 		Fatal("%v: bad node", Ctxt.Dconv(a))
 	}
 	if node.Sym == nil || node.Sym.Name[0] == '.' {
-		goto none
+		return zbits
 	}
-	et = int(a.Etype)
-	o = a.Offset
-	w = a.Width
+	et := int(a.Etype)
+	o := a.Offset
+	w := a.Width
 	if w < 0 {
 		Fatal("bad width %d for %v", w, Ctxt.Dconv(a))
 	}
 
-	flag = 0
+	flag := 0
+	var v *Var
 	for i := 0; i < nvar; i++ {
 		v = &var_[i:][0]
 		if v.node == node && int(v.name) == n {
@@ -299,7 +291,7 @@
 	switch et {
 	case 0,
 		TFUNC:
-		goto none
+		return zbits
 	}
 
 	if nvar >= NVAR {
@@ -319,10 +311,10 @@
 			}
 		}
 
-		goto none
+		return zbits
 	}
 
-	i = nvar
+	i := nvar
 	nvar++
 	v = &var_[i:][0]
 	v.id = i
@@ -341,7 +333,7 @@
 
 	node.Opt = v
 
-	bit = blsh(uint(i))
+	bit := blsh(uint(i))
 	if n == obj.NAME_EXTERN || n == obj.NAME_STATIC {
 		for z := 0; z < BITS; z++ {
 			externs.b[z] |= bit.b[z]
@@ -401,9 +393,6 @@
 	Ostats.Nvar++
 
 	return bit
-
-none:
-	return zbits
 }
 
 func prop(f *Flow, ref Bits, cal Bits) {
diff --git a/src/cmd/internal/gc/sinit.go b/src/cmd/internal/gc/sinit.go
index ca8db418..4cb2dd6 100644
--- a/src/cmd/internal/gc/sinit.go
+++ b/src/cmd/internal/gc/sinit.go
@@ -533,21 +533,18 @@
 
 func simplename(n *Node) bool {
 	if n.Op != ONAME {
-		goto no
+		return false
 	}
 	if n.Addable == 0 {
-		goto no
+		return false
 	}
 	if n.Class&PHEAP != 0 {
-		goto no
+		return false
 	}
 	if n.Class == PPARAMREF {
-		goto no
+		return false
 	}
 	return true
-
-no:
-	return false
 }
 
 func litas(l *Node, r *Node, init **NodeList) {
@@ -1191,48 +1188,48 @@
 }
 
 func oaslit(n *Node, init **NodeList) bool {
-	var ctxt int
-
 	if n.Left == nil || n.Right == nil {
-		goto no
+		// not a special composit literal assignment
+		return false
 	}
 	if n.Left.Type == nil || n.Right.Type == nil {
-		goto no
+		// not a special composit literal assignment
+		return false
 	}
 	if !simplename(n.Left) {
-		goto no
+		// not a special composit literal assignment
+		return false
 	}
 	if !Eqtype(n.Left.Type, n.Right.Type) {
-		goto no
+		// not a special composit literal assignment
+		return false
 	}
 
 	// context is init() function.
 	// implies generated data executed
 	// exactly once and not subject to races.
-	ctxt = 0
+	ctxt := 0
 
 	//	if(n->dodata == 1)
 	//		ctxt = 1;
 
 	switch n.Right.Op {
 	default:
-		goto no
+		// not a special composit literal assignment
+		return false
 
 	case OSTRUCTLIT,
 		OARRAYLIT,
 		OMAPLIT:
 		if vmatch1(n.Left, n.Right) {
-			goto no
+			// not a special composit literal assignment
+			return false
 		}
 		anylit(ctxt, n.Right, n.Left, init)
 	}
 
 	n.Op = OEMPTY
 	return true
-
-	// not a special composit literal assignment
-no:
-	return false
 }
 
 func getlit(lit *Node) int {
@@ -1244,7 +1241,7 @@
 
 func stataddr(nam *Node, n *Node) bool {
 	if n == nil {
-		goto no
+		return false
 	}
 
 	switch n.Op {
@@ -1281,7 +1278,6 @@
 		return true
 	}
 
-no:
 	return false
 }
 
@@ -1420,7 +1416,6 @@
 	var nr *Node
 	var nl *Node
 	var nam Node
-	var nod1 Node
 
 	if n.Dodata == 0 {
 		goto no
@@ -1436,7 +1431,7 @@
 		if nam.Class != PEXTERN {
 			goto no
 		}
-		goto yes
+		return true
 	}
 
 	if nr.Type == nil || !Eqtype(nl.Type, nr.Type) {
@@ -1466,7 +1461,33 @@
 	case OSLICEARR:
 		if nr.Right.Op == OKEY && nr.Right.Left == nil && nr.Right.Right == nil {
 			nr = nr.Left
-			goto slice
+			gused(nil) // in case the data is the dest of a goto
+			nl := nr
+			if nr == nil || nr.Op != OADDR {
+				goto no
+			}
+			nr = nr.Left
+			if nr == nil || nr.Op != ONAME {
+				goto no
+			}
+
+			// nr is the array being converted to a slice
+			if nr.Type == nil || nr.Type.Etype != TARRAY || nr.Type.Bound < 0 {
+				goto no
+			}
+
+			nam.Xoffset += int64(Array_array)
+			gdata(&nam, nl, int(Types[Tptr].Width))
+
+			nam.Xoffset += int64(Array_nel) - int64(Array_array)
+			var nod1 Node
+			Nodconst(&nod1, Types[TINT], nr.Type.Bound)
+			gdata(&nam, &nod1, Widthint)
+
+			nam.Xoffset += int64(Array_cap) - int64(Array_nel)
+			gdata(&nam, &nod1, Widthint)
+
+			return true
 		}
 
 		goto no
@@ -1505,37 +1526,8 @@
 		gdatastring(&nam, nr.Val.U.Sval)
 	}
 
-yes:
 	return true
 
-slice:
-	gused(nil) // in case the data is the dest of a goto
-	nl = nr
-	if nr == nil || nr.Op != OADDR {
-		goto no
-	}
-	nr = nr.Left
-	if nr == nil || nr.Op != ONAME {
-		goto no
-	}
-
-	// nr is the array being converted to a slice
-	if nr.Type == nil || nr.Type.Etype != TARRAY || nr.Type.Bound < 0 {
-		goto no
-	}
-
-	nam.Xoffset += int64(Array_array)
-	gdata(&nam, nl, int(Types[Tptr].Width))
-
-	nam.Xoffset += int64(Array_nel) - int64(Array_array)
-	Nodconst(&nod1, Types[TINT], nr.Type.Bound)
-	gdata(&nam, &nod1, Widthint)
-
-	nam.Xoffset += int64(Array_cap) - int64(Array_nel)
-	gdata(&nam, &nod1, Widthint)
-
-	goto yes
-
 no:
 	if n.Dodata == 2 {
 		Dump("\ngen_as_init", n)
diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go
index 1c59e59..c8eb1d6 100644
--- a/src/cmd/internal/gc/subr.go
+++ b/src/cmd/internal/gc/subr.go
@@ -1014,14 +1014,14 @@
 				Fatal("struct/interface missing field: %v %v", Tconv(t1, 0), Tconv(t2, 0))
 			}
 			if t1.Sym != t2.Sym || t1.Embedded != t2.Embedded || !eqtype1(t1.Type, t2.Type, &l) || !eqnote(t1.Note, t2.Note) {
-				goto no
+				return false
 			}
 		}
 
 		if t1 == nil && t2 == nil {
-			goto yes
+			return true
 		}
-		goto no
+		return false
 
 		// Loop over structs: receiver, in, out.
 	case TFUNC:
@@ -1043,40 +1043,34 @@
 					Fatal("func struct missing field: %v %v", Tconv(ta, 0), Tconv(tb, 0))
 				}
 				if ta.Isddd != tb.Isddd || !eqtype1(ta.Type, tb.Type, &l) {
-					goto no
+					return false
 				}
 			}
 
 			if ta != nil || tb != nil {
-				goto no
+				return false
 			}
 		}
 
 		if t1 == nil && t2 == nil {
-			goto yes
+			return true
 		}
-		goto no
+		return false
 
 	case TARRAY:
 		if t1.Bound != t2.Bound {
-			goto no
+			return false
 		}
 
 	case TCHAN:
 		if t1.Chan != t2.Chan {
-			goto no
+			return false
 		}
 	}
 
 	if eqtype1(t1.Down, t2.Down, &l) && eqtype1(t1.Type, t2.Type, &l) {
-		goto yes
+		return true
 	}
-	goto no
-
-yes:
-	return true
-
-no:
 	return false
 }
 
@@ -1376,10 +1370,8 @@
 }
 
 func subtype(stp **Type, t *Type, d int) bool {
-	var st *Type
-
 loop:
-	st = *stp
+	st := *stp
 	if st == nil {
 		return false
 	}
@@ -1762,7 +1754,7 @@
 
 	t = n.Type
 	if t == nil {
-		goto rnil
+		return nil
 	}
 
 	if t.Etype != TFIELD {
@@ -1775,7 +1767,6 @@
 bad:
 	Fatal("structfirst: not struct %v", Tconv(n, 0))
 
-rnil:
 	return nil
 }
 
@@ -1783,21 +1774,17 @@
 	n := s.T
 	t := n.Down
 	if t == nil {
-		goto rnil
+		return nil
 	}
 
 	if t.Etype != TFIELD {
-		goto bad
+		Fatal("structnext: not struct %v", Tconv(n, 0))
+
+		return nil
 	}
 
 	s.T = t
 	return t
-
-bad:
-	Fatal("structnext: not struct %v", Tconv(n, 0))
-
-rnil:
-	return nil
 }
 
 /*
@@ -2135,54 +2122,47 @@
 // will give shortest unique addressing.
 // modify the tree with missing type names.
 func adddot(n *Node) *Node {
-	var s *Sym
-	var c int
-	var d int
-
 	typecheck(&n.Left, Etype|Erv)
 	n.Diag |= n.Left.Diag
 	t := n.Left.Type
 	if t == nil {
-		goto ret
-	}
-
-	if n.Left.Op == OTYPE {
-		goto ret
-	}
-
-	if n.Right.Op != ONAME {
-		goto ret
-	}
-	s = n.Right.Sym
-	if s == nil {
-		goto ret
-	}
-
-	for d = 0; d < len(dotlist); d++ {
-		c = adddot1(s, t, d, nil, 0)
-		if c > 0 {
-			goto out
-		}
-	}
-
-	goto ret
-
-out:
-	if c > 1 {
-		Yyerror("ambiguous selector %v", Nconv(n, 0))
-		n.Left = nil
 		return n
 	}
 
-	// rebuild elided dots
-	for c := d - 1; c >= 0; c-- {
-		if n.Left.Type != nil && Isptr[n.Left.Type.Etype] != 0 {
-			n.Left.Implicit = 1
-		}
-		n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym))
+	if n.Left.Op == OTYPE {
+		return n
 	}
 
-ret:
+	if n.Right.Op != ONAME {
+		return n
+	}
+	s := n.Right.Sym
+	if s == nil {
+		return n
+	}
+
+	var c int
+	for d := 0; d < len(dotlist); d++ {
+		c = adddot1(s, t, d, nil, 0)
+		if c > 0 {
+			if c > 1 {
+				Yyerror("ambiguous selector %v", Nconv(n, 0))
+				n.Left = nil
+				return n
+			}
+
+			// rebuild elided dots
+			for c := d - 1; c >= 0; c-- {
+				if n.Left.Type != nil && Isptr[n.Left.Type.Etype] != 0 {
+					n.Left.Implicit = 1
+				}
+				n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym))
+			}
+
+			return n
+		}
+	}
+
 	return n
 }
 
@@ -3301,18 +3281,15 @@
  * 1000+ if it is a -(power of 2)
  */
 func powtwo(n *Node) int {
-	var v uint64
-	var b uint64
-
 	if n == nil || n.Op != OLITERAL || n.Type == nil {
-		goto no
+		return -1
 	}
 	if Isint[n.Type.Etype] == 0 {
-		goto no
+		return -1
 	}
 
-	v = uint64(Mpgetfix(n.Val.U.Xval))
-	b = 1
+	v := uint64(Mpgetfix(n.Val.U.Xval))
+	b := uint64(1)
 	for i := 0; i < 64; i++ {
 		if b == v {
 			return i
@@ -3321,7 +3298,7 @@
 	}
 
 	if Issigned[n.Type.Etype] == 0 {
-		goto no
+		return -1
 	}
 
 	v = -v
@@ -3333,7 +3310,6 @@
 		b = b << 1
 	}
 
-no:
 	return -1
 }
 
@@ -3592,22 +3568,19 @@
 	for i := 0; i < len(s); i++ {
 		c := s[i]
 		if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
-			goto escape
+			var buf bytes.Buffer
+			for i := 0; i < len(s); i++ {
+				c := s[i]
+				if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
+					fmt.Fprintf(&buf, "%%%02x", c)
+					continue
+				}
+				buf.WriteByte(c)
+			}
+			return buf.String()
 		}
 	}
 	return s
-
-escape:
-	var buf bytes.Buffer
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
-			fmt.Fprintf(&buf, "%%%02x", c)
-			continue
-		}
-		buf.WriteByte(c)
-	}
-	return buf.String()
 }
 
 func mkpkg(path_ *Strlit) *Pkg {
diff --git a/src/cmd/internal/gc/typecheck.go b/src/cmd/internal/gc/typecheck.go
index 1468d5f..cb0111e 100644
--- a/src/cmd/internal/gc/typecheck.go
+++ b/src/cmd/internal/gc/typecheck.go
@@ -1805,7 +1805,25 @@
 
 arith:
 	if op == OLSH || op == ORSH {
-		goto shift
+		defaultlit(&r, Types[TUINT])
+		n.Right = r
+		t := r.Type
+		if Isint[t.Etype] == 0 || Issigned[t.Etype] != 0 {
+			Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
+			goto error
+		}
+
+		t = l.Type
+		if t != nil && t.Etype != TIDEAL && Isint[t.Etype] == 0 {
+			Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
+			goto error
+		}
+
+		// no defaultlit for left
+		// the outer context gives the type
+		n.Type = l.Type
+
+		goto ret
 	}
 
 	// ideal mixed with non-ideal
@@ -1993,27 +2011,6 @@
 	n.Type = t
 	goto ret
 
-shift:
-	defaultlit(&r, Types[TUINT])
-	n.Right = r
-	t = r.Type
-	if Isint[t.Etype] == 0 || Issigned[t.Etype] != 0 {
-		Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
-		goto error
-	}
-
-	t = l.Type
-	if t != nil && t.Etype != TIDEAL && Isint[t.Etype] == 0 {
-		Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
-		goto error
-	}
-
-	// no defaultlit for left
-	// the outer context gives the type
-	n.Type = l.Type
-
-	goto ret
-
 doconv:
 	ok |= Erv
 	saveorignode(n)
diff --git a/src/cmd/internal/gc/unsafe.go b/src/cmd/internal/gc/unsafe.go
index 7f0a33f..6faed49 100644
--- a/src/cmd/internal/gc/unsafe.go
+++ b/src/cmd/internal/gc/unsafe.go
@@ -14,31 +14,28 @@
  * rewrite with a constant
  */
 func unsafenmagic(nn *Node) *Node {
-	var r *Node
-	var s *Sym
-	var v int64
-
 	fn := nn.Left
 	args := nn.List
 
 	if safemode != 0 || fn == nil || fn.Op != ONAME {
-		goto no
+		return nil
 	}
-	s = fn.Sym
+	s := fn.Sym
 	if s == nil {
-		goto no
+		return nil
 	}
 	if s.Pkg != unsafepkg {
-		goto no
+		return nil
 	}
 
 	if args == nil {
 		Yyerror("missing argument for %v", Sconv(s, 0))
-		goto no
+		return nil
 	}
 
-	r = args.N
+	r := args.N
 
+	var v int64
 	if s.Name == "Sizeof" {
 		typecheck(&r, Erv)
 		defaultlit(&r, nil)
@@ -127,7 +124,6 @@
 		goto yes
 	}
 
-no:
 	return nil
 
 bad:
diff --git a/src/cmd/internal/gc/util.go b/src/cmd/internal/gc/util.go
index df68d50..c3f7db2 100644
--- a/src/cmd/internal/gc/util.go
+++ b/src/cmd/internal/gc/util.go
@@ -39,17 +39,14 @@
 
 func plan9quote(s string) string {
 	if s == "" {
-		goto needquote
+		return "'" + strings.Replace(s, "'", "''", -1) + "'"
 	}
 	for i := 0; i < len(s); i++ {
 		if s[i] <= ' ' || s[i] == '\'' {
-			goto needquote
+			return "'" + strings.Replace(s, "'", "''", -1) + "'"
 		}
 	}
 	return s
-
-needquote:
-	return "'" + strings.Replace(s, "'", "''", -1) + "'"
 }
 
 // simulation of int(*s++) in C
diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go
index c57bdd6..4667494 100644
--- a/src/cmd/internal/gc/walk.go
+++ b/src/cmd/internal/gc/walk.go
@@ -3653,7 +3653,23 @@
 		if sl >= 0 {
 			sr := int(Mpgetfix(r.Right.Val.U.Xval))
 			if sr >= 0 && sl+sr == w {
-				goto yes
+				// Rewrite left shift half to left rotate.
+				if l.Op == OLSH {
+					n = l
+				} else {
+					n = r
+				}
+				n.Op = OLROT
+
+				// Remove rotate 0 and rotate w.
+				s := int(Mpgetfix(n.Right.Val.U.Xval))
+
+				if s == 0 || s == w {
+					n = n.Left
+				}
+
+				*np = n
+				return
 			}
 		}
 		return
@@ -3661,25 +3677,6 @@
 
 	// TODO: Could allow s and 32-s if s is bounded (maybe s&31 and 32-s&31).
 	return
-
-	// Rewrite left shift half to left rotate.
-yes:
-	if l.Op == OLSH {
-		n = l
-	} else {
-		n = r
-	}
-	n.Op = OLROT
-
-	// Remove rotate 0 and rotate w.
-	s := int(Mpgetfix(n.Right.Val.U.Xval))
-
-	if s == 0 || s == w {
-		n = n.Left
-	}
-
-	*np = n
-	return
 }
 
 /*
@@ -3793,11 +3790,124 @@
 		return
 	}
 
-	var n1 *Node
-	var m Magic
-	var n2 *Node
 	if pow < 0 {
-		goto divbymul
+		// try to do division by multiply by (2^w)/d
+		// see hacker's delight chapter 10
+		// TODO: support 64-bit magic multiply here.
+		var m Magic
+		m.W = w
+
+		if Issigned[nl.Type.Etype] != 0 {
+			m.Sd = Mpgetfix(nr.Val.U.Xval)
+			Smagic(&m)
+		} else {
+			m.Ud = uint64(Mpgetfix(nr.Val.U.Xval))
+			Umagic(&m)
+		}
+
+		if m.Bad != 0 {
+			return
+		}
+
+		// We have a quick division method so use it
+		// for modulo too.
+		if n.Op == OMOD {
+			// rewrite as A%B = A - (A/B*B).
+			n1 := Nod(ODIV, nl, nr)
+
+			n2 := Nod(OMUL, n1, nr)
+			n = Nod(OSUB, nl, n2)
+			goto ret
+		}
+
+		switch Simtype[nl.Type.Etype] {
+		default:
+			return
+
+			// n1 = nl * magic >> w (HMUL)
+		case TUINT8,
+			TUINT16,
+			TUINT32:
+			nc := Nod(OXXX, nil, nil)
+
+			Nodconst(nc, nl.Type, int64(m.Um))
+			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
+
+				case TUINT8,
+					TUINT16:
+					twide = Types[TUINT32]
+
+				case TUINT32:
+					twide = Types[TUINT64]
+
+				case TINT8,
+					TINT16:
+					twide = Types[TINT32]
+
+				case TINT32:
+					twide = Types[TINT64]
+				}
+
+				// add numerator (might overflow).
+				// n2 = (n1 + nl)
+				n2 := Nod(OADD, conv(n1, twide), conv(nl, twide))
+
+				// shift by m.s
+				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)
+
+				Nodconst(nc, Types[TUINT], int64(m.S))
+				n = Nod(ORSH, n1, nc)
+			}
+
+			// n1 = nl * magic >> w
+		case TINT8,
+			TINT16,
+			TINT32:
+			nc := Nod(OXXX, nil, nil)
+
+			Nodconst(nc, nl.Type, m.Sm)
+			n1 := Nod(OMUL, nl, nc)
+			typecheck(&n1, Erv)
+			n1.Op = OHMUL
+			if m.Sm < 0 {
+				// add the numerator.
+				n1 = Nod(OADD, n1, nl)
+			}
+
+			// shift by m.s
+			nc = Nod(OXXX, nil, nil)
+
+			Nodconst(nc, Types[TUINT], int64(m.S))
+			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.
+			n = Nod(OSUB, n2, n3)
+
+			// apply sign.
+			if m.Sd < 0 {
+				n = Nod(OMINUS, n, nil)
+			}
+		}
+
+		goto ret
 	}
 
 	switch pow {
@@ -3905,127 +4015,6 @@
 
 	goto ret
 
-	// try to do division by multiply by (2^w)/d
-	// see hacker's delight chapter 10
-	// TODO: support 64-bit magic multiply here.
-divbymul:
-	m.W = w
-
-	if Issigned[nl.Type.Etype] != 0 {
-		m.Sd = Mpgetfix(nr.Val.U.Xval)
-		Smagic(&m)
-	} else {
-		m.Ud = uint64(Mpgetfix(nr.Val.U.Xval))
-		Umagic(&m)
-	}
-
-	if m.Bad != 0 {
-		return
-	}
-
-	// We have a quick division method so use it
-	// for modulo too.
-	if n.Op == OMOD {
-		goto longmod
-	}
-
-	switch Simtype[nl.Type.Etype] {
-	default:
-		return
-
-		// n1 = nl * magic >> w (HMUL)
-	case TUINT8,
-		TUINT16,
-		TUINT32:
-		nc := Nod(OXXX, nil, nil)
-
-		Nodconst(nc, nl.Type, int64(m.Um))
-		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
-
-			case TUINT8,
-				TUINT16:
-				twide = Types[TUINT32]
-
-			case TUINT32:
-				twide = Types[TUINT64]
-
-			case TINT8,
-				TINT16:
-				twide = Types[TINT32]
-
-			case TINT32:
-				twide = Types[TINT64]
-			}
-
-			// add numerator (might overflow).
-			// n2 = (n1 + nl)
-			n2 := Nod(OADD, conv(n1, twide), conv(nl, twide))
-
-			// shift by m.s
-			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)
-
-			Nodconst(nc, Types[TUINT], int64(m.S))
-			n = Nod(ORSH, n1, nc)
-		}
-
-		// n1 = nl * magic >> w
-	case TINT8,
-		TINT16,
-		TINT32:
-		nc := Nod(OXXX, nil, nil)
-
-		Nodconst(nc, nl.Type, m.Sm)
-		n1 := Nod(OMUL, nl, nc)
-		typecheck(&n1, Erv)
-		n1.Op = OHMUL
-		if m.Sm < 0 {
-			// add the numerator.
-			n1 = Nod(OADD, n1, nl)
-		}
-
-		// shift by m.s
-		nc = Nod(OXXX, nil, nil)
-
-		Nodconst(nc, Types[TUINT], int64(m.S))
-		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.
-		n = Nod(OSUB, n2, n3)
-
-		// apply sign.
-		if m.Sd < 0 {
-			n = Nod(OMINUS, n, nil)
-		}
-	}
-
-	goto ret
-
-	// rewrite as A%B = A - (A/B*B).
-longmod:
-	n1 = Nod(ODIV, nl, nr)
-
-	n2 = Nod(OMUL, n1, nr)
-	n = Nod(OSUB, nl, n2)
-	goto ret
-
 ret:
 	typecheck(&n, Erv)
 	walkexpr(&n, init)
diff --git a/src/cmd/internal/ld/data.go b/src/cmd/internal/ld/data.go
index 381030d..369d3a4 100644
--- a/src/cmd/internal/ld/data.go
+++ b/src/cmd/internal/ld/data.go
@@ -81,9 +81,7 @@
 }
 
 func adduintxx(ctxt *Link, s *LSym, v uint64, wid int) int64 {
-	var off int64
-
-	off = s.Size
+	off := s.Size
 	setuintxx(ctxt, s, off, v, int64(wid))
 	return off
 }
@@ -113,17 +111,14 @@
 }
 
 func Addaddrplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
-	var i int64
-	var r *Reloc
-
 	if s.Type == 0 {
 		s.Type = SDATA
 	}
 	s.Reachable = true
-	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)
@@ -133,17 +128,14 @@
 }
 
 func Addpcrelplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
-	var i int64
-	var r *Reloc
-
 	if s.Type == 0 {
 		s.Type = SDATA
 	}
 	s.Reachable = true
-	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
@@ -157,8 +149,6 @@
 }
 
 func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 {
-	var r *Reloc
-
 	if s.Type == 0 {
 		s.Type = SDATA
 	}
@@ -168,7 +158,7 @@
 		Symgrow(ctxt, s, s.Size)
 	}
 
-	r = Addrel(s)
+	r := Addrel(s)
 	r.Sym = t
 	r.Off = int32(off)
 	r.Siz = uint8(ctxt.Arch.Ptrsize)
@@ -182,17 +172,14 @@
 }
 
 func addsize(ctxt *Link, s *LSym, t *LSym) int64 {
-	var i int64
-	var r *Reloc
-
 	if s.Type == 0 {
 		s.Type = SDATA
 	}
 	s.Reachable = true
-	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)
@@ -201,17 +188,14 @@
 }
 
 func addaddrplus4(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
-	var i int64
-	var r *Reloc
-
 	if s.Type == 0 {
 		s.Type = SDATA
 	}
 	s.Reachable = true
-	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
@@ -253,16 +237,12 @@
 }
 
 func listsort(l *LSym, cmp func(*LSym, *LSym) int, nextp func(*LSym) **LSym) *LSym {
-	var l1 *LSym
-	var l2 *LSym
-	var le *LSym
-
 	if l == nil || *nextp(l) == nil {
 		return l
 	}
 
-	l1 = l
-	l2 = l
+	l1 := l
+	l2 := l
 	for {
 		l2 = *nextp(l2)
 		if l2 == nil {
@@ -289,7 +269,7 @@
 		l2 = *nextp(l2)
 	}
 
-	le = l
+	le := l
 
 	for {
 		if l1 == nil {
@@ -332,14 +312,13 @@
 	var r *Reloc
 	var rs *LSym
 	var i16 int16
-	var ri int32
 	var off int32
 	var siz int32
 	var fl int32
 	var o int64
 
 	Ctxt.Cursym = s
-	for ri = 0; ri < int32(len(s.R)); ri++ {
+	for ri := int32(0); ri < int32(len(s.R)); ri++ {
 		r = &s.R[ri]
 		r.Done = 1
 		off = r.Off
@@ -591,34 +570,28 @@
 }
 
 func reloc() {
-	var s *LSym
-
 	if Debug['v'] != 0 {
 		fmt.Fprintf(&Bso, "%5.2f reloc\n", obj.Cputime())
 	}
 	Bflush(&Bso)
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		relocsym(s)
 	}
-	for s = datap; s != nil; s = s.Next {
+	for s := datap; s != nil; s = s.Next {
 		relocsym(s)
 	}
 }
 
 func dynrelocsym(s *LSym) {
-	var ri int
-	var r *Reloc
-
 	if HEADTYPE == Hwindows {
-		var rel *LSym
-		var targ *LSym
-
-		rel = Linklookup(Ctxt, ".rel", 0)
+		rel := Linklookup(Ctxt, ".rel", 0)
 		if s == rel {
 			return
 		}
-		for ri = 0; ri < len(s.R); ri++ {
+		var r *Reloc
+		var targ *LSym
+		for ri := 0; ri < len(s.R); ri++ {
 			r = &s.R[ri]
 			targ = r.Sym
 			if targ == nil {
@@ -655,7 +628,8 @@
 		return
 	}
 
-	for ri = 0; ri < len(s.R); ri++ {
+	var r *Reloc
+	for ri := 0; ri < len(s.R); ri++ {
 		r = &s.R[ri]
 		if r.Sym != nil && r.Sym.Type == SDYNIMPORT || r.Type >= 256 {
 			if r.Sym != nil && !r.Sym.Reachable {
@@ -667,8 +641,6 @@
 }
 
 func dynreloc() {
-	var s *LSym
-
 	// -d suppresses dynamic loader format, so we may as well not
 	// compute these sections or mark their symbols as reachable.
 	if Debug['d'] != 0 && HEADTYPE != Hwindows {
@@ -679,10 +651,10 @@
 	}
 	Bflush(&Bso)
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		dynrelocsym(s)
 	}
-	for s = datap; s != nil; s = s.Next {
+	for s := datap; s != nil; s = s.Next {
 		dynrelocsym(s)
 	}
 	if Iself {
@@ -692,9 +664,6 @@
 
 func blk(start *LSym, addr int64, size int64) {
 	var sym *LSym
-	var eaddr int64
-	var p []byte
-	var ep []byte
 
 	for sym = start; sym != nil; sym = sym.Next {
 		if sym.Type&SSUB == 0 && sym.Value >= addr {
@@ -702,7 +671,9 @@
 		}
 	}
 
-	eaddr = addr + size
+	eaddr := addr + size
+	var ep []byte
+	var p []byte
 	for ; sym != nil; sym = sym.Next {
 		if sym.Type&SSUB != 0 {
 			continue
@@ -746,11 +717,6 @@
 }
 
 func Codeblk(addr int64, size int64) {
-	var sym *LSym
-	var eaddr int64
-	var n int64
-	var q []byte
-
 	if Debug['a'] != 0 {
 		fmt.Fprintf(&Bso, "codeblk [%#x,%#x) at offset %#x\n", addr, addr+size, Cpos())
 	}
@@ -762,6 +728,7 @@
 		return
 	}
 
+	var sym *LSym
 	for sym = Ctxt.Textp; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -771,7 +738,9 @@
 		}
 	}
 
-	eaddr = addr + size
+	eaddr := addr + size
+	var n int64
+	var q []byte
 	for ; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -816,15 +785,6 @@
 }
 
 func Datblk(addr int64, size int64) {
-	var sym *LSym
-	var i int64
-	var eaddr int64
-	var p []byte
-	var ep []byte
-	var typ string
-	var rsname string
-	var r *Reloc
-
 	if Debug['a'] != 0 {
 		fmt.Fprintf(&Bso, "datblk [%#x,%#x) at offset %#x\n", addr, addr+size, Cpos())
 	}
@@ -836,13 +796,20 @@
 		return
 	}
 
+	var sym *LSym
 	for sym = datap; sym != nil; sym = sym.Next {
 		if sym.Value >= addr {
 			break
 		}
 	}
 
-	eaddr = addr + size
+	eaddr := addr + size
+	var ep []byte
+	var i int64
+	var p []byte
+	var r *Reloc
+	var rsname string
+	var typ string
 	for ; sym != nil; sym = sym.Next {
 		if sym.Value >= eaddr {
 			break
@@ -922,21 +889,16 @@
 }
 
 func addstrdata(name string, value string) {
-	var s *LSym
-	var sp *LSym
-	var p string
-	var reachable bool
-
-	p = fmt.Sprintf("%s.str", name)
-	sp = Linklookup(Ctxt, p, 0)
+	p := fmt.Sprintf("%s.str", name)
+	sp := Linklookup(Ctxt, p, 0)
 
 	Addstring(sp, value)
 	sp.Type = SRODATA
 
-	s = Linklookup(Ctxt, name, 0)
+	s := Linklookup(Ctxt, name, 0)
 	s.Size = 0
 	s.Dupok = 1
-	reachable = s.Reachable
+	reachable := s.Reachable
 	Addaddr(Ctxt, s, sp)
 	adduintxx(Ctxt, s, uint64(len(value)), Thearch.Ptrsize)
 
@@ -949,15 +911,12 @@
 }
 
 func Addstring(s *LSym, str string) int64 {
-	var n int
-	var r int32
-
 	if s.Type == 0 {
 		s.Type = SNOPTRDATA
 	}
 	s.Reachable = true
-	r = int32(s.Size)
-	n = len(str) + 1
+	r := int32(s.Size)
+	n := len(str) + 1
 	if s.Name == ".shstrtab" {
 		elfsetstring(str, int(r))
 	}
@@ -969,9 +928,7 @@
 }
 
 func dosymtype() {
-	var s *LSym
-
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if len(s.P) > 0 {
 			if s.Type == SBSS {
 				s.Type = SDATA
@@ -984,13 +941,11 @@
 }
 
 func symalign(s *LSym) int32 {
-	var align int32
-
 	if s.Align != 0 {
 		return s.Align
 	}
 
-	align = int32(Thearch.Maxalign)
+	align := int32(Thearch.Maxalign)
 	for int64(align) > s.Size && align > 1 {
 		align >>= 1
 	}
@@ -1008,9 +963,8 @@
 // the list of symbols s; the list stops when s->type exceeds type.
 func maxalign(s *LSym, type_ int) int32 {
 	var align int32
-	var max int32
 
-	max = 0
+	max := int32(0)
 	for ; s != nil && int(s.Type) <= type_; s = s.Next {
 		align = symalign(s)
 		if max < align {
@@ -1042,16 +996,13 @@
 
 // Writes 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
@@ -1068,9 +1019,7 @@
 
 // Skip v bytes due to alignment, etc.
 func proggenskip(g *ProgGen, off int64, v int64) {
-	var i int64
-
-	for i = off; i < off+v; i++ {
+	for i := off; i < off+v; i++ {
 		if (i % int64(Thearch.Ptrsize)) == 0 {
 			proggendata(g, obj.BitsScalar)
 		}
@@ -1101,11 +1050,6 @@
 
 // This function generates GC pointer info for global variables.
 func proggenaddsym(g *ProgGen, s *LSym) {
-	var gcprog *LSym
-	var mask []byte
-	var i int64
-	var size int64
-
 	if s.Size == 0 {
 		return
 	}
@@ -1128,10 +1072,10 @@
 		if (s.Size%int64(Thearch.Ptrsize) != 0) || (g.pos%int64(Thearch.Ptrsize) != 0) {
 			Diag("proggenaddsym: unaligned conservative symbol %s: size=%d pos=%d", s.Name, s.Size, g.pos)
 		}
-		size = (s.Size + int64(Thearch.Ptrsize) - 1) / int64(Thearch.Ptrsize) * int64(Thearch.Ptrsize)
+		size := (s.Size + int64(Thearch.Ptrsize) - 1) / int64(Thearch.Ptrsize) * int64(Thearch.Ptrsize)
 		if size < int64(32*Thearch.Ptrsize) {
 			// Emit small symbols as data.
-			for i = 0; i < size/int64(Thearch.Ptrsize); i++ {
+			for i := int64(0); i < size/int64(Thearch.Ptrsize); i++ {
 				proggendata(g, obj.BitsPointer)
 			}
 		} else {
@@ -1148,7 +1092,7 @@
 		if s.Size < int64(32*Thearch.Ptrsize) {
 			// Emit small symbols as data.
 			// This case also handles unaligned and tiny symbols, so tread carefully.
-			for i = s.Value; i < s.Value+s.Size; i++ {
+			for i := s.Value; i < s.Value+s.Size; i++ {
 				if (i % int64(Thearch.Ptrsize)) == 0 {
 					proggendata(g, obj.BitsScalar)
 				}
@@ -1168,24 +1112,24 @@
 		// gc program, copy directly
 		proggendataflush(g)
 
-		gcprog = decodetype_gcprog(s.Gotype)
-		size = decodetype_size(s.Gotype)
+		gcprog := decodetype_gcprog(s.Gotype)
+		size := decodetype_size(s.Gotype)
 		if (size%int64(Thearch.Ptrsize) != 0) || (g.pos%int64(Thearch.Ptrsize) != 0) {
 			Diag("proggenaddsym: unaligned gcprog symbol %s: size=%d pos=%d", s.Name, s.Size, g.pos)
 		}
-		for i = 0; i < int64(len(gcprog.P)-1); i++ {
+		for i := int64(0); i < int64(len(gcprog.P)-1); i++ {
 			proggenemit(g, uint8(gcprog.P[i]))
 		}
 		g.pos = s.Value + size
 	} else {
 		// gc mask, it's small so emit as data
-		mask = decodetype_gcmask(s.Gotype)
+		mask := decodetype_gcmask(s.Gotype)
 
-		size = decodetype_size(s.Gotype)
+		size := decodetype_size(s.Gotype)
 		if (size%int64(Thearch.Ptrsize) != 0) || (g.pos%int64(Thearch.Ptrsize) != 0) {
 			Diag("proggenaddsym: unaligned gcmask symbol %s: size=%d pos=%d", s.Name, s.Size, g.pos)
 		}
-		for i = 0; i < size; i += int64(Thearch.Ptrsize) {
+		for i := int64(0); i < size; i += int64(Thearch.Ptrsize) {
 			proggendata(g, uint8((mask[i/int64(Thearch.Ptrsize)/2]>>uint64((i/int64(Thearch.Ptrsize)%2)*4+2))&obj.BitsMask))
 		}
 		g.pos = s.Value + size
@@ -1193,9 +1137,7 @@
 }
 
 func growdatsize(datsizep *int64, s *LSym) {
-	var datsize int64
-
-	datsize = *datsizep
+	datsize := *datsizep
 	if s.Size < 0 {
 		Diag("negative size (datsize = %d, s->size = %d)", datsize, s.Size)
 	}
@@ -1206,27 +1148,15 @@
 }
 
 func dodata() {
-	var n int32
-	var datsize int64
-	var sect *Section
-	var segro *Segment
-	var s *LSym
-	var last *LSym
-	var l **LSym
-	var toc *LSym
-	var gcdata *LSym
-	var gcbss *LSym
-	var gen ProgGen
-
 	if Debug['v'] != 0 {
 		fmt.Fprintf(&Bso, "%5.2f dodata\n", obj.Cputime())
 	}
 	Bflush(&Bso)
 
-	last = nil
+	last := (*LSym)(nil)
 	datap = nil
 
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if !s.Reachable || s.Special != 0 {
 			continue
 		}
@@ -1245,7 +1175,7 @@
 		}
 	}
 
-	for s = datap; s != nil; s = s.Next {
+	for s := datap; s != nil; s = s.Next {
 		if int64(len(s.P)) > s.Size {
 			Diag("%s: initialize bounds (%d < %d)", s.Name, int64(s.Size), len(s.P))
 		}
@@ -1265,6 +1195,8 @@
 	dynreloc()
 
 	/* some symbols may no longer belong in datap (Mach-O) */
+	var l **LSym
+	var s *LSym
 	for l = &datap; ; {
 		s = *l
 		if s == nil {
@@ -1299,8 +1231,9 @@
 	}
 
 	/* writable ELF sections */
-	datsize = 0
+	datsize := int64(0)
 
+	var sect *Section
 	for ; s != nil && s.Type < SELFGOT; s = s.Next {
 		sect = addsection(&Segdata, s.Name, 06)
 		sect.Align = symalign(s)
@@ -1315,10 +1248,11 @@
 
 	/* .got (and .toc on ppc64) */
 	if s.Type == SELFGOT {
-		sect = addsection(&Segdata, ".got", 06)
+		sect := addsection(&Segdata, ".got", 06)
 		sect.Align = maxalign(s, SELFGOT)
 		datsize = Rnd(datsize, int64(sect.Align))
 		sect.Vaddr = uint64(datsize)
+		var toc *LSym
 		for ; s != nil && s.Type == SELFGOT; s = s.Next {
 			datsize = aligndatsize(datsize, s)
 			s.Sect = sect
@@ -1363,7 +1297,7 @@
 
 	/* shared library initializer */
 	if Flag_shared != 0 {
-		sect = addsection(&Segdata, ".init_array", 06)
+		sect := addsection(&Segdata, ".init_array", 06)
 		sect.Align = maxalign(s, SINITARR)
 		datsize = Rnd(datsize, int64(sect.Align))
 		sect.Vaddr = uint64(datsize)
@@ -1385,7 +1319,8 @@
 	sect.Vaddr = uint64(datsize)
 	Linklookup(Ctxt, "runtime.data", 0).Sect = sect
 	Linklookup(Ctxt, "runtime.edata", 0).Sect = sect
-	gcdata = Linklookup(Ctxt, "runtime.gcdata", 0)
+	gcdata := Linklookup(Ctxt, "runtime.gcdata", 0)
+	var gen ProgGen
 	proggeninit(&gen, gcdata)
 	for ; s != nil && s.Type < SBSS; s = s.Next {
 		if s.Type == SINITARR {
@@ -1412,7 +1347,7 @@
 	sect.Vaddr = uint64(datsize)
 	Linklookup(Ctxt, "runtime.bss", 0).Sect = sect
 	Linklookup(Ctxt, "runtime.ebss", 0).Sect = sect
-	gcbss = Linklookup(Ctxt, "runtime.gcbss", 0)
+	gcbss := Linklookup(Ctxt, "runtime.gcbss", 0)
 	proggeninit(&gen, gcbss)
 	for ; s != nil && s.Type < SNOPTRBSS; s = s.Next {
 		s.Sect = sect
@@ -1449,7 +1384,7 @@
 	}
 
 	if Iself && Linkmode == LinkExternal && s != nil && s.Type == STLSBSS && HEADTYPE != Hopenbsd {
-		sect = addsection(&Segdata, ".tbss", 06)
+		sect := addsection(&Segdata, ".tbss", 06)
 		sect.Align = int32(Thearch.Ptrsize)
 		sect.Vaddr = 0
 		datsize = 0
@@ -1486,6 +1421,7 @@
 	 * since it's not our decision; that code expects the sections in
 	 * segtext.
 	 */
+	var segro *Segment
 	if Iself && Linkmode == LinkInternal {
 		segro = &Segrodata
 	} else {
@@ -1600,17 +1536,17 @@
 	}
 
 	/* number the sections */
-	n = 1
+	n := int32(1)
 
-	for sect = Segtext.Sect; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect; sect != nil; sect = sect.Next {
 		sect.Extnum = int16(n)
 		n++
 	}
-	for sect = Segrodata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segrodata.Sect; sect != nil; sect = sect.Next {
 		sect.Extnum = int16(n)
 		n++
 	}
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		sect.Extnum = int16(n)
 		n++
 	}
@@ -1618,9 +1554,6 @@
 
 // assign addresses to text
 func textaddress() {
-	var va uint64
-	var sect *Section
-	var sym *LSym
 	var sub *LSym
 
 	addsection(&Segtext, ".text", 05)
@@ -1628,14 +1561,14 @@
 	// Assign PCs in text segment.
 	// Could parallelize, by assigning to text
 	// and then letting threads copy down, but probably not worth it.
-	sect = Segtext.Sect
+	sect := Segtext.Sect
 
 	sect.Align = int32(Funcalign)
 	Linklookup(Ctxt, "runtime.text", 0).Sect = sect
 	Linklookup(Ctxt, "runtime.etext", 0).Sect = sect
-	va = uint64(INITTEXT)
+	va := uint64(INITTEXT)
 	sect.Vaddr = va
-	for sym = Ctxt.Textp; sym != nil; sym = sym.Next {
+	for sym := Ctxt.Textp; sym != nil; sym = sym.Next {
 		sym.Sect = sect
 		if sym.Type&SSUB != 0 {
 			continue
@@ -1664,26 +1597,11 @@
 
 // assign addresses
 func address() {
-	var s *Section
-	var text *Section
-	var data *Section
-	var rodata *Section
-	var symtab *Section
-	var pclntab *Section
-	var noptr *Section
-	var bss *Section
-	var noptrbss *Section
-	var typelink *Section
-	var sym *LSym
-	var sub *LSym
-	var va uint64
-	var vlen int64
-
-	va = uint64(INITTEXT)
+	va := uint64(INITTEXT)
 	Segtext.Rwx = 05
 	Segtext.Vaddr = va
 	Segtext.Fileoff = uint64(HEADR)
-	for s = Segtext.Sect; s != nil; s = s.Next {
+	for s := Segtext.Sect; s != nil; s = s.Next {
 		va = uint64(Rnd(int64(va), int64(s.Align)))
 		s.Vaddr = va
 		va += s.Length
@@ -1704,7 +1622,7 @@
 		Segrodata.Vaddr = va
 		Segrodata.Fileoff = va - Segtext.Vaddr + Segtext.Fileoff
 		Segrodata.Filelen = 0
-		for s = Segrodata.Sect; s != nil; s = s.Next {
+		for s := Segrodata.Sect; s != nil; s = s.Next {
 			va = uint64(Rnd(int64(va), int64(s.Align)))
 			s.Vaddr = va
 			va += s.Length
@@ -1725,11 +1643,12 @@
 	if HEADTYPE == Hplan9 {
 		Segdata.Fileoff = Segtext.Fileoff + Segtext.Filelen
 	}
-	data = nil
-	noptr = nil
-	bss = nil
-	noptrbss = nil
-	for s = Segdata.Sect; s != nil; s = s.Next {
+	data := (*Section)(nil)
+	noptr := (*Section)(nil)
+	bss := (*Section)(nil)
+	noptrbss := (*Section)(nil)
+	var vlen int64
+	for s := Segdata.Sect; s != nil; s = s.Next {
 		vlen = int64(s.Length)
 		if s.Next != nil {
 			vlen = int64(s.Next.Vaddr - s.Vaddr)
@@ -1753,17 +1672,19 @@
 
 	Segdata.Filelen = bss.Vaddr - Segdata.Vaddr
 
-	text = Segtext.Sect
+	text := Segtext.Sect
+	var rodata *Section
 	if Segrodata.Sect != nil {
 		rodata = Segrodata.Sect
 	} else {
 		rodata = text.Next
 	}
-	typelink = rodata.Next
-	symtab = typelink.Next
-	pclntab = symtab.Next
+	typelink := rodata.Next
+	symtab := typelink.Next
+	pclntab := symtab.Next
 
-	for sym = datap; sym != nil; sym = sym.Next {
+	var sub *LSym
+	for sym := datap; sym != nil; sym = sym.Next {
 		Ctxt.Cursym = sym
 		if sym.Sect != nil {
 			sym.Value += int64((sym.Sect.(*Section)).Vaddr)
@@ -1780,7 +1701,7 @@
 	xdefine("runtime.typelink", SRODATA, int64(typelink.Vaddr))
 	xdefine("runtime.etypelink", SRODATA, int64(typelink.Vaddr+typelink.Length))
 
-	sym = Linklookup(Ctxt, "runtime.gcdata", 0)
+	sym := Linklookup(Ctxt, "runtime.gcdata", 0)
 	xdefine("runtime.egcdata", SRODATA, Symaddr(sym)+sym.Size)
 	Linklookup(Ctxt, "runtime.egcdata", 0).Sect = sym.Sect
 
diff --git a/src/cmd/internal/ld/decodesym.go b/src/cmd/internal/ld/decodesym.go
index c7b1a2f..74fa4b5 100644
--- a/src/cmd/internal/ld/decodesym.go
+++ b/src/cmd/internal/ld/decodesym.go
@@ -11,9 +11,7 @@
 // ../gc/reflect.c stuffs in these.
 
 func decode_reloc(s *LSym, off int32) *Reloc {
-	var i int
-
-	for i = 0; i < len(s.R); i++ {
+	for i := 0; i < len(s.R); i++ {
 		if s.R[i].Off == off {
 			return &s.R[i:][0]
 		}
@@ -22,9 +20,7 @@
 }
 
 func decode_reloc_sym(s *LSym, off int32) *LSym {
-	var r *Reloc
-
-	r = decode_reloc(s, off)
+	r := decode_reloc(s, off)
 	if r == nil {
 		return nil
 	}
@@ -75,9 +71,7 @@
 }
 
 func decodetype_gcmask(s *LSym) []byte {
-	var mask *LSym
-
-	mask = decode_reloc_sym(s, 1*int32(Thearch.Ptrsize)+8+1*int32(Thearch.Ptrsize))
+	mask := decode_reloc_sym(s, 1*int32(Thearch.Ptrsize)+8+1*int32(Thearch.Ptrsize))
 	return mask.P
 }
 
@@ -124,9 +118,7 @@
 }
 
 func decodetype_funcintype(s *LSym, i int) *LSym {
-	var r *Reloc
-
-	r = decode_reloc(s, int32(commonsize())+int32(Thearch.Ptrsize))
+	r := decode_reloc(s, int32(commonsize())+int32(Thearch.Ptrsize))
 	if r == nil {
 		return nil
 	}
@@ -134,9 +126,7 @@
 }
 
 func decodetype_funcouttype(s *LSym, i int) *LSym {
-	var r *Reloc
-
-	r = decode_reloc(s, int32(commonsize())+2*int32(Thearch.Ptrsize)+2*int32(Thearch.Intsize))
+	r := decode_reloc(s, int32(commonsize())+2*int32(Thearch.Ptrsize)+2*int32(Thearch.Intsize))
 	if r == nil {
 		return nil
 	}
@@ -154,16 +144,14 @@
 
 // Type.StructType.fields[]-> name, typ and offset.
 func decodetype_structfieldname(s *LSym, i int) string {
-	var r *Reloc
-
 	// go.string."foo"  0x28 / 0x40
 	s = decode_reloc_sym(s, int32(commonsize())+int32(Thearch.Ptrsize)+2*int32(Thearch.Intsize)+int32(i)*int32(structfieldsize()))
 
 	if s == nil { // embedded structs have a nil name.
 		return ""
 	}
-	r = decode_reloc(s, 0) // s has a pointer to the string data at offset 0
-	if r == nil {          // shouldn't happen.
+	r := decode_reloc(s, 0) // s has a pointer to the string data at offset 0
+	if r == nil {           // shouldn't happen.
 		return ""
 	}
 	return cstring(r.Sym.P[r.Add:])
diff --git a/src/cmd/internal/ld/dwarf.go b/src/cmd/internal/ld/dwarf.go
index 490795c..4d3715b 100644
--- a/src/cmd/internal/ld/dwarf.go
+++ b/src/cmd/internal/ld/dwarf.go
@@ -102,9 +102,8 @@
 
 func uleb128enc(v uint64, dst []byte) int {
 	var c uint8
-	var length uint8
 
-	length = 0
+	length := uint8(0)
 	for {
 		c = uint8(v & 0x7f)
 		v >>= 7
@@ -127,9 +126,8 @@
 func sleb128enc(v int64, dst []byte) int {
 	var c uint8
 	var s uint8
-	var length uint8
 
-	length = 0
+	length := uint8(0)
 	for {
 		c = uint8(v & 0x7f)
 		s = uint8(v & 0x40)
@@ -587,12 +585,11 @@
 }
 
 func writeabbrev() {
-	var i int
 	var j int
 	var f *DWAttrForm
 
 	abbrevo = Cpos()
-	for i = 1; i < DW_NABRV; i++ {
+	for i := 1; i < DW_NABRV; i++ {
 		// See section 7.5.3
 		uleb128put(int64(i))
 
@@ -620,9 +617,7 @@
 )
 
 func dwarfhashstr(s string) uint32 {
-	var h uint32
-
-	h = 0
+	h := uint32(0)
 	for s != "" {
 		h = h + h + h + uint32(s[0])
 		s = s[1:]
@@ -663,9 +658,7 @@
 var dwglobals DWDie
 
 func newattr(die *DWDie, attr uint16, cls int, value int64, data interface{}) *DWAttr {
-	var a *DWAttr
-
-	a = new(DWAttr)
+	a := new(DWAttr)
 	a.link = die.attr
 	die.attr = a
 	a.atr = attr
@@ -679,15 +672,12 @@
 // name. getattr moves the desired one to the front so
 // frequently searched ones are found faster.
 func getattr(die *DWDie, attr uint16) *DWAttr {
-	var a *DWAttr
-	var b *DWAttr
-
 	if die.attr.atr == attr {
 		return die.attr
 	}
 
-	a = die.attr
-	b = a.link
+	a := die.attr
+	b := a.link
 	for b != nil {
 		if b.atr == attr {
 			a.link = b.link
@@ -707,10 +697,7 @@
 // written out if it is listed in the abbrev).	If its parent is
 // keeping an index, the new DIE will be inserted there.
 func newdie(parent *DWDie, abbrev int, name string) *DWDie {
-	var die *DWDie
-	var h int
-
-	die = new(DWDie)
+	die := new(DWDie)
 	die.abbrev = abbrev
 	die.link = parent.child
 	parent.child = die
@@ -718,7 +705,7 @@
 	newattr(die, DW_AT_name, DW_CLS_STRING, int64(len(name)), name)
 
 	if parent.hash != nil {
-		h = int(dwarfhashstr(name))
+		h := int(dwarfhashstr(name))
 		die.hlink = parent.hash[h]
 		parent.hash[h] = die
 	}
@@ -731,11 +718,9 @@
 }
 
 func walktypedef(die *DWDie) *DWDie {
-	var attr *DWAttr
-
 	// Resolve typedef if present.
 	if die.abbrev == DW_ABRV_TYPEDECL {
-		for attr = die.attr; attr != nil; attr = attr.link {
+		for attr := die.attr; attr != nil; attr = attr.link {
 			if attr.atr == DW_AT_type && attr.cls == DW_CLS_REFERENCE && attr.data != nil {
 				return attr.data.(*DWDie)
 			}
@@ -800,8 +785,7 @@
 }
 
 func find_or_diag(die *DWDie, name string) *DWDie {
-	var r *DWDie
-	r = find(die, name)
+	r := find(die, name)
 	if r == nil {
 		Diag("dwarf find: %s %p has no %s", getattr(die, DW_AT_name).data, die, name)
 		Errorexit()
@@ -811,9 +795,7 @@
 }
 
 func adddwarfrel(sec *LSym, sym *LSym, offsetbase int64, siz int, addend int64) {
-	var r *Reloc
-
-	r = Addrel(sec)
+	r := Addrel(sec)
 	r.Sym = sym
 	r.Xsym = sym
 	r.Off = int32(Cpos() - offsetbase)
@@ -846,10 +828,6 @@
 var fwdcount int
 
 func putattr(abbrev int, form int, cls int, value int64, data interface{}) {
-	var off int64
-	var p []byte
-	var i int
-
 	switch form {
 	case DW_FORM_addr: // address
 		if Linkmode == LinkExternal {
@@ -876,8 +854,8 @@
 
 		value &= 0xff
 		Cput(uint8(value))
-		p = data.([]byte)
-		for i = 0; int64(i) < value; i++ {
+		p := data.([]byte)
+		for i := 0; int64(i) < value; i++ {
 			Cput(uint8(p[i]))
 		}
 
@@ -885,8 +863,8 @@
 		value &= 0xffff
 
 		Thearch.Wput(uint16(value))
-		p = data.([]byte)
-		for i = 0; int64(i) < value; i++ {
+		p := data.([]byte)
+		for i := 0; int64(i) < value; i++ {
 			Cput(uint8(p[i]))
 		}
 
@@ -894,16 +872,16 @@
 		value &= 0xffffffff
 
 		Thearch.Lput(uint32(value))
-		p = data.([]byte)
-		for i = 0; int64(i) < value; i++ {
+		p := data.([]byte)
+		for i := 0; int64(i) < value; i++ {
 			Cput(uint8(p[i]))
 		}
 
 	case DW_FORM_block: // block
 		uleb128put(value)
 
-		p = data.([]byte)
-		for i = 0; int64(i) < value; i++ {
+		p := data.([]byte)
+		for i := 0; int64(i) < value; i++ {
 			Cput(uint8(p[i]))
 		}
 
@@ -953,7 +931,7 @@
 				Thearch.Lput(0) // invalid dwarf, gdb will complain.
 			}
 		} else {
-			off = (data.(*DWDie)).offs
+			off := (data.(*DWDie)).offs
 			if off == 0 {
 				fwdcount++
 			}
@@ -984,10 +962,9 @@
 // Note that we can (and do) add arbitrary attributes to a DIE, but
 // only the ones actually listed in the Abbrev will be written out.
 func putattrs(abbrev int, attr *DWAttr) {
-	var af []DWAttrForm
 	var ap *DWAttr
 
-	for af = abbrevs[abbrev].attr[:]; af[0].attr != 0; af = af[1:] {
+	for af := abbrevs[abbrev].attr[:]; af[0].attr != 0; af = af[1:] {
 		for ap = attr; ap != nil; ap = ap.link {
 			if ap.atr == af[0].attr {
 				putattr(abbrev, int(af[0].form), int(ap.cls), ap.value, ap.data)
@@ -1017,11 +994,8 @@
 }
 
 func reverselist(list **DWDie) {
-	var curr *DWDie
-	var prev *DWDie
-
-	curr = *list
-	prev = nil
+	curr := *list
+	prev := (*DWDie)(nil)
 	for curr != nil {
 		var next *DWDie = curr.link
 		curr.link = prev
@@ -1033,10 +1007,8 @@
 }
 
 func reversetree(list **DWDie) {
-	var die *DWDie
-
 	reverselist(list)
-	for die = *list; die != nil; die = die.link {
+	for die := *list; die != nil; die = die.link {
 		if abbrevs[die.abbrev].children != 0 {
 			reversetree(&die.child)
 		}
@@ -1045,9 +1017,8 @@
 
 func newmemberoffsetattr(die *DWDie, offs int32) {
 	var block [20]byte
-	var i int
 
-	i = 0
+	i := 0
 	block[i] = DW_OP_plus_uconst
 	i++
 	i += uleb128enc(uint64(offs), block[i:])
@@ -1063,9 +1034,7 @@
 
 // Lookup predefined types
 func lookup_or_diag(n string) *LSym {
-	var s *LSym
-
-	s = Linkrlookup(Ctxt, n, 0)
+	s := Linkrlookup(Ctxt, n, 0)
 	if s == nil || s.Size == 0 {
 		Diag("dwarf: missing type: %s", n)
 		Errorexit()
@@ -1075,8 +1044,6 @@
 }
 
 func dotypedef(parent *DWDie, name string, def *DWDie) {
-	var die *DWDie
-
 	// Only emit typedefs for real names.
 	if strings.HasPrefix(name, "map[") {
 		return
@@ -1098,23 +1065,13 @@
 	// so that future lookups will find the typedef instead
 	// of the real definition. This hooks the typedef into any
 	// circular definition loops, so that gdb can understand them.
-	die = newdie(parent, DW_ABRV_TYPEDECL, name)
+	die := newdie(parent, DW_ABRV_TYPEDECL, name)
 
 	newrefattr(die, DW_AT_type, def)
 }
 
 // Define gotype, for composite ones recurse into constituents.
 func defgotype(gotype *LSym) *DWDie {
-	var die *DWDie
-	var fld *DWDie
-	var s *LSym
-	var name string
-	var f string
-	var kind uint8
-	var bytesize int64
-	var i int
-	var nfields int
-
 	if gotype == nil {
 		return find_or_diag(&dwtypes, "<unspecified>")
 	}
@@ -1124,9 +1081,9 @@
 		return find_or_diag(&dwtypes, "<unspecified>")
 	}
 
-	name = gotype.Name[5:] // could also decode from Type.string
+	name := gotype.Name[5:] // could also decode from Type.string
 
-	die = find(&dwtypes, name)
+	die := find(&dwtypes, name)
 
 	if die != nil {
 		return die
@@ -1136,8 +1093,8 @@
 		fmt.Printf("new type: %%Y\n", gotype)
 	}
 
-	kind = decodetype_kind(gotype)
-	bytesize = decodetype_size(gotype)
+	kind := decodetype_kind(gotype)
+	bytesize := decodetype_size(gotype)
 
 	switch kind {
 	case obj.KindBool:
@@ -1180,9 +1137,9 @@
 		die = newdie(&dwtypes, DW_ABRV_ARRAYTYPE, name)
 		dotypedef(&dwtypes, name, die)
 		newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0)
-		s = decodetype_arrayelem(gotype)
+		s := decodetype_arrayelem(gotype)
 		newrefattr(die, DW_AT_type, defgotype(s))
-		fld = newdie(die, DW_ABRV_ARRAYRANGE, "range")
+		fld := newdie(die, DW_ABRV_ARRAYRANGE, "range")
 
 		// use actual length not upper bound; correct for 0-length arrays.
 		newattr(fld, DW_AT_count, DW_CLS_CONSTANT, decodetype_arraylen(gotype), 0)
@@ -1192,15 +1149,17 @@
 	case obj.KindChan:
 		die = newdie(&dwtypes, DW_ABRV_CHANTYPE, name)
 		newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0)
-		s = decodetype_chanelem(gotype)
+		s := decodetype_chanelem(gotype)
 		newrefattr(die, DW_AT_go_elem, defgotype(s))
 
 	case obj.KindFunc:
 		die = newdie(&dwtypes, DW_ABRV_FUNCTYPE, name)
 		dotypedef(&dwtypes, name, die)
 		newrefattr(die, DW_AT_type, find_or_diag(&dwtypes, "void"))
-		nfields = decodetype_funcincount(gotype)
-		for i = 0; i < nfields; i++ {
+		nfields := decodetype_funcincount(gotype)
+		var fld *DWDie
+		var s *LSym
+		for i := 0; i < nfields; i++ {
 			s = decodetype_funcintype(gotype, i)
 			fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s.Name[5:])
 			newrefattr(fld, DW_AT_type, defgotype(s))
@@ -1210,7 +1169,7 @@
 			newdie(die, DW_ABRV_DOTDOTDOT, "...")
 		}
 		nfields = decodetype_funcoutcount(gotype)
-		for i = 0; i < nfields; i++ {
+		for i := 0; i < nfields; i++ {
 			s = decodetype_funcouttype(gotype, i)
 			fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s.Name[5:])
 			newrefattr(fld, DW_AT_type, defptrto(defgotype(s)))
@@ -1220,7 +1179,8 @@
 		die = newdie(&dwtypes, DW_ABRV_IFACETYPE, name)
 		dotypedef(&dwtypes, name, die)
 		newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0)
-		nfields = int(decodetype_ifacemethodcount(gotype))
+		nfields := int(decodetype_ifacemethodcount(gotype))
+		var s *LSym
 		if nfields == 0 {
 			s = lookup_or_diag("type.runtime.eface")
 		} else {
@@ -1230,7 +1190,7 @@
 
 	case obj.KindMap:
 		die = newdie(&dwtypes, DW_ABRV_MAPTYPE, name)
-		s = decodetype_mapkey(gotype)
+		s := decodetype_mapkey(gotype)
 		newrefattr(die, DW_AT_go_key, defgotype(s))
 		s = decodetype_mapvalue(gotype)
 		newrefattr(die, DW_AT_go_elem, defgotype(s))
@@ -1238,14 +1198,14 @@
 	case obj.KindPtr:
 		die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name)
 		dotypedef(&dwtypes, name, die)
-		s = decodetype_ptrelem(gotype)
+		s := decodetype_ptrelem(gotype)
 		newrefattr(die, DW_AT_type, defgotype(s))
 
 	case obj.KindSlice:
 		die = newdie(&dwtypes, DW_ABRV_SLICETYPE, name)
 		dotypedef(&dwtypes, name, die)
 		newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0)
-		s = decodetype_arrayelem(gotype)
+		s := decodetype_arrayelem(gotype)
 		newrefattr(die, DW_AT_go_elem, defgotype(s))
 
 	case obj.KindString:
@@ -1256,8 +1216,11 @@
 		die = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, name)
 		dotypedef(&dwtypes, name, die)
 		newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0)
-		nfields = decodetype_structfieldcount(gotype)
-		for i = 0; i < nfields; i++ {
+		nfields := decodetype_structfieldcount(gotype)
+		var f string
+		var fld *DWDie
+		var s *LSym
+		for i := 0; i < nfields; i++ {
 			f = decodetype_structfieldname(gotype, i)
 			s = decodetype_structfieldtype(gotype, i)
 			if f == "" {
@@ -1284,11 +1247,8 @@
 
 // Find or construct *T given T.
 func defptrto(dwtype *DWDie) *DWDie {
-	var ptrname string
-	var die *DWDie
-
-	ptrname = fmt.Sprintf("*%s", getattr(dwtype, DW_AT_name).data)
-	die = find(&dwtypes, ptrname)
+	ptrname := fmt.Sprintf("*%s", getattr(dwtype, DW_AT_name).data)
+	die := find(&dwtypes, ptrname)
 	if die == nil {
 		die = newdie(&dwtypes, DW_ABRV_PTRTYPE, ptrname)
 		newrefattr(die, DW_AT_type, dwtype)
@@ -1325,15 +1285,12 @@
 // Search children (assumed to have DW_TAG_member) for the one named
 // field and set its DW_AT_type to dwtype
 func substitutetype(structdie *DWDie, field string, dwtype *DWDie) {
-	var child *DWDie
-	var a *DWAttr
-
-	child = find_or_diag(structdie, field)
+	child := find_or_diag(structdie, field)
 	if child == nil {
 		return
 	}
 
-	a = getattr(child, DW_AT_type)
+	a := getattr(child, DW_AT_type)
 	if a != nil {
 		a.data = dwtype
 	} else {
@@ -1342,9 +1299,7 @@
 }
 
 func synthesizestringtypes(die *DWDie) {
-	var prototype *DWDie
-
-	prototype = walktypedef(defgotype(lookup_or_diag("type.runtime._string")))
+	prototype := walktypedef(defgotype(lookup_or_diag("type.runtime._string")))
 	if prototype == nil {
 		return
 	}
@@ -1358,14 +1313,12 @@
 }
 
 func synthesizeslicetypes(die *DWDie) {
-	var prototype *DWDie
-	var elem *DWDie
-
-	prototype = walktypedef(defgotype(lookup_or_diag("type.runtime.slice")))
+	prototype := walktypedef(defgotype(lookup_or_diag("type.runtime.slice")))
 	if prototype == nil {
 		return
 	}
 
+	var elem *DWDie
 	for ; die != nil; die = die.link {
 		if die.abbrev != DW_ABRV_SLICETYPE {
 			continue
@@ -1378,14 +1331,13 @@
 
 func mkinternaltypename(base string, arg1 string, arg2 string) string {
 	var buf string
-	var n string
 
 	if arg2 == "" {
 		buf = fmt.Sprintf("%s<%s>", base, arg1)
 	} else {
 		buf = fmt.Sprintf("%s<%s,%s>", base, arg1, arg2)
 	}
-	n = buf
+	n := buf
 	return n
 }
 
@@ -1397,29 +1349,26 @@
 )
 
 func synthesizemaptypes(die *DWDie) {
-	var hash *DWDie
-	var bucket *DWDie
-	var dwh *DWDie
-	var dwhk *DWDie
-	var dwhv *DWDie
-	var dwhb *DWDie
-	var keytype *DWDie
-	var valtype *DWDie
-	var fld *DWDie
-	var t *DWDie
-	var indirect_key int
-	var indirect_val int
-	var keysize int
-	var valsize int
-	var a *DWAttr
-
-	hash = walktypedef(defgotype(lookup_or_diag("type.runtime.hmap")))
-	bucket = walktypedef(defgotype(lookup_or_diag("type.runtime.bmap")))
+	hash := walktypedef(defgotype(lookup_or_diag("type.runtime.hmap")))
+	bucket := walktypedef(defgotype(lookup_or_diag("type.runtime.bmap")))
 
 	if hash == nil {
 		return
 	}
 
+	var a *DWAttr
+	var dwh *DWDie
+	var dwhb *DWDie
+	var dwhk *DWDie
+	var dwhv *DWDie
+	var fld *DWDie
+	var indirect_key int
+	var indirect_val int
+	var keysize int
+	var keytype *DWDie
+	var t *DWDie
+	var valsize int
+	var valtype *DWDie
 	for ; die != nil; die = die.link {
 		if die.abbrev != DW_ABRV_MAPTYPE {
 			continue
@@ -1518,26 +1467,21 @@
 }
 
 func synthesizechantypes(die *DWDie) {
-	var sudog *DWDie
-	var waitq *DWDie
-	var hchan *DWDie
-	var dws *DWDie
-	var dww *DWDie
-	var dwh *DWDie
-	var elemtype *DWDie
-	var a *DWAttr
-	var elemsize int
-	var sudogsize int
-
-	sudog = walktypedef(defgotype(lookup_or_diag("type.runtime.sudog")))
-	waitq = walktypedef(defgotype(lookup_or_diag("type.runtime.waitq")))
-	hchan = walktypedef(defgotype(lookup_or_diag("type.runtime.hchan")))
+	sudog := walktypedef(defgotype(lookup_or_diag("type.runtime.sudog")))
+	waitq := walktypedef(defgotype(lookup_or_diag("type.runtime.waitq")))
+	hchan := walktypedef(defgotype(lookup_or_diag("type.runtime.hchan")))
 	if sudog == nil || waitq == nil || hchan == nil {
 		return
 	}
 
-	sudogsize = int(getattr(sudog, DW_AT_byte_size).value)
+	sudogsize := int(getattr(sudog, DW_AT_byte_size).value)
 
+	var a *DWAttr
+	var dwh *DWDie
+	var dws *DWDie
+	var dww *DWDie
+	var elemsize int
+	var elemtype *DWDie
 	for ; die != nil; die = die.link {
 		if die.abbrev != DW_ABRV_CHANTYPE {
 			continue
@@ -1584,9 +1528,6 @@
 
 // For use with pass.c::genasmsym
 func defdwsymb(sym *LSym, s string, t int, v int64, size int64, ver int, gotype *LSym) {
-	var dv *DWDie
-	var dt *DWDie
-
 	if strings.HasPrefix(s, "go.string.") {
 		return
 	}
@@ -1596,8 +1537,9 @@
 		return
 	}
 
-	dv = nil
+	dv := (*DWDie)(nil)
 
+	var dt *DWDie
 	switch t {
 	default:
 		return
@@ -1625,9 +1567,7 @@
 }
 
 func movetomodule(parent *DWDie) {
-	var die *DWDie
-
-	die = dwroot.child.child
+	die := dwroot.child.child
 	for die.link != nil {
 		die = die.link
 	}
@@ -1636,15 +1576,13 @@
 
 // If the pcln table contains runtime/runtime.go, use that to set gdbscript path.
 func finddebugruntimepath(s *LSym) {
-	var i int
-	var p string
-	var f *LSym
-
 	if gdbscript != "" {
 		return
 	}
 
-	for i = 0; i < s.Pcln.Nfile; i++ {
+	var f *LSym
+	var p string
+	for i := 0; i < s.Pcln.Nfile; i++ {
 		f = s.Pcln.File[i]
 		_ = p
 		if i := strings.Index(f.Name, "runtime/runtime.go"); i >= 0 {
@@ -1685,9 +1623,8 @@
 
 func newcfaoffsetattr(die *DWDie, offs int32) {
 	var block [20]byte
-	var i int
 
-	i = 0
+	i := 0
 
 	block[i] = DW_OP_call_frame_cfa
 	i++
@@ -1703,11 +1640,8 @@
 }
 
 func mkvarname(name string, da int) string {
-	var buf string
-	var n string
-
-	buf = fmt.Sprintf("%s#%d", name, da)
-	n = buf
+	buf := fmt.Sprintf("%s#%d", name, da)
+	n := buf
 	return n
 }
 
@@ -1717,8 +1651,6 @@
 
 // flush previous compilation unit.
 func flushunit(dwinfo *DWDie, pc int64, pcsym *LSym, unitstart int64, header_length int32) {
-	var here int64
-
 	if dwinfo != nil && pc != 0 {
 		newattr(dwinfo, DW_AT_high_pc, DW_CLS_ADDRESS, pc+1, pcsym)
 	}
@@ -1728,7 +1660,7 @@
 		uleb128put(1)
 		Cput(DW_LNE_end_sequence)
 
-		here = Cpos()
+		here := Cpos()
 		Cseek(unitstart)
 		Thearch.Lput(uint32(here - unitstart - 4)) // unit_length
 		Thearch.Wput(2)                            // dwarf version
@@ -1738,50 +1670,24 @@
 }
 
 func writelines() {
-	var s *LSym
-	var epcs *LSym
-	var a *Auto
-	var unitstart int64
-	var headerend int64
-	var offs int64
-	var pc int64
-	var epc int64
-	var i int
-	var lang int
-	var da int
-	var dt int
-	var line int
-	var file int
-	var dwinfo *DWDie
-	var dwfunc *DWDie
-	var dwvar *DWDie
-	var dws **DWDie
-	var varhash [HASHSIZE]*DWDie
-	var n string
-	var nn string
-	var pcfile Pciter
-	var pcline Pciter
-	var files []*LSym
-	var f *LSym
-
 	if linesec == nil {
 		linesec = Linklookup(Ctxt, ".dwarfline", 0)
 	}
 	linesec.R = linesec.R[:0]
 
-	unitstart = -1
-	headerend = -1
-	epc = 0
-	epcs = nil
+	unitstart := int64(-1)
+	headerend := int64(-1)
+	epc := int64(0)
+	epcs := (*LSym)(nil)
 	lineo = Cpos()
-	dwinfo = nil
+	dwinfo := (*DWDie)(nil)
 
 	flushunit(dwinfo, epc, epcs, unitstart, int32(headerend-unitstart-10))
 	unitstart = Cpos()
 
-	lang = DW_LANG_Go
+	lang := DW_LANG_Go
 
-	s = Ctxt.Textp
+	s := Ctxt.Textp
 
 	dwinfo = newdie(&dwroot, DW_ABRV_COMPUNIT, "go")
 	newattr(dwinfo, DW_AT_language, DW_CLS_CONSTANT, int64(lang), 0)
@@ -1811,13 +1717,13 @@
 	Cput(1)                // standard_opcode_lengths[9]
 	Cput(0)                // include_directories  (empty)
 
-	files = make([]*LSym, Ctxt.Nhistfile)
+	files := make([]*LSym, Ctxt.Nhistfile)
 
-	for f = Ctxt.Filesyms; f != nil; f = f.Next {
+	for f := Ctxt.Filesyms; f != nil; f = f.Next {
 		files[f.Value-1] = f
 	}
 
-	for i = 0; int32(i) < Ctxt.Nhistfile; i++ {
+	for i := 0; int32(i) < Ctxt.Nhistfile; i++ {
 		strnput(files[i].Name, len(files[i].Name)+4)
 	}
 
@@ -1830,15 +1736,27 @@
 	uleb128put(1 + int64(Thearch.Ptrsize))
 	Cput(DW_LNE_set_address)
 
-	pc = s.Value
-	line = 1
-	file = 1
+	pc := s.Value
+	line := 1
+	file := 1
 	if Linkmode == LinkExternal {
 		adddwarfrel(linesec, s, lineo, Thearch.Ptrsize, 0)
 	} else {
 		addrput(pc)
 	}
 
+	var a *Auto
+	var da int
+	var dt int
+	var dwfunc *DWDie
+	var dws **DWDie
+	var dwvar *DWDie
+	var n string
+	var nn string
+	var offs int64
+	var pcfile Pciter
+	var pcline Pciter
+	var varhash [HASHSIZE]*DWDie
 	for Ctxt.Cursym = Ctxt.Textp; Ctxt.Cursym != nil; Ctxt.Cursym = Ctxt.Cursym.Next {
 		s = Ctxt.Cursym
 
@@ -1975,13 +1893,6 @@
 }
 
 func writeframes() {
-	var s *LSym
-	var fdeo int64
-	var fdesize int64
-	var pad int64
-	var pcsp Pciter
-	var nextpc uint32
-
 	if framesec == nil {
 		framesec = Linklookup(Ctxt, ".dwarfframe", 0)
 	}
@@ -2006,7 +1917,7 @@
 	uleb128put(int64(-Thearch.Ptrsize) / DATAALIGNMENTFACTOR) // at cfa - x*4
 
 	// 4 is to exclude the length field.
-	pad = CIERESERVE + frameo + 4 - Cpos()
+	pad := CIERESERVE + frameo + 4 - Cpos()
 
 	if pad < 0 {
 		Diag("dwarf: CIERESERVE too small by %d bytes.", -pad)
@@ -2015,6 +1926,11 @@
 
 	strnput("", int(pad))
 
+	var fdeo int64
+	var fdesize int64
+	var nextpc uint32
+	var pcsp Pciter
+	var s *LSym
 	for Ctxt.Cursym = Ctxt.Textp; Ctxt.Cursym != nil; Ctxt.Cursym = Ctxt.Cursym.Next {
 		s = Ctxt.Cursym
 		if s.Pcln == nil {
@@ -2077,10 +1993,6 @@
 )
 
 func writeinfo() {
-	var compunit *DWDie
-	var unitstart int64
-	var here int64
-
 	fwdcount = 0
 	if infosec == nil {
 		infosec = Linklookup(Ctxt, ".dwarfinfo", 0)
@@ -2092,7 +2004,9 @@
 	}
 	arangessec.R = arangessec.R[:0]
 
-	for compunit = dwroot.child; compunit != nil; compunit = compunit.link {
+	var here int64
+	var unitstart int64
+	for compunit := dwroot.child; compunit != nil; compunit = compunit.link {
 		unitstart = Cpos()
 
 		// Write .debug_info Compilation Unit Header (sec 7.5.1)
@@ -2126,12 +2040,10 @@
  *  because we need die->offs and infoo/infosize;
  */
 func ispubname(die *DWDie) bool {
-	var a *DWAttr
-
 	switch die.abbrev {
 	case DW_ABRV_FUNCTION,
 		DW_ABRV_VARIABLE:
-		a = getattr(die, DW_AT_external)
+		a := getattr(die, DW_AT_external)
 		return a != nil && a.value != 0
 	}
 
@@ -2143,17 +2055,15 @@
 }
 
 func writepub(ispub func(*DWDie) bool) int64 {
-	var compunit *DWDie
 	var die *DWDie
 	var dwa *DWAttr
 	var unitstart int64
 	var unitend int64
-	var sectionstart int64
 	var here int64
 
-	sectionstart = Cpos()
+	sectionstart := Cpos()
 
-	for compunit = dwroot.child; compunit != nil; compunit = compunit.link {
+	for compunit := dwroot.child; compunit != nil; compunit = compunit.link {
 		unitstart = compunit.offs - COMPUNITHEADERSIZE
 		if compunit.link != nil {
 			unitend = compunit.link.offs - COMPUNITHEADERSIZE
@@ -2192,17 +2102,14 @@
  *  because we need die->offs of dw_globals.
  */
 func writearanges() int64 {
-	var compunit *DWDie
 	var b *DWAttr
 	var e *DWAttr
-	var headersize int
-	var sectionstart int64
 	var value int64
 
-	sectionstart = Cpos()
-	headersize = int(Rnd(4+2+4+1+1, int64(Thearch.Ptrsize))) // don't count unit_length field itself
+	sectionstart := Cpos()
+	headersize := int(Rnd(4+2+4+1+1, int64(Thearch.Ptrsize))) // don't count unit_length field itself
 
-	for compunit = dwroot.child; compunit != nil; compunit = compunit.link {
+	for compunit := dwroot.child; compunit != nil; compunit = compunit.link {
 		b = getattr(compunit, DW_AT_low_pc)
 		if b == nil {
 			continue
@@ -2243,9 +2150,7 @@
 }
 
 func writegdbscript() int64 {
-	var sectionstart int64
-
-	sectionstart = Cpos()
+	sectionstart := Cpos()
 
 	if gdbscript != "" {
 		Cput(1) // magic 1 byte?
@@ -2264,12 +2169,10 @@
 
 func writedwarfreloc(s *LSym) int64 {
 	var i int
-	var ri int
-	var start int64
 	var r *Reloc
 
-	start = Cpos()
-	for ri = 0; ri < len(s.R); ri++ {
+	start := Cpos()
+	for ri := 0; ri < len(s.R); ri++ {
 		r = &s.R[ri]
 		if Iself {
 			i = Thearch.Elfreloc1(r, int64(r.Off))
@@ -2296,9 +2199,6 @@
  *
  */
 func Dwarfemitdebugsections() {
-	var infoe int64
-	var die *DWDie
-
 	if Debug['w'] != 0 { // disable dwarf
 		return
 	}
@@ -2320,7 +2220,7 @@
 	newdie(&dwtypes, DW_ABRV_NULLTYPE, "void")
 	newdie(&dwtypes, DW_ABRV_BARE_PTRTYPE, "unsafe.Pointer")
 
-	die = newdie(&dwtypes, DW_ABRV_BASETYPE, "uintptr") // needed for array size
+	die := newdie(&dwtypes, DW_ABRV_BASETYPE, "uintptr") // needed for array size
 	newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_unsigned, 0)
 	newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, int64(Thearch.Ptrsize), 0)
 	newattr(die, DW_AT_go_kind, DW_CLS_CONSTANT, obj.KindUintptr, 0)
@@ -2354,7 +2254,7 @@
 
 	infoo = Cpos()
 	writeinfo()
-	infoe = Cpos()
+	infoe := Cpos()
 	pubnameso = infoe
 	pubtypeso = infoe
 	arangeso = infoe
@@ -2510,9 +2410,7 @@
 }
 
 func dwarfaddelfrelocheader(elfstr int, shdata *ElfShdr, off int64, size int64) {
-	var sh *ElfShdr
-
-	sh = newElfShdr(elfstrdbg[elfstr])
+	sh := newElfShdr(elfstrdbg[elfstr])
 	if Thearch.Thechar == '6' || Thearch.Thechar == '9' {
 		sh.type_ = SHT_RELA
 	} else {
@@ -2531,17 +2429,11 @@
 }
 
 func dwarfaddelfheaders() {
-	var sh *ElfShdr
-	var shinfo *ElfShdr
-	var sharanges *ElfShdr
-	var shline *ElfShdr
-	var shframe *ElfShdr
-
 	if Debug['w'] != 0 { // disable dwarf
 		return
 	}
 
-	sh = newElfShdr(elfstrdbg[ElfStrDebugAbbrev])
+	sh := newElfShdr(elfstrdbg[ElfStrDebugAbbrev])
 	sh.type_ = SHT_PROGBITS
 	sh.off = uint64(abbrevo)
 	sh.size = uint64(abbrevsize)
@@ -2558,7 +2450,7 @@
 	if linesympos > 0 {
 		putelfsymshndx(linesympos, sh.shnum)
 	}
-	shline = sh
+	shline := sh
 
 	sh = newElfShdr(elfstrdbg[ElfStrDebugFrame])
 	sh.type_ = SHT_PROGBITS
@@ -2568,7 +2460,7 @@
 	if framesympos > 0 {
 		putelfsymshndx(framesympos, sh.shnum)
 	}
-	shframe = sh
+	shframe := sh
 
 	sh = newElfShdr(elfstrdbg[ElfStrDebugInfo])
 	sh.type_ = SHT_PROGBITS
@@ -2578,10 +2470,10 @@
 	if infosympos > 0 {
 		putelfsymshndx(infosympos, sh.shnum)
 	}
-	shinfo = sh
+	shinfo := sh
 
 	if pubnamessize > 0 {
-		sh = newElfShdr(elfstrdbg[ElfStrDebugPubNames])
+		sh := newElfShdr(elfstrdbg[ElfStrDebugPubNames])
 		sh.type_ = SHT_PROGBITS
 		sh.off = uint64(pubnameso)
 		sh.size = uint64(pubnamessize)
@@ -2589,16 +2481,16 @@
 	}
 
 	if pubtypessize > 0 {
-		sh = newElfShdr(elfstrdbg[ElfStrDebugPubTypes])
+		sh := newElfShdr(elfstrdbg[ElfStrDebugPubTypes])
 		sh.type_ = SHT_PROGBITS
 		sh.off = uint64(pubtypeso)
 		sh.size = uint64(pubtypessize)
 		sh.addralign = 1
 	}
 
-	sharanges = nil
+	sharanges := (*ElfShdr)(nil)
 	if arangessize != 0 {
-		sh = newElfShdr(elfstrdbg[ElfStrDebugAranges])
+		sh := newElfShdr(elfstrdbg[ElfStrDebugAranges])
 		sh.type_ = SHT_PROGBITS
 		sh.off = uint64(arangeso)
 		sh.size = uint64(arangessize)
@@ -2607,7 +2499,7 @@
 	}
 
 	if gdbscriptsize != 0 {
-		sh = newElfShdr(elfstrdbg[ElfStrGDBScripts])
+		sh := newElfShdr(elfstrdbg[ElfStrGDBScripts])
 		sh.type_ = SHT_PROGBITS
 		sh.off = uint64(gdbscripto)
 		sh.size = uint64(gdbscriptsize)
@@ -2635,20 +2527,15 @@
  * Macho
  */
 func dwarfaddmachoheaders() {
-	var msect *MachoSect
-	var ms *MachoSeg
-	var fakestart int64
-	var nsect int
-
 	if Debug['w'] != 0 { // disable dwarf
 		return
 	}
 
 	// Zero vsize segments won't be loaded in memory, even so they
 	// have to be page aligned in the file.
-	fakestart = abbrevo &^ 0xfff
+	fakestart := abbrevo &^ 0xfff
 
-	nsect = 4
+	nsect := 4
 	if pubnamessize > 0 {
 		nsect++
 	}
@@ -2662,12 +2549,12 @@
 		nsect++
 	}
 
-	ms = newMachoSeg("__DWARF", nsect)
+	ms := newMachoSeg("__DWARF", nsect)
 	ms.fileoffset = uint64(fakestart)
 	ms.filesize = uint64(abbrevo) - uint64(fakestart)
 	ms.vaddr = ms.fileoffset + Segdata.Vaddr - Segdata.Fileoff
 
-	msect = newMachoSect(ms, "__debug_abbrev", "__DWARF")
+	msect := newMachoSect(ms, "__debug_abbrev", "__DWARF")
 	msect.off = uint32(abbrevo)
 	msect.size = uint64(abbrevsize)
 	msect.addr = uint64(msect.off) + Segdata.Vaddr - Segdata.Fileoff
@@ -2692,7 +2579,7 @@
 	ms.filesize += msect.size
 
 	if pubnamessize > 0 {
-		msect = newMachoSect(ms, "__debug_pubnames", "__DWARF")
+		msect := newMachoSect(ms, "__debug_pubnames", "__DWARF")
 		msect.off = uint32(pubnameso)
 		msect.size = uint64(pubnamessize)
 		msect.addr = uint64(msect.off) + Segdata.Vaddr - Segdata.Fileoff
@@ -2700,7 +2587,7 @@
 	}
 
 	if pubtypessize > 0 {
-		msect = newMachoSect(ms, "__debug_pubtypes", "__DWARF")
+		msect := newMachoSect(ms, "__debug_pubtypes", "__DWARF")
 		msect.off = uint32(pubtypeso)
 		msect.size = uint64(pubtypessize)
 		msect.addr = uint64(msect.off) + Segdata.Vaddr - Segdata.Fileoff
@@ -2708,7 +2595,7 @@
 	}
 
 	if arangessize > 0 {
-		msect = newMachoSect(ms, "__debug_aranges", "__DWARF")
+		msect := newMachoSect(ms, "__debug_aranges", "__DWARF")
 		msect.off = uint32(arangeso)
 		msect.size = uint64(arangessize)
 		msect.addr = uint64(msect.off) + Segdata.Vaddr - Segdata.Fileoff
@@ -2717,7 +2604,7 @@
 
 	// TODO(lvd) fix gdb/python to load MachO (16 char section name limit)
 	if gdbscriptsize > 0 {
-		msect = newMachoSect(ms, "__debug_gdb_scripts", "__DWARF")
+		msect := newMachoSect(ms, "__debug_gdb_scripts", "__DWARF")
 		msect.off = uint32(gdbscripto)
 		msect.size = uint64(gdbscriptsize)
 		msect.addr = uint64(msect.off) + Segdata.Vaddr - Segdata.Fileoff
diff --git a/src/cmd/internal/ld/elf.go b/src/cmd/internal/ld/elf.go
index f6d1043..be66fab 100644
--- a/src/cmd/internal/ld/elf.go
+++ b/src/cmd/internal/ld/elf.go
@@ -804,13 +804,11 @@
 }
 
 func elf32phdr(e *ElfPhdr) {
-	var frag int
-
 	if e.type_ == PT_LOAD {
 		// Correct ELF loaders will do this implicitly,
 		// but buggy ELF loaders like the one in some
 		// versions of QEMU won't.
-		frag = int(e.vaddr & (e.align - 1))
+		frag := int(e.vaddr & (e.align - 1))
 
 		e.off -= uint64(frag)
 		e.vaddr -= uint64(frag)
@@ -856,16 +854,14 @@
 }
 
 func elfwriteshdrs() uint32 {
-	var i int
-
 	if elf64 != 0 {
-		for i = 0; i < int(ehdr.shnum); i++ {
+		for i := 0; i < int(ehdr.shnum); i++ {
 			elf64shdr(shdr[i])
 		}
 		return uint32(ehdr.shnum) * ELF64SHDRSIZE
 	}
 
-	for i = 0; i < int(ehdr.shnum); i++ {
+	for i := 0; i < int(ehdr.shnum); i++ {
 		elf32shdr(shdr[i])
 	}
 	return uint32(ehdr.shnum) * ELF32SHDRSIZE
@@ -883,25 +879,21 @@
 }
 
 func elfwritephdrs() uint32 {
-	var i int
-
 	if elf64 != 0 {
-		for i = 0; i < int(ehdr.phnum); i++ {
+		for i := 0; i < int(ehdr.phnum); i++ {
 			elf64phdr(phdr[i])
 		}
 		return uint32(ehdr.phnum) * ELF64PHDRSIZE
 	}
 
-	for i = 0; i < int(ehdr.phnum); i++ {
+	for i := 0; i < int(ehdr.phnum); i++ {
 		elf32phdr(phdr[i])
 	}
 	return uint32(ehdr.phnum) * ELF32PHDRSIZE
 }
 
 func newElfPhdr() *ElfPhdr {
-	var e *ElfPhdr
-
-	e = new(ElfPhdr)
+	e := new(ElfPhdr)
 	if ehdr.phnum >= NSECT {
 		Diag("too many phdrs")
 	} else {
@@ -917,9 +909,7 @@
 }
 
 func newElfShdr(name int64) *ElfShdr {
-	var e *ElfShdr
-
-	e = new(ElfShdr)
+	e := new(ElfShdr)
 	e.name = uint32(name)
 	e.shnum = int(ehdr.shnum)
 	if ehdr.shnum >= NSECT {
@@ -937,9 +927,7 @@
 }
 
 func elf64writehdr() uint32 {
-	var i int
-
-	for i = 0; i < EI_NIDENT; i++ {
+	for i := 0; i < EI_NIDENT; i++ {
 		Cput(ehdr.ident[i])
 	}
 	Thearch.Wput(ehdr.type_)
@@ -959,9 +947,7 @@
 }
 
 func elf32writehdr() uint32 {
-	var i int
-
-	for i = 0; i < EI_NIDENT; i++ {
+	for i := 0; i < EI_NIDENT; i++ {
 		Cput(ehdr.ident[i])
 	}
 	Thearch.Wput(ehdr.type_)
@@ -1037,10 +1023,8 @@
 }
 
 func elfinterp(sh *ElfShdr, startva uint64, resoff uint64, p string) int {
-	var n int
-
 	interp = p
-	n = len(interp) + 1
+	n := len(interp) + 1
 	sh.addr = startva + resoff - uint64(n)
 	sh.off = resoff - uint64(n)
 	sh.size = uint64(n)
@@ -1049,9 +1033,7 @@
 }
 
 func elfwriteinterp() int {
-	var sh *ElfShdr
-
-	sh = elfshname(".interp")
+	sh := elfshname(".interp")
 	Cseek(int64(sh.off))
 	coutbuf.w.WriteString(interp)
 	Cput(0)
@@ -1059,9 +1041,7 @@
 }
 
 func elfnote(sh *ElfShdr, startva uint64, resoff uint64, sz int) int {
-	var n uint64
-
-	n = 3*4 + uint64(sz) + resoff%4
+	n := 3*4 + uint64(sz) + resoff%4
 
 	sh.type_ = SHT_NOTE
 	sh.flags = SHF_ALLOC
@@ -1074,9 +1054,7 @@
 }
 
 func elfwritenotehdr(str string, namesz uint32, descsz uint32, tag uint32) *ElfShdr {
-	var sh *ElfShdr
-
-	sh = elfshname(str)
+	sh := elfshname(str)
 
 	// Write Elf_Note header.
 	Cseek(int64(sh.off))
@@ -1099,17 +1077,13 @@
 var ELF_NOTE_NETBSD_NAME = []byte("NetBSD\x00")
 
 func elfnetbsdsig(sh *ElfShdr, startva uint64, resoff uint64) int {
-	var n int
-
-	n = int(Rnd(ELF_NOTE_NETBSD_NAMESZ, 4) + Rnd(ELF_NOTE_NETBSD_DESCSZ, 4))
+	n := int(Rnd(ELF_NOTE_NETBSD_NAMESZ, 4) + Rnd(ELF_NOTE_NETBSD_DESCSZ, 4))
 	return elfnote(sh, startva, resoff, n)
 }
 
 func elfwritenetbsdsig() int {
-	var sh *ElfShdr
-
 	// Write Elf_Note header.
-	sh = elfwritenotehdr(".note.netbsd.ident", ELF_NOTE_NETBSD_NAMESZ, ELF_NOTE_NETBSD_DESCSZ, ELF_NOTE_NETBSD_TAG)
+	sh := elfwritenotehdr(".note.netbsd.ident", ELF_NOTE_NETBSD_NAMESZ, ELF_NOTE_NETBSD_DESCSZ, ELF_NOTE_NETBSD_TAG)
 
 	if sh == nil {
 		return 0
@@ -1135,17 +1109,13 @@
 var ELF_NOTE_OPENBSD_NAME = []byte("OpenBSD\x00")
 
 func elfopenbsdsig(sh *ElfShdr, startva uint64, resoff uint64) int {
-	var n int
-
-	n = ELF_NOTE_OPENBSD_NAMESZ + ELF_NOTE_OPENBSD_DESCSZ
+	n := ELF_NOTE_OPENBSD_NAMESZ + ELF_NOTE_OPENBSD_DESCSZ
 	return elfnote(sh, startva, resoff, n)
 }
 
 func elfwriteopenbsdsig() int {
-	var sh *ElfShdr
-
 	// Write Elf_Note header.
-	sh = elfwritenotehdr(".note.openbsd.ident", ELF_NOTE_OPENBSD_NAMESZ, ELF_NOTE_OPENBSD_DESCSZ, ELF_NOTE_OPENBSD_TAG)
+	sh := elfwritenotehdr(".note.openbsd.ident", ELF_NOTE_OPENBSD_NAMESZ, ELF_NOTE_OPENBSD_DESCSZ, ELF_NOTE_OPENBSD_TAG)
 
 	if sh == nil {
 		return 0
@@ -1160,9 +1130,6 @@
 }
 
 func addbuildinfo(val string) {
-	var ov string
-	var i int
-	var b int
 	var j int
 
 	if val[0] != '0' || val[1] != 'x' {
@@ -1170,9 +1137,10 @@
 		Exit(2)
 	}
 
-	ov = val
+	ov := val
 	val = val[2:]
-	i = 0
+	i := 0
+	var b int
 	for val != "" {
 		if len(val) == 1 {
 			fmt.Fprintf(os.Stderr, "%s: -B argument must have even number of digits: %s\n", os.Args[0], ov)
@@ -1216,16 +1184,12 @@
 var ELF_NOTE_BUILDINFO_NAME = []byte("GNU\x00")
 
 func elfbuildinfo(sh *ElfShdr, startva uint64, resoff uint64) int {
-	var n int
-
-	n = int(ELF_NOTE_BUILDINFO_NAMESZ + Rnd(int64(len(buildinfo)), 4))
+	n := int(ELF_NOTE_BUILDINFO_NAMESZ + Rnd(int64(len(buildinfo)), 4))
 	return elfnote(sh, startva, resoff, n)
 }
 
 func elfwritebuildinfo() int {
-	var sh *ElfShdr
-
-	sh = elfwritenotehdr(".note.gnu.build-id", ELF_NOTE_BUILDINFO_NAMESZ, uint32(len(buildinfo)), ELF_NOTE_BUILDINFO_TAG)
+	sh := elfwritenotehdr(".note.gnu.build-id", ELF_NOTE_BUILDINFO_NAMESZ, uint32(len(buildinfo)), ELF_NOTE_BUILDINFO_TAG)
 	if sh == nil {
 		return 0
 	}
@@ -1254,7 +1218,6 @@
 
 func addelflib(list **Elflib, file string, vers string) *Elfaux {
 	var lib *Elflib
-	var aux *Elfaux
 
 	for lib = *list; lib != nil; lib = lib.next {
 		if lib.file == file {
@@ -1267,75 +1230,59 @@
 	*list = lib
 
 havelib:
-	for aux = lib.aux; aux != nil; aux = aux.next {
+	for aux := lib.aux; aux != nil; aux = aux.next {
 		if aux.vers == vers {
-			goto haveaux
+			return aux
 		}
 	}
-	aux = new(Elfaux)
+	aux := new(Elfaux)
 	aux.next = lib.aux
 	aux.vers = vers
 	lib.aux = aux
 
-haveaux:
 	return aux
 }
 
 func elfdynhash() {
-	var s *LSym
-	var sy *LSym
-	var dynstr *LSym
-	var i int
-	var j int
-	var nbucket int
-	var b int
-	var nfile int
-	var hc uint32
-	var chain []uint32
-	var buckets []uint32
-	var nsym int
-	var name string
-	var need []*Elfaux
-	var needlib *Elflib
-	var l *Elflib
-	var x *Elfaux
-
 	if !Iself {
 		return
 	}
 
-	nsym = Nelfsym
-	s = Linklookup(Ctxt, ".hash", 0)
+	nsym := Nelfsym
+	s := Linklookup(Ctxt, ".hash", 0)
 	s.Type = SELFROSECT
 	s.Reachable = true
 
-	i = nsym
-	nbucket = 1
+	i := nsym
+	nbucket := 1
 	for i > 0 {
 		nbucket++
 		i >>= 1
 	}
 
-	needlib = nil
-	need = make([]*Elfaux, nsym)
-	chain = make([]uint32, nsym)
-	buckets = make([]uint32, nbucket)
+	needlib := (*Elflib)(nil)
+	need := make([]*Elfaux, nsym)
+	chain := make([]uint32, nsym)
+	buckets := make([]uint32, nbucket)
 	if need == nil || chain == nil || buckets == nil {
 		Ctxt.Cursym = nil
 		Diag("out of memory")
 		Errorexit()
 	}
 
-	for i = 0; i < nsym; i++ {
+	for i := 0; i < nsym; i++ {
 		need[i] = nil
 	}
-	for i = 0; i < nsym; i++ {
+	for i := 0; i < nsym; i++ {
 		chain[i] = 0
 	}
-	for i = 0; i < nbucket; i++ {
+	for i := 0; i < nbucket; i++ {
 		buckets[i] = 0
 	}
-	for sy = Ctxt.Allsym; sy != nil; sy = sy.Allsym {
+	var b int
+	var hc uint32
+	var name string
+	for sy := Ctxt.Allsym; sy != nil; sy = sy.Allsym {
 		if sy.Dynid <= 0 {
 			continue
 		}
@@ -1354,20 +1301,22 @@
 
 	Adduint32(Ctxt, s, uint32(nbucket))
 	Adduint32(Ctxt, s, uint32(nsym))
-	for i = 0; i < nbucket; i++ {
+	for i := 0; i < nbucket; i++ {
 		Adduint32(Ctxt, s, buckets[i])
 	}
-	for i = 0; i < nsym; i++ {
+	for i := 0; i < nsym; i++ {
 		Adduint32(Ctxt, s, chain[i])
 	}
 
 	// version symbols
-	dynstr = Linklookup(Ctxt, ".dynstr", 0)
+	dynstr := Linklookup(Ctxt, ".dynstr", 0)
 
 	s = Linklookup(Ctxt, ".gnu.version_r", 0)
 	i = 2
-	nfile = 0
-	for l = needlib; l != nil; l = l.next {
+	nfile := 0
+	var j int
+	var x *Elfaux
+	for l := needlib; l != nil; l = l.next {
 		nfile++
 
 		// header
@@ -1405,7 +1354,7 @@
 	// version references
 	s = Linklookup(Ctxt, ".gnu.version", 0)
 
-	for i = 0; i < nsym; i++ {
+	for i := 0; i < nsym; i++ {
 		if i == 0 {
 			Adduint16(Ctxt, s, 0) // first entry - no symbol
 		} else if need[i] == nil {
@@ -1424,14 +1373,14 @@
 	}
 
 	if Thearch.Thechar == '6' || Thearch.Thechar == '9' {
-		sy = Linklookup(Ctxt, ".rela.plt", 0)
+		sy := Linklookup(Ctxt, ".rela.plt", 0)
 		if sy.Size > 0 {
 			Elfwritedynent(s, DT_PLTREL, DT_RELA)
 			elfwritedynentsymsize(s, DT_PLTRELSZ, sy)
 			elfwritedynentsym(s, DT_JMPREL, sy)
 		}
 	} else {
-		sy = Linklookup(Ctxt, ".rel.plt", 0)
+		sy := Linklookup(Ctxt, ".rel.plt", 0)
 		if sy.Size > 0 {
 			Elfwritedynent(s, DT_PLTREL, DT_REL)
 			elfwritedynentsymsize(s, DT_PLTRELSZ, sy)
@@ -1443,9 +1392,7 @@
 }
 
 func elfphload(seg *Segment) *ElfPhdr {
-	var ph *ElfPhdr
-
-	ph = newElfPhdr()
+	ph := newElfPhdr()
 	ph.type_ = PT_LOAD
 	if seg.Rwx&4 != 0 {
 		ph.flags |= PF_R
@@ -1467,45 +1414,37 @@
 }
 
 func elfshname(name string) *ElfShdr {
-	var i int
 	var off int
 	var sh *ElfShdr
 
-	for i = 0; i < nelfstr; i++ {
+	for i := 0; i < nelfstr; i++ {
 		if name == elfstr[i].s {
 			off = elfstr[i].off
-			goto found
+			for i = 0; i < int(ehdr.shnum); i++ {
+				sh = shdr[i]
+				if sh.name == uint32(off) {
+					return sh
+				}
+			}
+
+			sh = newElfShdr(int64(off))
+			return sh
 		}
 	}
 
 	Diag("cannot find elf name %s", name)
 	Errorexit()
 	return nil
-
-found:
-	for i = 0; i < int(ehdr.shnum); i++ {
-		sh = shdr[i]
-		if sh.name == uint32(off) {
-			return sh
-		}
-	}
-
-	sh = newElfShdr(int64(off))
-	return sh
 }
 
 func elfshalloc(sect *Section) *ElfShdr {
-	var sh *ElfShdr
-
-	sh = elfshname(sect.Name)
+	sh := elfshname(sect.Name)
 	sect.Elfsect = sh
 	return sh
 }
 
 func elfshbits(sect *Section) *ElfShdr {
-	var sh *ElfShdr
-
-	sh = elfshalloc(sect)
+	sh := elfshalloc(sect)
 	if sh.type_ > 0 {
 		return sh
 	}
@@ -1540,11 +1479,6 @@
 }
 
 func elfshreloc(sect *Section) *ElfShdr {
-	var typ int
-	var sh *ElfShdr
-	var prefix string
-	var buf string
-
 	// If main section is SHT_NOBITS, nothing to relocate.
 	// Also nothing to relocate in .shstrtab.
 	if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
@@ -1554,6 +1488,8 @@
 		return nil
 	}
 
+	var prefix string
+	var typ int
 	if Thearch.Thechar == '6' || Thearch.Thechar == '9' {
 		prefix = ".rela"
 		typ = SHT_RELA
@@ -1562,8 +1498,8 @@
 		typ = SHT_REL
 	}
 
-	buf = fmt.Sprintf("%s%s", prefix, sect.Name)
-	sh = elfshname(buf)
+	buf := fmt.Sprintf("%s%s", prefix, sect.Name)
+	sh := elfshname(buf)
 	sh.type_ = uint32(typ)
 	sh.entsize = uint64(Thearch.Regsize) * 2
 	if typ == SHT_RELA {
@@ -1578,11 +1514,6 @@
 }
 
 func elfrelocsect(sect *Section, first *LSym) {
-	var ri int
-	var sym *LSym
-	var eaddr int32
-	var r *Reloc
-
 	// If main section is SHT_NOBITS, nothing to relocate.
 	// Also nothing to relocate in .shstrtab.
 	if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
@@ -1593,6 +1524,7 @@
 	}
 
 	sect.Reloff = uint64(Cpos())
+	var sym *LSym
 	for sym = first; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -1602,7 +1534,9 @@
 		}
 	}
 
-	eaddr = int32(sect.Vaddr + sect.Length)
+	eaddr := int32(sect.Vaddr + sect.Length)
+	var r *Reloc
+	var ri int
 	for ; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -1635,35 +1569,29 @@
 }
 
 func Elfemitreloc() {
-	var sect *Section
-
 	for Cpos()&7 != 0 {
 		Cput(0)
 	}
 
 	elfrelocsect(Segtext.Sect, Ctxt.Textp)
-	for sect = Segtext.Sect.Next; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect.Next; sect != nil; sect = sect.Next {
 		elfrelocsect(sect, datap)
 	}
-	for sect = Segrodata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segrodata.Sect; sect != nil; sect = sect.Next {
 		elfrelocsect(sect, datap)
 	}
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		elfrelocsect(sect, datap)
 	}
 }
 
 func doelf() {
-	var s *LSym
-	var shstrtab *LSym
-	var dynstr *LSym
-
 	if !Iself {
 		return
 	}
 
 	/* predefine strings we need for section headers */
-	shstrtab = Linklookup(Ctxt, ".shstrtab", 0)
+	shstrtab := Linklookup(Ctxt, ".shstrtab", 0)
 
 	shstrtab.Type = SELFROSECT
 	shstrtab.Reachable = true
@@ -1767,7 +1695,7 @@
 		Addstring(shstrtab, ".gnu.version_r")
 
 		/* dynamic symbol table - first entry all zeros */
-		s = Linklookup(Ctxt, ".dynsym", 0)
+		s := Linklookup(Ctxt, ".dynsym", 0)
 
 		s.Type = SELFROSECT
 		s.Reachable = true
@@ -1785,7 +1713,7 @@
 		if s.Size == 0 {
 			Addstring(s, "")
 		}
-		dynstr = s
+		dynstr := s
 
 		/* relocation table */
 		if Thearch.Thechar == '6' || Thearch.Thechar == '9' {
@@ -1804,7 +1732,7 @@
 
 		/* ppc64 glink resolver */
 		if Thearch.Thechar == '9' {
-			s = Linklookup(Ctxt, ".glink", 0)
+			s := Linklookup(Ctxt, ".glink", 0)
 			s.Reachable = true
 			s.Type = SELFRXSECT
 		}
@@ -1901,8 +1829,7 @@
 
 // Do not write DT_NULL.  elfdynhash will finish it.
 func shsym(sh *ElfShdr, s *LSym) {
-	var addr int64
-	addr = Symaddr(s)
+	addr := Symaddr(s)
 	if sh.flags&SHF_ALLOC != 0 {
 		sh.addr = uint64(addr)
 	}
@@ -1920,35 +1847,22 @@
 }
 
 func Asmbelfsetup() {
-	var sect *Section
-
 	/* This null SHdr must appear before all others */
 	elfshname("")
 
-	for sect = Segtext.Sect; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect; sect != nil; sect = sect.Next {
 		elfshalloc(sect)
 	}
-	for sect = Segrodata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segrodata.Sect; sect != nil; sect = sect.Next {
 		elfshalloc(sect)
 	}
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		elfshalloc(sect)
 	}
 }
 
 func Asmbelf(symo int64) {
-	var a int64
-	var o int64
-	var startva int64
-	var resoff int64
-	var eh *ElfEhdr
-	var ph *ElfPhdr
-	var pph *ElfPhdr
-	var pnote *ElfPhdr
-	var sh *ElfShdr
-	var sect *Section
-
-	eh = getElfEhdr()
+	eh := getElfEhdr()
 	switch Thearch.Thechar {
 	default:
 		Diag("unknown architecture in asmbelf")
@@ -1968,10 +1882,11 @@
 		eh.machine = EM_PPC64
 	}
 
-	startva = INITTEXT - int64(HEADR)
-	resoff = ELFRESERVE
+	startva := INITTEXT - int64(HEADR)
+	resoff := int64(ELFRESERVE)
 
-	pph = nil
+	pph := (*ElfPhdr)(nil)
+	var pnote *ElfPhdr
 	if Linkmode == LinkExternal {
 		/* skip program headers */
 		eh.phoff = 0
@@ -1996,7 +1911,7 @@
 	 * Except on NaCl where it must not be loaded.
 	 */
 	if HEADTYPE != Hnacl {
-		o = int64(Segtext.Vaddr - pph.vaddr)
+		o := int64(Segtext.Vaddr - pph.vaddr)
 		Segtext.Vaddr -= uint64(o)
 		Segtext.Length += uint64(o)
 		o = int64(Segtext.Fileoff - pph.off)
@@ -2006,7 +1921,7 @@
 
 	if Debug['d'] == 0 {
 		/* interpreter */
-		sh = elfshname(".interp")
+		sh := elfshname(".interp")
 
 		sh.type_ = SHT_PROGBITS
 		sh.flags = SHF_ALLOC
@@ -2035,7 +1950,7 @@
 
 		resoff -= int64(elfinterp(sh, uint64(startva), uint64(resoff), interpreter))
 
-		ph = newElfPhdr()
+		ph := newElfPhdr()
 		ph.type_ = PT_INTERP
 		ph.flags = PF_R
 		phsh(ph, sh)
@@ -2043,7 +1958,7 @@
 
 	pnote = nil
 	if HEADTYPE == Hnetbsd || HEADTYPE == Hopenbsd {
-		sh = nil
+		sh := (*ElfShdr)(nil)
 		switch HEADTYPE {
 		case Hnetbsd:
 			sh = elfshname(".note.netbsd.ident")
@@ -2061,7 +1976,7 @@
 	}
 
 	if len(buildinfo) > 0 {
-		sh = elfshname(".note.gnu.build-id")
+		sh := elfshname(".note.gnu.build-id")
 		resoff -= int64(elfbuildinfo(sh, uint64(startva), uint64(resoff)))
 
 		if pnote == nil {
@@ -2083,7 +1998,7 @@
 
 	/* Dynamic linking sections */
 	if Debug['d'] == 0 {
-		sh = elfshname(".dynsym")
+		sh := elfshname(".dynsym")
 		sh.type_ = SHT_DYNSYM
 		sh.flags = SHF_ALLOC
 		if elf64 != 0 {
@@ -2104,7 +2019,7 @@
 		shsym(sh, Linklookup(Ctxt, ".dynstr", 0))
 
 		if elfverneed != 0 {
-			sh = elfshname(".gnu.version")
+			sh := elfshname(".gnu.version")
 			sh.type_ = SHT_GNU_VERSYM
 			sh.flags = SHF_ALLOC
 			sh.addralign = 2
@@ -2124,7 +2039,7 @@
 		switch eh.machine {
 		case EM_X86_64,
 			EM_PPC64:
-			sh = elfshname(".rela.plt")
+			sh := elfshname(".rela.plt")
 			sh.type_ = SHT_RELA
 			sh.flags = SHF_ALLOC
 			sh.entsize = ELF64RELASIZE
@@ -2142,7 +2057,7 @@
 			shsym(sh, Linklookup(Ctxt, ".rela", 0))
 
 		default:
-			sh = elfshname(".rel.plt")
+			sh := elfshname(".rel.plt")
 			sh.type_ = SHT_REL
 			sh.flags = SHF_ALLOC
 			sh.entsize = ELF32RELSIZE
@@ -2160,7 +2075,7 @@
 		}
 
 		if eh.machine == EM_PPC64 {
-			sh = elfshname(".glink")
+			sh := elfshname(".glink")
 			sh.type_ = SHT_PROGBITS
 			sh.flags = SHF_ALLOC + SHF_EXECINSTR
 			sh.addralign = 4
@@ -2188,7 +2103,7 @@
 		// On ppc64, .got comes from the input files, so don't
 		// create it here, and .got.plt is not used.
 		if eh.machine != EM_PPC64 {
-			sh = elfshname(".got")
+			sh := elfshname(".got")
 			sh.type_ = SHT_PROGBITS
 			sh.flags = SHF_ALLOC + SHF_WRITE
 			sh.entsize = uint64(Thearch.Regsize)
@@ -2220,7 +2135,7 @@
 		sh.addralign = uint64(Thearch.Regsize)
 		sh.link = uint32(elfshname(".dynstr").shnum)
 		shsym(sh, Linklookup(Ctxt, ".dynamic", 0))
-		ph = newElfPhdr()
+		ph := newElfPhdr()
 		ph.type_ = PT_DYNAMIC
 		ph.flags = PF_R + PF_W
 		phsh(ph, sh)
@@ -2232,7 +2147,7 @@
 		// not currently support it. This is handled
 		// appropriately in runtime/cgo.
 		if Ctxt.Tlsoffset != 0 && HEADTYPE != Hopenbsd {
-			ph = newElfPhdr()
+			ph := newElfPhdr()
 			ph.type_ = PT_TLS
 			ph.flags = PF_R
 			ph.memsz = uint64(-Ctxt.Tlsoffset)
@@ -2241,7 +2156,7 @@
 	}
 
 	if HEADTYPE == Hlinux {
-		ph = newElfPhdr()
+		ph := newElfPhdr()
 		ph.type_ = PT_GNU_STACK
 		ph.flags = PF_W + PF_R
 		ph.align = uint64(Thearch.Regsize)
@@ -2253,7 +2168,7 @@
 	}
 
 elfobj:
-	sh = elfshname(".shstrtab")
+	sh := elfshname(".shstrtab")
 	sh.type_ = SHT_STRTAB
 	sh.addralign = 1
 	shsym(sh, Linklookup(Ctxt, ".shstrtab", 0))
@@ -2265,29 +2180,29 @@
 		elfshname(".strtab")
 	}
 
-	for sect = Segtext.Sect; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect; sect != nil; sect = sect.Next {
 		elfshbits(sect)
 	}
-	for sect = Segrodata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segrodata.Sect; sect != nil; sect = sect.Next {
 		elfshbits(sect)
 	}
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		elfshbits(sect)
 	}
 
 	if Linkmode == LinkExternal {
-		for sect = Segtext.Sect; sect != nil; sect = sect.Next {
+		for sect := Segtext.Sect; sect != nil; sect = sect.Next {
 			elfshreloc(sect)
 		}
-		for sect = Segrodata.Sect; sect != nil; sect = sect.Next {
+		for sect := Segrodata.Sect; sect != nil; sect = sect.Next {
 			elfshreloc(sect)
 		}
-		for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+		for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 			elfshreloc(sect)
 		}
 
 		// add a .note.GNU-stack section to mark the stack as non-executable
-		sh = elfshname(".note.GNU-stack")
+		sh := elfshname(".note.GNU-stack")
 
 		sh.type_ = SHT_PROGBITS
 		sh.addralign = 1
@@ -2297,7 +2212,7 @@
 	// generate .tbss section for dynamic internal linking (except for OpenBSD)
 	// external linking generates .tbss in data.c
 	if Linkmode == LinkInternal && Debug['d'] == 0 && HEADTYPE != Hopenbsd {
-		sh = elfshname(".tbss")
+		sh := elfshname(".tbss")
 		sh.type_ = SHT_NOBITS
 		sh.addralign = uint64(Thearch.Regsize)
 		sh.size = uint64(-Ctxt.Tlsoffset)
@@ -2305,7 +2220,7 @@
 	}
 
 	if Debug['s'] == 0 {
-		sh = elfshname(".symtab")
+		sh := elfshname(".symtab")
 		sh.type_ = SHT_SYMTAB
 		sh.off = uint64(symo)
 		sh.size = uint64(Symsize)
@@ -2368,7 +2283,7 @@
 	}
 
 	Cseek(0)
-	a = 0
+	a := int64(0)
 	a += int64(elfwritehdr())
 	a += int64(elfwritephdrs())
 	a += int64(elfwriteshdrs())
diff --git a/src/cmd/internal/ld/go.go b/src/cmd/internal/ld/go.go
index cd85c8b..f529cea 100644
--- a/src/cmd/internal/ld/go.go
+++ b/src/cmd/internal/ld/go.go
@@ -54,11 +54,8 @@
 var nimport int
 
 func hashstr(name string) int {
-	var h uint32
-	var cp string
-
-	h = 0
-	for cp = name; cp != ""; cp = cp[1:] {
+	h := uint32(0)
+	for cp := name; cp != ""; cp = cp[1:] {
 		h = h*1119 + uint32(cp[0])
 	}
 	h &= 0xffffff
@@ -66,16 +63,13 @@
 }
 
 func ilookup(name string) *Import {
-	var h int
-	var x *Import
-
-	h = hashstr(name) % NIHASH
-	for x = ihash[h]; x != nil; x = x.hash {
+	h := hashstr(name) % NIHASH
+	for x := ihash[h]; x != nil; x = x.hash {
 		if x.name[0] == name[0] && x.name == name {
 			return x
 		}
 	}
-	x = new(Import)
+	x := new(Import)
 	x.name = name
 	x.hash = ihash[h]
 	ihash[h] = x
@@ -84,10 +78,7 @@
 }
 
 func ldpkg(f *Biobuf, pkg string, length int64, filename string, whence int) {
-	var bdata []byte
-	var data string
 	var p0, p1 int
-	var name string
 
 	if Debug['g'] != 0 {
 		return
@@ -101,7 +92,7 @@
 		return
 	}
 
-	bdata = make([]byte, length)
+	bdata := make([]byte, length)
 	if int64(Bread(f, bdata)) != length {
 		fmt.Fprintf(os.Stderr, "%s: short pkg read %s\n", os.Args[0], filename)
 		if Debug['u'] != 0 {
@@ -109,7 +100,7 @@
 		}
 		return
 	}
-	data = string(bdata)
+	data := string(bdata)
 
 	// first \n$$ marks beginning of exports - skip rest of line
 	p0 = strings.Index(data, "\n$$")
@@ -153,7 +144,7 @@
 		for p0 < p1 && (data[p0] == ' ' || data[p0] == '\t' || data[p0] == '\n') {
 			p0++
 		}
-		name = data[p0:]
+		name := data[p0:]
 		for p0 < p1 && data[p0] != ' ' && data[p0] != '\t' && data[p0] != '\n' {
 			p0++
 		}
@@ -221,14 +212,13 @@
 }
 
 func loadpkgdata(file string, pkg string, data string) {
-	var p string
 	var prefix string
 	var name string
 	var def string
 	var x *Import
 
 	file = file
-	p = data
+	p := data
 	for parsepkgdata(file, pkg, &p, &prefix, &name, &def) > 0 {
 		x = ilookup(name)
 		if x.prefix == "" {
@@ -250,15 +240,10 @@
 }
 
 func parsepkgdata(file string, pkg string, pp *string, prefixp *string, namep *string, defp *string) int {
-	var p string
 	var prefix string
-	var name string
-	var def string
-	var meth string
-	var inquote bool
 
 	// skip white space
-	p = *pp
+	p := *pp
 
 loop:
 	for len(p) > 0 && (p[0] == ' ' || p[0] == '\t' || p[0] == '\n') {
@@ -310,9 +295,9 @@
 	prefix = prefix[:len(prefix)-len(p)-1]
 
 	// name: a.b followed by space
-	name = p
+	name := p
 
-	inquote = false
+	inquote := false
 	for len(p) > 0 {
 		if p[0] == ' ' && !inquote {
 			break
@@ -334,7 +319,7 @@
 	p = p[1:]
 
 	// def: free form to new line
-	def = p
+	def := p
 
 	for len(p) > 0 && p[0] != '\n' {
 		p = p[1:]
@@ -347,6 +332,7 @@
 	p = p[1:]
 
 	// include methods on successive lines in def of named type
+	var meth string
 	for parsemethod(&p, &meth) > 0 {
 		if defbuf == nil {
 			defbuf = new(bytes.Buffer)
@@ -372,10 +358,8 @@
 }
 
 func parsemethod(pp *string, methp *string) int {
-	var p string
-
 	// skip white space
-	p = *pp
+	p := *pp
 
 	for len(p) > 0 && (p[0] == ' ' || p[0] == '\t') {
 		p = p[1:]
@@ -415,7 +399,6 @@
 
 func loadcgo(file string, pkg string, p string) {
 	var next string
-	var p0 string
 	var q string
 	var f []string
 	var local string
@@ -423,7 +406,7 @@
 	var lib string
 	var s *LSym
 
-	p0 = ""
+	p0 := ""
 	for ; p != ""; p = next {
 		if i := strings.Index(p, "\n"); i >= 0 {
 			p, next = p[:i], p[i+1:]
@@ -610,10 +593,9 @@
 
 func markflood() {
 	var a *Auto
-	var s *LSym
 	var i int
 
-	for s = markq; s != nil; s = s.Queue {
+	for s := markq; s != nil; s = s.Queue {
 		if s.Type == STEXT {
 			if Debug['v'] > 1 {
 				fmt.Fprintf(&Bso, "marktext %s\n", s.Name)
@@ -659,38 +641,32 @@
 }
 
 func deadcode() {
-	var i int
-	var s *LSym
-	var last *LSym
-	var p *LSym
-	var fmt_ string
-
 	if Debug['v'] != 0 {
 		fmt.Fprintf(&Bso, "%5.2f deadcode\n", obj.Cputime())
 	}
 
 	mark(Linklookup(Ctxt, INITENTRY, 0))
-	for i = 0; i < len(markextra); i++ {
+	for i := 0; i < len(markextra); i++ {
 		mark(Linklookup(Ctxt, markextra[i], 0))
 	}
 
-	for i = 0; i < len(dynexp); i++ {
+	for i := 0; i < len(dynexp); i++ {
 		mark(dynexp[i])
 	}
 
 	markflood()
 
 	// keep each beginning with 'typelink.' if the symbol it points at is being kept.
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if strings.HasPrefix(s.Name, "go.typelink.") {
 			s.Reachable = len(s.R) == 1 && s.R[0].Sym.Reachable
 		}
 	}
 
 	// remove dead text but keep file information (z symbols).
-	last = nil
+	last := (*LSym)(nil)
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		if !s.Reachable {
 			continue
 		}
@@ -710,7 +686,7 @@
 		last.Next = nil
 	}
 
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if strings.HasPrefix(s.Name, "go.weak.") {
 			s.Special = 1 // do not lay out in data segment
 			s.Reachable = true
@@ -719,9 +695,10 @@
 	}
 
 	// record field tracking references
-	fmt_ = ""
+	fmt_ := ""
 
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	var p *LSym
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if strings.HasPrefix(s.Name, "go.track.") {
 			s.Special = 1 // do not lay out in data segment
 			s.Hide = 1
@@ -741,7 +718,7 @@
 	if tracksym == "" {
 		return
 	}
-	s = Linklookup(Ctxt, tracksym, 0)
+	s := Linklookup(Ctxt, tracksym, 0)
 	if !s.Reachable {
 		return
 	}
@@ -749,12 +726,11 @@
 }
 
 func doweak() {
-	var s *LSym
 	var t *LSym
 
 	// resolve weak references only if
 	// target symbol will be in binary anyway.
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if strings.HasPrefix(s.Name, "go.weak.") {
 			t = Linkrlookup(Ctxt, s.Name[8:], int(s.Version))
 			if t != nil && t.Type != 0 && t.Reachable {
@@ -772,13 +748,11 @@
 }
 
 func addexport() {
-	var i int
-
 	if HEADTYPE == Hdarwin {
 		return
 	}
 
-	for i = 0; i < len(dynexp); i++ {
+	for i := 0; i < len(dynexp); i++ {
 		Thearch.Adddynsym(Ctxt, dynexp[i])
 	}
 }
@@ -840,16 +814,13 @@
 var pkgall *Pkg
 
 func getpkg(path_ string) *Pkg {
-	var p *Pkg
-	var h int
-
-	h = hashstr(path_) % len(phash)
-	for p = phash[h]; p != nil; p = p.next {
+	h := hashstr(path_) % len(phash)
+	for p := phash[h]; p != nil; p = p.next {
 		if p.path_ == path_ {
 			return p
 		}
 	}
-	p = new(Pkg)
+	p := new(Pkg)
 	p.path_ = path_
 	p.next = phash[h]
 	phash[h] = p
@@ -859,24 +830,18 @@
 }
 
 func imported(pkg string, import_ string) {
-	var p *Pkg
-	var i *Pkg
-
 	// everyone imports runtime, even runtime.
 	if import_ == "\"runtime\"" {
 		return
 	}
 
 	pkg = fmt.Sprintf("\"%v\"", Zconv(pkg, 0)) // turn pkg path into quoted form, freed below
-	p = getpkg(pkg)
-	i = getpkg(import_)
+	p := getpkg(pkg)
+	i := getpkg(import_)
 	i.impby = append(i.impby, p)
 }
 
 func cycle(p *Pkg) *Pkg {
-	var i int
-	var bad *Pkg
-
 	if p.checked != 0 {
 		return nil
 	}
@@ -889,7 +854,8 @@
 	}
 
 	p.mark = 1
-	for i = 0; i < len(p.impby); i++ {
+	var bad *Pkg
+	for i := 0; i < len(p.impby); i++ {
 		bad = cycle(p.impby[i])
 		if bad != nil {
 			p.mark = 0
@@ -908,9 +874,7 @@
 }
 
 func importcycles() {
-	var p *Pkg
-
-	for p = pkgall; p != nil; p = p.all {
+	for p := pkgall; p != nil; p = p.all {
 		cycle(p)
 	}
 }
diff --git a/src/cmd/internal/ld/ld.go b/src/cmd/internal/ld/ld.go
index 99f2fab..3397dd2 100644
--- a/src/cmd/internal/ld/ld.go
+++ b/src/cmd/internal/ld/ld.go
@@ -86,10 +86,7 @@
  *	pkg: package import path, e.g. container/vector
  */
 func addlibpath(ctxt *Link, srcref string, objref string, file string, pkg string) {
-	var i int
-	var l *Library
-
-	for i = 0; i < len(ctxt.Library); i++ {
+	for i := 0; i < len(ctxt.Library); i++ {
 		if file == ctxt.Library[i].File {
 			return
 		}
@@ -100,7 +97,7 @@
 	}
 
 	ctxt.Library = append(ctxt.Library, Library{})
-	l = &ctxt.Library[len(ctxt.Library)-1]
+	l := &ctxt.Library[len(ctxt.Library)-1]
 	l.Objref = objref
 	l.Srcref = srcref
 	l.File = file
diff --git a/src/cmd/internal/ld/ldelf.go b/src/cmd/internal/ld/ldelf.go
index c50e995..372dc18 100644
--- a/src/cmd/internal/ld/ldelf.go
+++ b/src/cmd/internal/ld/ldelf.go
@@ -285,39 +285,35 @@
 }
 
 func ldelf(f *Biobuf, pkg string, length int64, pn string) {
-	var err error
-	var base int32
-	var add uint64
-	var info uint64
-	var name string
-	var i int
-	var j int
-	var rela int
-	var is64 int
-	var n int
-	var flag int
-	var hdrbuf [64]uint8
-	var p []byte
-	var hdr *ElfHdrBytes
-	var elfobj *ElfObj
-	var sect *ElfSect
-	var rsect *ElfSect
-	var sym ElfSym
-	var e binary.ByteOrder
-	var r []Reloc
-	var rp *Reloc
-	var s *LSym
-	var symbols []*LSym
-
-	symbols = nil
+	symbols := []*LSym(nil)
 
 	if Debug['v'] != 0 {
 		fmt.Fprintf(&Bso, "%5.2f ldelf %s\n", obj.Cputime(), pn)
 	}
 
 	Ctxt.Version++
-	base = int32(Boffset(f))
+	base := int32(Boffset(f))
 
+	var add uint64
+	var e binary.ByteOrder
+	var elfobj *ElfObj
+	var err error
+	var flag int
+	var hdr *ElfHdrBytes
+	var hdrbuf [64]uint8
+	var info uint64
+	var is64 int
+	var j int
+	var n int
+	var name string
+	var p []byte
+	var r []Reloc
+	var rela int
+	var rp *Reloc
+	var rsect *ElfSect
+	var s *LSym
+	var sect *ElfSect
+	var sym ElfSym
 	if Bread(f, hdrbuf[:]) != len(hdrbuf) {
 		goto bad
 	}
@@ -348,10 +344,8 @@
 
 	is64 = 0
 	if hdr.Ident[4] == ElfClass64 {
-		var hdr *ElfHdrBytes64
-
 		is64 = 1
-		hdr = new(ElfHdrBytes64)
+		hdr := new(ElfHdrBytes64)
 		binary.Read(bytes.NewReader(hdrbuf[:]), binary.BigEndian, hdr) // only byte arrays; byte order doesn't matter
 		elfobj.type_ = uint32(e.Uint16(hdr.Type[:]))
 		elfobj.machine = uint32(e.Uint16(hdr.Machine[:]))
@@ -426,7 +420,7 @@
 	elfobj.sect = make([]ElfSect, elfobj.shnum)
 
 	elfobj.nsect = uint(elfobj.shnum)
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		if Bseek(f, int64(uint64(base)+elfobj.shoff+uint64(int64(i)*int64(elfobj.shentsize))), 0) < 0 {
 			goto bad
 		}
@@ -478,7 +472,7 @@
 	if err = elfmap(elfobj, sect); err != nil {
 		goto bad
 	}
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		if elfobj.sect[i].nameoff != 0 {
 			elfobj.sect[i].name = cstring(sect.base[elfobj.sect[i].nameoff:])
 		}
@@ -517,7 +511,7 @@
 	// as well use one large chunk.
 
 	// create symbols for elfmapped sections
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		sect = &elfobj.sect[i]
 		if (sect.type_ != ElfSectProgbits && sect.type_ != ElfSectNobits) || sect.flags&ElfSectFlagAlloc == 0 {
 			continue
@@ -572,7 +566,7 @@
 		Errorexit()
 	}
 
-	for i = 1; i < elfobj.nsymtab; i++ {
+	for i := 1; i < elfobj.nsymtab; i++ {
 		if err = readelfsym(elfobj, i, &sym, 1); err != nil {
 			goto bad
 		}
@@ -645,7 +639,7 @@
 
 	// Sort outer lists by address, adding to textp.
 	// This keeps textp in increasing address order.
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		s = elfobj.sect[i].sym
 		if s == nil {
 			continue
@@ -676,7 +670,7 @@
 	}
 
 	// load relocations
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		rsect = &elfobj.sect[i]
 		if rsect.type_ != ElfSectRela && rsect.type_ != ElfSectRel {
 			continue
@@ -782,9 +776,7 @@
 }
 
 func section(elfobj *ElfObj, name string) *ElfSect {
-	var i int
-
-	for i = 0; uint(i) < elfobj.nsect; i++ {
+	for i := 0; uint(i) < elfobj.nsect; i++ {
 		if elfobj.sect[i].name != "" && name != "" && elfobj.sect[i].name == name {
 			return &elfobj.sect[i]
 		}
@@ -812,8 +804,6 @@
 }
 
 func readelfsym(elfobj *ElfObj, i int, sym *ElfSym, needSym int) (err error) {
-	var s *LSym
-
 	if i >= elfobj.nsymtab || i < 0 {
 		err = fmt.Errorf("invalid elf symbol index")
 		return err
@@ -845,7 +835,7 @@
 		sym.other = b.Other
 	}
 
-	s = nil
+	s := (*LSym)(nil)
 	if sym.name == "_GLOBAL_OFFSET_TABLE_" {
 		sym.name = ".got"
 	}
@@ -940,11 +930,8 @@
 }
 
 func (x rbyoff) Less(i, j int) bool {
-	var a *Reloc
-	var b *Reloc
-
-	a = &x[i]
-	b = &x[j]
+	a := &x[i]
+	b := &x[j]
 	if a.Off < b.Off {
 		return true
 	}
diff --git a/src/cmd/internal/ld/ldmacho.go b/src/cmd/internal/ld/ldmacho.go
index e762318..58f065a 100644
--- a/src/cmd/internal/ld/ldmacho.go
+++ b/src/cmd/internal/ld/ldmacho.go
@@ -172,13 +172,8 @@
 )
 
 func unpackcmd(p []byte, m *LdMachoObj, c *LdMachoCmd, type_ uint, sz uint) int {
-	var e4 func([]byte) uint32
-	var e8 func([]byte) uint64
-	var s *LdMachoSect
-	var i int
-
-	e4 = m.e.Uint32
-	e8 = m.e.Uint64
+	e4 := m.e.Uint32
+	e8 := m.e.Uint64
 
 	c.type_ = int(type_)
 	c.size = uint32(sz)
@@ -204,7 +199,8 @@
 			return -1
 		}
 		p = p[56:]
-		for i = 0; uint32(i) < c.seg.nsect; i++ {
+		var s *LdMachoSect
+		for i := 0; uint32(i) < c.seg.nsect; i++ {
 			s = &c.seg.sect[i]
 			s.name = cstring(p[0:16])
 			s.segname = cstring(p[16:32])
@@ -238,7 +234,8 @@
 			return -1
 		}
 		p = p[72:]
-		for i = 0; uint32(i) < c.seg.nsect; i++ {
+		var s *LdMachoSect
+		for i := 0; uint32(i) < c.seg.nsect; i++ {
 			s = &c.seg.sect[i]
 			s.name = cstring(p[0:16])
 			s.segname = cstring(p[16:32])
@@ -293,24 +290,19 @@
 }
 
 func macholoadrel(m *LdMachoObj, sect *LdMachoSect) int {
-	var rel []LdMachoRel
-	var r *LdMachoRel
-	var buf []byte
-	var p []byte
-	var i int
-	var n int
-	var v uint32
-
 	if sect.rel != nil || sect.nreloc == 0 {
 		return 0
 	}
-	rel = make([]LdMachoRel, sect.nreloc)
-	n = int(sect.nreloc * 8)
-	buf = make([]byte, n)
+	rel := make([]LdMachoRel, sect.nreloc)
+	n := int(sect.nreloc * 8)
+	buf := make([]byte, n)
 	if Bseek(m.f, m.base+int64(sect.reloff), 0) < 0 || Bread(m.f, buf) != n {
 		return -1
 	}
-	for i = 0; uint32(i) < sect.nreloc; i++ {
+	var p []byte
+	var r *LdMachoRel
+	var v uint32
+	for i := 0; uint32(i) < sect.nreloc; i++ {
 		r = &rel[i]
 		p = buf[i*8:]
 		r.addr = m.e.Uint32(p)
@@ -347,56 +339,44 @@
 }
 
 func macholoaddsym(m *LdMachoObj, d *LdMachoDysymtab) int {
-	var p []byte
-	var i int
-	var n int
+	n := int(d.nindirectsyms)
 
-	n = int(d.nindirectsyms)
-
-	p = make([]byte, n*4)
+	p := make([]byte, n*4)
 	if Bseek(m.f, m.base+int64(d.indirectsymoff), 0) < 0 || Bread(m.f, p) != len(p) {
 		return -1
 	}
 
 	d.indir = make([]uint32, n)
-	for i = 0; i < n; i++ {
+	for i := 0; i < n; i++ {
 		d.indir[i] = m.e.Uint32(p[4*i:])
 	}
 	return 0
 }
 
 func macholoadsym(m *LdMachoObj, symtab *LdMachoSymtab) int {
-	var strbuf []byte
-	var symbuf []byte
-	var p []byte
-	var i int
-	var n int
-	var symsize int
-	var sym []LdMachoSym
-	var s *LdMachoSym
-	var v uint32
-
 	if symtab.sym != nil {
 		return 0
 	}
 
-	strbuf = make([]byte, symtab.strsize)
+	strbuf := make([]byte, symtab.strsize)
 	if Bseek(m.f, m.base+int64(symtab.stroff), 0) < 0 || Bread(m.f, strbuf) != len(strbuf) {
 		return -1
 	}
 
-	symsize = 12
+	symsize := 12
 	if m.is64 {
 		symsize = 16
 	}
-	n = int(symtab.nsym * uint32(symsize))
-	symbuf = make([]byte, n)
+	n := int(symtab.nsym * uint32(symsize))
+	symbuf := make([]byte, n)
 	if Bseek(m.f, m.base+int64(symtab.symoff), 0) < 0 || Bread(m.f, symbuf) != len(symbuf) {
 		return -1
 	}
-	sym = make([]LdMachoSym, symtab.nsym)
-	p = symbuf
-	for i = 0; uint32(i) < symtab.nsym; i++ {
+	sym := make([]LdMachoSym, symtab.nsym)
+	p := symbuf
+	var s *LdMachoSym
+	var v uint32
+	for i := 0; uint32(i) < symtab.nsym; i++ {
 		s = &sym[i]
 		v = m.e.Uint32(p)
 		if v >= symtab.strsize {
@@ -421,13 +401,11 @@
 
 func ldmacho(f *Biobuf, pkg string, length int64, pn string) {
 	var err error
-	var i int
 	var j int
 	var is64 bool
 	var secaddr uint64
 	var hdr [7 * 4]uint8
 	var cmdp []byte
-	var tmp [4]uint8
 	var dat []byte
 	var ncmd uint32
 	var cmdsz uint32
@@ -436,7 +414,6 @@
 	var off uint32
 	var m *LdMachoObj
 	var e binary.ByteOrder
-	var base int64
 	var sect *LdMachoSect
 	var rel *LdMachoRel
 	var rpi int
@@ -452,7 +429,7 @@
 	var name string
 
 	Ctxt.Version++
-	base = Boffset(f)
+	base := Boffset(f)
 	if Bread(f, hdr[:]) != len(hdr) {
 		goto bad
 	}
@@ -475,6 +452,7 @@
 	}
 
 	if is64 {
+		var tmp [4]uint8
 		Bread(f, tmp[:4]) // skip reserved word in header
 	}
 
@@ -524,7 +502,7 @@
 	symtab = nil
 	dsymtab = nil
 
-	for i = 0; uint32(i) < ncmd; i++ {
+	for i := 0; uint32(i) < ncmd; i++ {
 		ty = e.Uint32(cmdp)
 		sz = e.Uint32(cmdp[4:])
 		m.cmd[i].off = off
@@ -581,7 +559,7 @@
 		goto bad
 	}
 
-	for i = 0; uint32(i) < c.seg.nsect; i++ {
+	for i := 0; uint32(i) < c.seg.nsect; i++ {
 		sect = &c.seg.sect[i]
 		if sect.segname != "__TEXT" && sect.segname != "__DATA" {
 			continue
@@ -623,8 +601,7 @@
 
 	// enter sub-symbols into symbol table.
 	// have to guess sizes from next symbol.
-	for i = 0; uint32(i) < symtab.nsym; i++ {
-		var v int
+	for i := 0; uint32(i) < symtab.nsym; i++ {
 		sym = &symtab.sym[i]
 		if sym.type_&N_STAB != 0 {
 			continue
@@ -636,7 +613,7 @@
 		if name[0] == '_' && name[1] != '\x00' {
 			name = name[1:]
 		}
-		v = 0
+		v := 0
 		if sym.type_&N_EXT == 0 {
 			v = Ctxt.Version
 		}
@@ -688,7 +665,7 @@
 
 	// Sort outer lists by address, adding to textp.
 	// This keeps textp in increasing address order.
-	for i = 0; uint32(i) < c.seg.nsect; i++ {
+	for i := 0; uint32(i) < c.seg.nsect; i++ {
 		sect = &c.seg.sect[i]
 		s = sect.sym
 		if s == nil {
@@ -730,7 +707,7 @@
 	}
 
 	// load relocations
-	for i = 0; uint32(i) < c.seg.nsect; i++ {
+	for i := 0; uint32(i) < c.seg.nsect; i++ {
 		sect = &c.seg.sect[i]
 		s = sect.sym
 		if s == nil {
@@ -746,9 +723,6 @@
 			rp = &r[rpi]
 			rel = &sect.rel[j]
 			if rel.scattered != 0 {
-				var k int
-				var ks *LdMachoSect
-
 				if Thearch.Thechar != '8' {
 					// mach-o only uses scattered relocation on 32-bit platforms
 					Diag("unexpected scattered relocation")
@@ -792,54 +766,53 @@
 
 				// now consider the desired symbol.
 				// find the section where it lives.
-				for k = 0; uint32(k) < c.seg.nsect; k++ {
+				var ks *LdMachoSect
+				for k := 0; uint32(k) < c.seg.nsect; k++ {
 					ks = &c.seg.sect[k]
 					if ks.addr <= uint64(rel.value) && uint64(rel.value) < ks.addr+ks.size {
-						goto foundk
+						if ks.sym != nil {
+							rp.Sym = ks.sym
+							rp.Add += int64(uint64(rel.value) - ks.addr)
+						} else if ks.segname == "__IMPORT" && ks.name == "__pointers" {
+							// handle reference to __IMPORT/__pointers.
+							// how much worse can this get?
+							// why are we supporting 386 on the mac anyway?
+							rp.Type = 512 + MACHO_FAKE_GOTPCREL
+
+							// figure out which pointer this is a reference to.
+							k = int(uint64(ks.res1) + (uint64(rel.value)-ks.addr)/4)
+
+							// load indirect table for __pointers
+							// fetch symbol number
+							if dsymtab == nil || k < 0 || uint32(k) >= dsymtab.nindirectsyms || dsymtab.indir == nil {
+								err = fmt.Errorf("invalid scattered relocation: indirect symbol reference out of range")
+								goto bad
+							}
+
+							k = int(dsymtab.indir[k])
+							if k < 0 || uint32(k) >= symtab.nsym {
+								err = fmt.Errorf("invalid scattered relocation: symbol reference out of range")
+								goto bad
+							}
+
+							rp.Sym = symtab.sym[k].sym
+						} else {
+							err = fmt.Errorf("unsupported scattered relocation: reference to %s/%s", ks.segname, ks.name)
+							goto bad
+						}
+
+						rpi++
+
+						// skip #1 of 2 rel; continue skips #2 of 2.
+						j++
+
+						continue
 					}
 				}
 
 				err = fmt.Errorf("unsupported scattered relocation: invalid address %#x", rel.addr)
 				goto bad
 
-			foundk:
-				if ks.sym != nil {
-					rp.Sym = ks.sym
-					rp.Add += int64(uint64(rel.value) - ks.addr)
-				} else if ks.segname == "__IMPORT" && ks.name == "__pointers" {
-					// handle reference to __IMPORT/__pointers.
-					// how much worse can this get?
-					// why are we supporting 386 on the mac anyway?
-					rp.Type = 512 + MACHO_FAKE_GOTPCREL
-
-					// figure out which pointer this is a reference to.
-					k = int(uint64(ks.res1) + (uint64(rel.value)-ks.addr)/4)
-
-					// load indirect table for __pointers
-					// fetch symbol number
-					if dsymtab == nil || k < 0 || uint32(k) >= dsymtab.nindirectsyms || dsymtab.indir == nil {
-						err = fmt.Errorf("invalid scattered relocation: indirect symbol reference out of range")
-						goto bad
-					}
-
-					k = int(dsymtab.indir[k])
-					if k < 0 || uint32(k) >= symtab.nsym {
-						err = fmt.Errorf("invalid scattered relocation: symbol reference out of range")
-						goto bad
-					}
-
-					rp.Sym = symtab.sym[k].sym
-				} else {
-					err = fmt.Errorf("unsupported scattered relocation: reference to %s/%s", ks.segname, ks.name)
-					goto bad
-				}
-
-				rpi++
-
-				// skip #1 of 2 rel; continue skips #2 of 2.
-				j++
-
-				continue
 			}
 
 			rp.Siz = rel.length
diff --git a/src/cmd/internal/ld/ldpe.go b/src/cmd/internal/ld/ldpe.go
index 247e829..0daf887 100644
--- a/src/cmd/internal/ld/ldpe.go
+++ b/src/cmd/internal/ld/ldpe.go
@@ -127,36 +127,31 @@
 }
 
 func ldpe(f *Biobuf, pkg string, length int64, pn string) {
-	var err error
-	var name string
-	var base int32
-	var l uint32
-	var i int
-	var j int
-	var numaux int
-	var peobj *PeObj
-	var sect *PeSect
-	var rsect *PeSect
-	var symbuf [18]uint8
-	var s *LSym
-	var r []Reloc
-	var rp *Reloc
-	var sym *PeSym
-
 	if Debug['v'] != 0 {
 		fmt.Fprintf(&Bso, "%5.2f ldpe %s\n", obj.Cputime(), pn)
 	}
 
-	sect = nil
+	sect := (*PeSect)(nil)
 	Ctxt.Version++
-	base = int32(Boffset(f))
+	base := int32(Boffset(f))
 
-	peobj = new(PeObj)
+	peobj := new(PeObj)
 	peobj.f = f
 	peobj.base = uint32(base)
 	peobj.name = pn
 
 	// read header
+	var err error
+	var j int
+	var l uint32
+	var name string
+	var numaux int
+	var r []Reloc
+	var rp *Reloc
+	var rsect *PeSect
+	var s *LSym
+	var sym *PeSym
+	var symbuf [18]uint8
 	if err = binary.Read(f, binary.LittleEndian, &peobj.fh); err != nil {
 		goto bad
 	}
@@ -165,7 +160,7 @@
 	peobj.sect = make([]PeSect, peobj.fh.NumberOfSections)
 
 	peobj.nsect = uint(peobj.fh.NumberOfSections)
-	for i = 0; i < int(peobj.fh.NumberOfSections); i++ {
+	for i := 0; i < int(peobj.fh.NumberOfSections); i++ {
 		if err = binary.Read(f, binary.LittleEndian, &peobj.sect[i].sh); err != nil {
 			goto bad
 		}
@@ -189,7 +184,7 @@
 	}
 
 	// rewrite section names if they start with /
-	for i = 0; i < int(peobj.fh.NumberOfSections); i++ {
+	for i := 0; i < int(peobj.fh.NumberOfSections); i++ {
 		if peobj.sect[i].name == "" {
 			continue
 		}
@@ -205,7 +200,7 @@
 
 	peobj.npesym = uint(peobj.fh.NumberOfSymbols)
 	Bseek(f, int64(base)+int64(peobj.fh.PointerToSymbolTable), 0)
-	for i = 0; uint32(i) < peobj.fh.NumberOfSymbols; i += numaux + 1 {
+	for i := 0; uint32(i) < peobj.fh.NumberOfSymbols; i += numaux + 1 {
 		Bseek(f, int64(base)+int64(peobj.fh.PointerToSymbolTable)+int64(len(symbuf))*int64(i), 0)
 		if Bread(f, symbuf[:]) != len(symbuf) {
 			goto bad
@@ -230,7 +225,7 @@
 	}
 
 	// create symbols for mapped sections
-	for i = 0; uint(i) < peobj.nsect; i++ {
+	for i := 0; uint(i) < peobj.nsect; i++ {
 		sect = &peobj.sect[i]
 		if sect.sh.Characteristics&IMAGE_SCN_MEM_DISCARDABLE != 0 {
 			continue
@@ -277,7 +272,7 @@
 	}
 
 	// load relocations
-	for i = 0; uint(i) < peobj.nsect; i++ {
+	for i := 0; uint(i) < peobj.nsect; i++ {
 		rsect = &peobj.sect[i]
 		if rsect.sym == nil || rsect.sh.NumberOfRelocations == 0 {
 			continue
@@ -298,12 +293,9 @@
 			if Bread(f, symbuf[:10]) != 10 {
 				goto bad
 			}
-			var rva uint32
-			var symindex uint32
-			var type_ uint16
-			rva = Le32(symbuf[0:])
-			symindex = Le32(symbuf[4:])
-			type_ = Le16(symbuf[8:])
+			rva := Le32(symbuf[0:])
+			symindex := Le32(symbuf[4:])
+			type_ := Le16(symbuf[8:])
 			if err = readpesym(peobj, int(symindex), &sym); err != nil {
 				goto bad
 			}
@@ -360,7 +352,7 @@
 	}
 
 	// enter sub-symbols into symbol table.
-	for i = 0; uint(i) < peobj.npesym; i++ {
+	for i := 0; uint(i) < peobj.npesym; i++ {
 		if peobj.pesym[i].name == "" {
 			continue
 		}
@@ -429,7 +421,7 @@
 
 	// Sort outer lists by address, adding to textp.
 	// This keeps textp in increasing address order.
-	for i = 0; uint(i) < peobj.nsect; i++ {
+	for i := 0; uint(i) < peobj.nsect; i++ {
 		s = peobj.sect[i].sym
 		if s == nil {
 			continue
@@ -486,18 +478,15 @@
 }
 
 func readpesym(peobj *PeObj, i int, y **PeSym) (err error) {
-	var s *LSym
-	var sym *PeSym
-	var name string
-
 	if uint(i) >= peobj.npesym || i < 0 {
 		err = fmt.Errorf("invalid pe symbol index")
 		return err
 	}
 
-	sym = &peobj.pesym[i]
+	sym := &peobj.pesym[i]
 	*y = sym
 
+	var name string
 	if issect(sym) {
 		name = peobj.sect[sym.sectnum-1].sym.Name
 	} else {
@@ -515,6 +504,7 @@
 		name = name[:i]
 	}
 
+	var s *LSym
 	switch sym.type_ {
 	default:
 		err = fmt.Errorf("%s: invalid symbol type %d", sym.name, sym.type_)
diff --git a/src/cmd/internal/ld/lib.go b/src/cmd/internal/ld/lib.go
index bc58fff..030ddbf 100644
--- a/src/cmd/internal/ld/lib.go
+++ b/src/cmd/internal/ld/lib.go
@@ -294,16 +294,13 @@
 }
 
 func libinit() {
-	var suffix string
-	var suffixsep string
-
 	Funcalign = Thearch.Funcalign
 	mywhatsys() // get goroot, goarch, goos
 
 	// add goroot to the end of the libdir list.
-	suffix = ""
+	suffix := ""
 
-	suffixsep = ""
+	suffixsep := ""
 	if flag_installsuffix != "" {
 		suffixsep = "_"
 		suffix = flag_installsuffix
@@ -353,11 +350,9 @@
 
 func loadinternal(name string) {
 	var pname string
-	var i int
-	var found int
 
-	found = 0
-	for i = 0; i < len(Ctxt.Libdir); i++ {
+	found := 0
+	for i := 0; i < len(Ctxt.Libdir); i++ {
 		pname = fmt.Sprintf("%s/%s.a", Ctxt.Libdir[i], name)
 		if Debug['v'] != 0 {
 			fmt.Fprintf(&Bso, "searching for %s.a in %s\n", name, pname)
@@ -375,15 +370,8 @@
 }
 
 func loadlib() {
-	var i int
-	var w int
-	var x int
-	var s *LSym
-	var tlsg *LSym
-	var cgostrsym string
-
 	if Flag_shared != 0 {
-		s = Linklookup(Ctxt, "runtime.islibrary", 0)
+		s := Linklookup(Ctxt, "runtime.islibrary", 0)
 		s.Dupok = 1
 		Adduint8(Ctxt, s, 1)
 	}
@@ -396,6 +384,7 @@
 		loadinternal("runtime/race")
 	}
 
+	var i int
 	for i = 0; i < len(Ctxt.Library); i++ {
 		if Debug['v'] > 1 {
 			fmt.Fprintf(&Bso, "%5.2f autolib: %s (from %s)\n", obj.Cputime(), Ctxt.Library[i].File, Ctxt.Library[i].Objref)
@@ -438,7 +427,7 @@
 		}
 
 		// Pretend that we really imported the package.
-		s = Linklookup(Ctxt, "go.importpath.runtime/cgo.", 0)
+		s := Linklookup(Ctxt, "go.importpath.runtime/cgo.", 0)
 
 		s.Type = SDATA
 		s.Dupok = 1
@@ -446,10 +435,10 @@
 
 		// Provided by the code that imports the package.
 		// Since we are simulating the import, we have to provide this string.
-		cgostrsym = "go.string.\"runtime/cgo\""
+		cgostrsym := "go.string.\"runtime/cgo\""
 
 		if Linkrlookup(Ctxt, cgostrsym, 0) == nil {
-			s = Linklookup(Ctxt, cgostrsym, 0)
+			s := Linklookup(Ctxt, cgostrsym, 0)
 			s.Type = SRODATA
 			s.Reachable = true
 			addstrdata(cgostrsym, "runtime/cgo")
@@ -459,7 +448,7 @@
 	if Linkmode == LinkInternal {
 		// Drop all the cgo_import_static declarations.
 		// Turns out we won't be needing them.
-		for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+		for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 			if s.Type == SHOSTOBJ {
 				// If a symbol was marked both
 				// cgo_import_static and cgo_import_dynamic,
@@ -474,7 +463,7 @@
 		}
 	}
 
-	tlsg = Linklookup(Ctxt, "runtime.tlsg", 0)
+	tlsg := Linklookup(Ctxt, "runtime.tlsg", 0)
 
 	// For most ports, runtime.tlsg is a placeholder symbol for TLS
 	// relocation. However, the Android and Darwin arm ports need it
@@ -492,13 +481,13 @@
 	Ctxt.Tlsg = tlsg
 
 	// Now that we know the link mode, trim the dynexp list.
-	x = CgoExportDynamic
+	x := CgoExportDynamic
 
 	if Linkmode == LinkExternal {
 		x = CgoExportStatic
 	}
-	w = 0
-	for i = 0; i < len(dynexp); i++ {
+	w := 0
+	for i := 0; i < len(dynexp); i++ {
 		if int(dynexp[i].Cgoexport)&x != 0 {
 			dynexp[w] = dynexp[i]
 			w++
@@ -564,12 +553,6 @@
 }
 
 func objfile(file string, pkg string) {
-	var off int64
-	var l int64
-	var f *Biobuf
-	var pname string
-	var arhdr ArHdr
-
 	pkg = pathtoprefix(pkg)
 
 	if Debug['v'] > 1 {
@@ -577,6 +560,7 @@
 	}
 	Bflush(&Bso)
 	var err error
+	var f *Biobuf
 	f, err = Bopenr(file)
 	if err != nil {
 		Diag("cannot open file %s: %v", file, err)
@@ -586,7 +570,7 @@
 	magbuf := make([]byte, len(ARMAG))
 	if Bread(f, magbuf) != len(magbuf) || !strings.HasPrefix(string(magbuf), ARMAG) {
 		/* load it as a regular file */
-		l = Bseek(f, 0, 2)
+		l := Bseek(f, 0, 2)
 
 		Bseek(f, 0, 0)
 		ldobj(f, pkg, l, file, file, FileObj)
@@ -596,9 +580,11 @@
 	}
 
 	/* skip over optional __.GOSYMDEF and process __.PKGDEF */
-	off = Boffset(f)
+	off := Boffset(f)
 
-	l = nextar(f, off, &arhdr)
+	var arhdr ArHdr
+	l := nextar(f, off, &arhdr)
+	var pname string
 	if l <= 0 {
 		Diag("%s: short read on archive file symbol header", file)
 		goto out
@@ -684,12 +670,8 @@
 }
 
 func ldhostobj(ld func(*Biobuf, string, int64, string), f *Biobuf, pkg string, length int64, pn string, file string) {
-	var i int
-	var isinternal int
-	var h *Hostobj
-
-	isinternal = 0
-	for i = 0; i < len(internalpkg); i++ {
+	isinternal := 0
+	for i := 0; i < len(internalpkg); i++ {
 		if pkg == internalpkg[i] {
 			isinternal = 1
 			break
@@ -713,7 +695,7 @@
 	}
 
 	hostobj = append(hostobj, Hostobj{})
-	h = &hostobj[len(hostobj)-1]
+	h := &hostobj[len(hostobj)-1]
 	h.ld = ld
 	h.pkg = pkg
 	h.pn = pn
@@ -723,11 +705,10 @@
 }
 
 func hostobjs() {
-	var i int
 	var f *Biobuf
 	var h *Hostobj
 
-	for i = 0; i < len(hostobj); i++ {
+	for i := 0; i < len(hostobj); i++ {
 		h = &hostobj[i]
 		var err error
 		f, err = Bopenr(h.file)
@@ -750,8 +731,6 @@
 }
 
 func hostlinksetup() {
-	var p string
-
 	if Linkmode != LinkExternal {
 		return
 	}
@@ -769,7 +748,7 @@
 	// change our output to temporary object file
 	cout.Close()
 
-	p = fmt.Sprintf("%s/go.o", tmpdir)
+	p := fmt.Sprintf("%s/go.o", tmpdir)
 	var err error
 	cout, err = os.OpenFile(p, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0775)
 	if err != nil {
@@ -783,14 +762,6 @@
 var hostlink_buf = make([]byte, 64*1024)
 
 func hostlink() {
-	var p string
-	var argv []string
-	var i int
-	var n int
-	var length int
-	var h *Hostobj
-	var f *Biobuf
-
 	if Linkmode != LinkExternal || nerrors > 0 {
 		return
 	}
@@ -798,6 +769,7 @@
 	if extld == "" {
 		extld = "gcc"
 	}
+	var argv []string
 	argv = append(argv, extld)
 	switch Thearch.Thechar {
 	case '8':
@@ -851,7 +823,12 @@
 
 	// already wrote main object file
 	// copy host objects to temporary directory
-	for i = 0; i < len(hostobj); i++ {
+	var f *Biobuf
+	var h *Hostobj
+	var length int
+	var n int
+	var p string
+	for i := 0; i < len(hostobj); i++ {
 		h = &hostobj[i]
 		var err error
 		f, err = Bopenr(h.file)
@@ -886,7 +863,7 @@
 			length -= n
 		}
 
-		if err = w.Close(); err != nil {
+		if err := w.Close(); err != nil {
 			Ctxt.Cursym = nil
 			Diag("cannot write %s: %v", p, err)
 			Errorexit()
@@ -896,6 +873,7 @@
 	}
 
 	argv = append(argv, fmt.Sprintf("%s/go.o", tmpdir))
+	var i int
 	for i = 0; i < len(ldflag); i++ {
 		argv = append(argv, ldflag[i])
 	}
@@ -935,30 +913,18 @@
 }
 
 func ldobj(f *Biobuf, pkg string, length int64, pn string, file string, whence int) {
-	var line string
-	var c1 int
-	var c2 int
-	var c3 int
-	var c4 int
-	var magic uint32
-	var import0 int64
-	var import1 int64
-	var eof int64
-	var start int64
-	var t string
-
-	eof = Boffset(f) + length
+	eof := Boffset(f) + length
 
 	pn = pn
 
-	start = Boffset(f)
-	c1 = Bgetc(f)
-	c2 = Bgetc(f)
-	c3 = Bgetc(f)
-	c4 = Bgetc(f)
+	start := Boffset(f)
+	c1 := Bgetc(f)
+	c2 := Bgetc(f)
+	c3 := Bgetc(f)
+	c4 := Bgetc(f)
 	Bseek(f, start, 0)
 
-	magic = uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
+	magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
 	if magic == 0x7f454c46 { // \x7F E L F
 		ldhostobj(ldelf, f, pkg, length, pn, file)
 		return
@@ -975,8 +941,11 @@
 	}
 
 	/* check the header */
-	line = Brdline(f, '\n')
+	line := Brdline(f, '\n')
 
+	var import0 int64
+	var import1 int64
+	var t string
 	if line == "" {
 		if Blinelen(f) > 0 {
 			Diag("%s: not an object file", pn)
@@ -1055,9 +1024,7 @@
 }
 
 func zerosig(sp string) {
-	var s *LSym
-
-	s = Linklookup(Ctxt, sp, 0)
+	s := Linklookup(Ctxt, sp, 0)
 	s.Sig = 0
 }
 
@@ -1097,44 +1064,40 @@
 	for i := 0; i < len(s); i++ {
 		c := s[i]
 		if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
-			goto escape
+			var buf bytes.Buffer
+			for i := 0; i < len(s); i++ {
+				c := s[i]
+				if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
+					fmt.Fprintf(&buf, "%%%02x", c)
+					continue
+				}
+				buf.WriteByte(c)
+			}
+			return buf.String()
 		}
 	}
 	return s
-
-escape:
-	var buf bytes.Buffer
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
-			fmt.Fprintf(&buf, "%%%02x", c)
-			continue
-		}
-		buf.WriteByte(c)
-	}
-	return buf.String()
 }
 
 func iconv(p string) string {
-	var fp string
-
 	if p == "" {
+		var fp string
 		fp += "<nil>"
 		return fp
 	}
 
 	p = pathtoprefix(p)
+	var fp string
 	fp += p
 	return fp
 }
 
 func addsection(seg *Segment, name string, rwx int) *Section {
 	var l **Section
-	var sect *Section
 
 	for l = &seg.Sect; *l != nil; l = &(*l).Next {
 	}
-	sect = new(Section)
+	sect := new(Section)
 	sect.Rwx = uint8(rwx)
 	sect.Name = name
 	sect.Seg = seg
@@ -1197,7 +1160,6 @@
 
 func dostkcheck() {
 	var ch Chain
-	var s *LSym
 
 	morestack = Linklookup(Ctxt, "runtime.morestack", 0)
 	newstack = Linklookup(Ctxt, "runtime.newstack", 0)
@@ -1215,7 +1177,7 @@
 
 	// Check every function, but do the nosplit functions in a first pass,
 	// to make the printed failure chains as short as possible.
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		// runtime.racesymbolizethunk is called from gcc-compiled C
 		// code running on the operating system thread stack.
 		// It uses more than the usual amount of stack but that's okay.
@@ -1230,7 +1192,7 @@
 		}
 	}
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		if s.Nosplit == 0 {
 			Ctxt.Cursym = s
 			ch.sym = s
@@ -1240,17 +1202,8 @@
 }
 
 func stkcheck(up *Chain, depth int) int {
-	var ch Chain
-	var ch1 Chain
-	var s *LSym
-	var limit int
-	var r *Reloc
-	var ri int
-	var endr int
-	var pcsp Pciter
-
-	limit = up.limit
-	s = up.sym
+	limit := up.limit
+	s := up.sym
 
 	// Don't duplicate work: only need to consider each
 	// function at top of safe zone once.
@@ -1288,12 +1241,16 @@
 		return 0
 	}
 
+	var ch Chain
 	ch.up = up
 
 	// Walk through sp adjustments in function, consuming relocs.
-	ri = 0
+	ri := 0
 
-	endr = len(s.R)
+	endr := len(s.R)
+	var ch1 Chain
+	var pcsp Pciter
+	var r *Reloc
 	for pciterinit(Ctxt, &pcsp, &s.Pcln.Pcsp); pcsp.done == 0; pciternext(&pcsp) {
 		// pcsp.value is in effect for [pcsp.pc, pcsp.nextpc).
 
@@ -1384,16 +1341,12 @@
 func Yconv(s *LSym) string {
 	var fp string
 
-	var fmt_ string
-	var i int
-	var str string
-
 	if s == nil {
 		fp += fmt.Sprintf("<nil>")
 	} else {
-		fmt_ = ""
+		fmt_ := ""
 		fmt_ += fmt.Sprintf("%s @0x%08x [%d]", s.Name, int64(s.Value), int64(s.Size))
-		for i = 0; int64(i) < s.Size; i++ {
+		for i := 0; int64(i) < s.Size; i++ {
 			if i%8 == 0 {
 				fmt_ += fmt.Sprintf("\n\t0x%04x ", i)
 			}
@@ -1401,11 +1354,11 @@
 		}
 
 		fmt_ += fmt.Sprintf("\n")
-		for i = 0; i < len(s.R); i++ {
+		for i := 0; i < len(s.R); i++ {
 			fmt_ += fmt.Sprintf("\t0x%04x[%x] %d %s[%x]\n", s.R[i].Off, s.R[i].Siz, s.R[i].Type, s.R[i].Sym.Name, int64(s.R[i].Add))
 		}
 
-		str = fmt_
+		str := fmt_
 		fp += str
 	}
 
@@ -1439,9 +1392,7 @@
 }
 
 func setheadtype(s string) {
-	var h int
-
-	h = headtype(s)
+	h := headtype(s)
 	if h < 0 {
 		fmt.Fprintf(os.Stderr, "unknown header type -H %s\n", s)
 		Errorexit()
@@ -1462,13 +1413,9 @@
 }
 
 func genasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) {
-	var a *Auto
-	var s *LSym
-	var off int32
-
 	// These symbols won't show up in the first loop below because we
 	// skip STEXT symbols. Normal STEXT symbols are emitted by walking textp.
-	s = Linklookup(Ctxt, "runtime.text", 0)
+	s := Linklookup(Ctxt, "runtime.text", 0)
 
 	if s.Type == STEXT {
 		put(s, s.Name, 'T', s.Value, s.Size, int(s.Version), nil)
@@ -1478,7 +1425,7 @@
 		put(s, s.Name, 'T', s.Value, s.Size, int(s.Version), nil)
 	}
 
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if s.Hide != 0 || (s.Name[0] == '.' && s.Version == 0 && s.Name != ".rathole") {
 			continue
 		}
@@ -1518,7 +1465,9 @@
 		}
 	}
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	var a *Auto
+	var off int32
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		put(s, s.Name, 'T', s.Value, s.Size, int(s.Version), s.Gotype)
 
 		// NOTE(ality): acid can't produce a stack trace without .frame symbols
@@ -1568,9 +1517,7 @@
 }
 
 func xdefine(p string, t int, v int64) {
-	var s *LSym
-
-	s = Linklookup(Ctxt, p, 0)
+	s := Linklookup(Ctxt, p, 0)
 	s.Type = int16(t)
 	s.Value = v
 	s.Reachable = true
@@ -1589,14 +1536,11 @@
 }
 
 func Entryvalue() int64 {
-	var a string
-	var s *LSym
-
-	a = INITENTRY
+	a := INITENTRY
 	if a[0] >= '0' && a[0] <= '9' {
 		return atolwhex(a)
 	}
-	s = Linklookup(Ctxt, a, 0)
+	s := Linklookup(Ctxt, a, 0)
 	if s.Type == 0 {
 		return INITTEXT
 	}
@@ -1607,11 +1551,10 @@
 }
 
 func undefsym(s *LSym) {
-	var i int
 	var r *Reloc
 
 	Ctxt.Cursym = s
-	for i = 0; i < len(s.R); i++ {
+	for i := 0; i < len(s.R); i++ {
 		r = &s.R[i]
 		if r.Sym == nil { // happens for some external ARM relocs
 			continue
@@ -1626,12 +1569,10 @@
 }
 
 func undef() {
-	var s *LSym
-
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		undefsym(s)
 	}
-	for s = datap; s != nil; s = s.Next {
+	for s := datap; s != nil; s = s.Next {
 		undefsym(s)
 	}
 	if nerrors > 0 {
@@ -1640,15 +1581,13 @@
 }
 
 func callgraph() {
-	var s *LSym
-	var r *Reloc
-	var i int
-
 	if Debug['c'] == 0 {
 		return
 	}
 
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	var i int
+	var r *Reloc
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		for i = 0; i < len(s.R); i++ {
 			r = &s.R[i]
 			if r.Sym == nil {
@@ -1678,11 +1617,6 @@
 }
 
 func checkgo() {
-	var s *LSym
-	var r *Reloc
-	var i int
-	var changed int
-
 	if Debug['C'] == 0 {
 		return
 	}
@@ -1691,6 +1625,10 @@
 	// which would simplify this logic quite a bit.
 
 	// Mark every Go-called C function with cfunc=2, recursively.
+	var changed int
+	var i int
+	var r *Reloc
+	var s *LSym
 	for {
 		changed = 0
 		for s = Ctxt.Textp; s != nil; s = s.Next {
@@ -1716,7 +1654,7 @@
 
 	// Complain about Go-called C functions that can split the stack
 	// (that can be preempted for garbage collection or trigger a stack copy).
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		if s.Cfunc == 0 || (s.Cfunc == 2 && s.Nosplit != 0) {
 			for i = 0; i < len(s.R); i++ {
 				r = &s.R[i]
@@ -1736,13 +1674,11 @@
 }
 
 func Rnd(v int64, r int64) int64 {
-	var c int64
-
 	if r <= 0 {
 		return v
 	}
 	v += r - 1
-	c = v % r
+	c := v % r
 	if c < 0 {
 		c += r
 	}
diff --git a/src/cmd/internal/ld/macho.go b/src/cmd/internal/ld/macho.go
index 6349642..9fe63f3 100644
--- a/src/cmd/internal/ld/macho.go
+++ b/src/cmd/internal/ld/macho.go
@@ -156,14 +156,12 @@
 }
 
 func newMachoSeg(name string, msect int) *MachoSeg {
-	var s *MachoSeg
-
 	if nseg >= len(seg) {
 		Diag("too many segs")
 		Errorexit()
 	}
 
-	s = &seg[nseg]
+	s := &seg[nseg]
 	nseg++
 	s.name = name
 	s.msect = uint32(msect)
@@ -172,14 +170,12 @@
 }
 
 func newMachoSect(seg *MachoSeg, name string, segname string) *MachoSect {
-	var s *MachoSect
-
 	if seg.nsect >= seg.msect {
 		Diag("too many sects in segment %s", seg.name)
 		Errorexit()
 	}
 
-	s = &seg.sect[seg.nsect]
+	s := &seg.sect[seg.nsect]
 	seg.nsect++
 	s.name = name
 	s.segname = segname
@@ -196,18 +192,10 @@
 var linkoff int64
 
 func machowrite() int {
-	var o1 int64
-	var loadsize int
-	var i int
-	var j int
-	var s *MachoSeg
-	var t *MachoSect
-	var l *MachoLoad
+	o1 := Cpos()
 
-	o1 = Cpos()
-
-	loadsize = 4 * 4 * ndebug
-	for i = 0; i < len(load); i++ {
+	loadsize := 4 * 4 * ndebug
+	for i := 0; i < len(load); i++ {
 		loadsize += 4 * (len(load[i].data) + 2)
 	}
 	if macho64 {
@@ -237,7 +225,10 @@
 		Thearch.Lput(0) /* reserved */
 	}
 
-	for i = 0; i < nseg; i++ {
+	var j int
+	var s *MachoSeg
+	var t *MachoSect
+	for i := 0; i < nseg; i++ {
 		s = &seg[i]
 		if macho64 {
 			Thearch.Lput(25) /* segment 64 */
@@ -296,7 +287,8 @@
 		}
 	}
 
-	for i = 0; i < len(load); i++ {
+	var l *MachoLoad
+	for i := 0; i < len(load); i++ {
 		l = &load[i]
 		Thearch.Lput(l.type_)
 		Thearch.Lput(4 * (uint32(len(l.data)) + 2))
@@ -309,14 +301,12 @@
 }
 
 func domacho() {
-	var s *LSym
-
 	if Debug['d'] != 0 {
 		return
 	}
 
 	// empirically, string table must begin with " \x00".
-	s = Linklookup(Ctxt, ".machosymstr", 0)
+	s := Linklookup(Ctxt, ".machosymstr", 0)
 
 	s.Type = SMACHOSYMSTR
 	s.Reachable = true
@@ -328,7 +318,7 @@
 	s.Reachable = true
 
 	if Linkmode != LinkExternal {
-		s = Linklookup(Ctxt, ".plt", 0) // will be __symbol_stub
+		s := Linklookup(Ctxt, ".plt", 0) // will be __symbol_stub
 		s.Type = SMACHOPLT
 		s.Reachable = true
 
@@ -364,12 +354,9 @@
 }
 
 func machoshbits(mseg *MachoSeg, sect *Section, segname string) {
-	var msect *MachoSect
-	var buf string
+	buf := "__" + strings.Replace(sect.Name[1:], ".", "_", -1)
 
-	buf = "__" + strings.Replace(sect.Name[1:], ".", "_", -1)
-
-	msect = newMachoSect(mseg, buf, segname)
+	msect := newMachoSect(mseg, buf, segname)
 	if sect.Rellen > 0 {
 		msect.reloc = uint32(sect.Reloff)
 		msect.nreloc = uint32(sect.Rellen / 8)
@@ -413,20 +400,10 @@
 }
 
 func Asmbmacho() {
-	var v int64
-	var w int64
-	var va int64
-	var a int
-	var i int
-	var mh *MachoHdr
-	var ms *MachoSeg
-	var ml *MachoLoad
-	var sect *Section
-
 	/* apple MACH */
-	va = INITTEXT - int64(HEADR)
+	va := INITTEXT - int64(HEADR)
 
-	mh = getMachoHdr()
+	mh := getMachoHdr()
 	switch Thearch.Thechar {
 	default:
 		Diag("unknown mach architecture")
@@ -446,7 +423,7 @@
 		mh.subcpu = MACHO_SUBCPU_X86
 	}
 
-	ms = nil
+	ms := (*MachoSeg)(nil)
 	if Linkmode == LinkExternal {
 		/* segment for entire file */
 		ms = newMachoSeg("", 40)
@@ -462,7 +439,7 @@
 	}
 
 	/* text */
-	v = Rnd(int64(uint64(HEADR)+Segtext.Length), int64(INITRND))
+	v := Rnd(int64(uint64(HEADR)+Segtext.Length), int64(INITRND))
 
 	if Linkmode != LinkExternal {
 		ms = newMachoSeg("__TEXT", 20)
@@ -474,13 +451,13 @@
 		ms.prot2 = 5
 	}
 
-	for sect = Segtext.Sect; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect; sect != nil; sect = sect.Next {
 		machoshbits(ms, sect, "__TEXT")
 	}
 
 	/* data */
 	if Linkmode != LinkExternal {
-		w = int64(Segdata.Length)
+		w := int64(Segdata.Length)
 		ms = newMachoSeg("__DATA", 20)
 		ms.vaddr = uint64(va) + uint64(v)
 		ms.vsize = uint64(w)
@@ -490,7 +467,7 @@
 		ms.prot2 = 3
 	}
 
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		machoshbits(ms, sect, "__DATA")
 	}
 
@@ -502,20 +479,20 @@
 			fallthrough
 
 		case '5':
-			ml = newMachoLoad(5, 17+2)           /* unix thread */
+			ml := newMachoLoad(5, 17+2)          /* unix thread */
 			ml.data[0] = 1                       /* thread type */
 			ml.data[1] = 17                      /* word count */
 			ml.data[2+15] = uint32(Entryvalue()) /* start pc */
 
 		case '6':
-			ml = newMachoLoad(5, 42+2)                         /* unix thread */
+			ml := newMachoLoad(5, 42+2)                        /* unix thread */
 			ml.data[0] = 4                                     /* thread type */
 			ml.data[1] = 42                                    /* word count */
 			ml.data[2+32] = uint32(Entryvalue())               /* start pc */
 			ml.data[2+32+1] = uint32(Entryvalue() >> 16 >> 16) // hide >>32 for 8l
 
 		case '8':
-			ml = newMachoLoad(5, 16+2)           /* unix thread */
+			ml := newMachoLoad(5, 16+2)          /* unix thread */
 			ml.data[0] = 1                       /* thread type */
 			ml.data[1] = 16                      /* word count */
 			ml.data[2+10] = uint32(Entryvalue()) /* start pc */
@@ -523,20 +500,15 @@
 	}
 
 	if Debug['d'] == 0 {
-		var s1 *LSym
-		var s2 *LSym
-		var s3 *LSym
-		var s4 *LSym
-
 		// must match domacholink below
-		s1 = Linklookup(Ctxt, ".machosymtab", 0)
+		s1 := Linklookup(Ctxt, ".machosymtab", 0)
 
-		s2 = Linklookup(Ctxt, ".linkedit.plt", 0)
-		s3 = Linklookup(Ctxt, ".linkedit.got", 0)
-		s4 = Linklookup(Ctxt, ".machosymstr", 0)
+		s2 := Linklookup(Ctxt, ".linkedit.plt", 0)
+		s3 := Linklookup(Ctxt, ".linkedit.got", 0)
+		s4 := Linklookup(Ctxt, ".machosymstr", 0)
 
 		if Linkmode != LinkExternal {
-			ms = newMachoSeg("__LINKEDIT", 0)
+			ms := newMachoSeg("__LINKEDIT", 0)
 			ms.vaddr = uint64(va) + uint64(v) + uint64(Rnd(int64(Segdata.Length), int64(INITRND)))
 			ms.vsize = uint64(s1.Size) + uint64(s2.Size) + uint64(s3.Size) + uint64(s4.Size)
 			ms.fileoffset = uint64(linkoff)
@@ -545,7 +517,7 @@
 			ms.prot2 = 3
 		}
 
-		ml = newMachoLoad(2, 4)                                    /* LC_SYMTAB */
+		ml := newMachoLoad(2, 4)                                   /* LC_SYMTAB */
 		ml.data[0] = uint32(linkoff)                               /* symoff */
 		ml.data[1] = uint32(nsortsym)                              /* nsyms */
 		ml.data[2] = uint32(linkoff + s1.Size + s2.Size + s3.Size) /* stroff */
@@ -554,11 +526,11 @@
 		machodysymtab()
 
 		if Linkmode != LinkExternal {
-			ml = newMachoLoad(14, 6) /* LC_LOAD_DYLINKER */
-			ml.data[0] = 12          /* offset to string */
+			ml := newMachoLoad(14, 6) /* LC_LOAD_DYLINKER */
+			ml.data[0] = 12           /* offset to string */
 			stringtouint32(ml.data[1:], "/usr/lib/dyld")
 
-			for i = 0; i < len(dylib); i++ {
+			for i := 0; i < len(dylib); i++ {
 				ml = newMachoLoad(12, 4+(uint32(len(dylib[i]))+1+7)/8*2) /* LC_LOAD_DYLIB */
 				ml.data[0] = 24                                          /* offset of string from beginning of load */
 				ml.data[1] = 0                                           /* time stamp */
@@ -574,7 +546,7 @@
 		dwarfaddmachoheaders()
 	}
 
-	a = machowrite()
+	a := machowrite()
 	if int32(a) > HEADR {
 		Diag("HEADR too small: %d > %d", a, HEADR)
 	}
@@ -624,16 +596,11 @@
 }
 
 func (x machoscmp) Less(i, j int) bool {
-	var s1 *LSym
-	var s2 *LSym
-	var k1 int
-	var k2 int
+	s1 := x[i]
+	s2 := x[j]
 
-	s1 = x[i]
-	s2 = x[j]
-
-	k1 = symkind(s1)
-	k2 = symkind(s2)
+	k1 := symkind(s1)
+	k2 := symkind(s2)
 	if k1 != k2 {
 		return k1-k2 < 0
 	}
@@ -642,10 +609,8 @@
 }
 
 func machogenasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) {
-	var s *LSym
-
 	genasmsym(put)
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if s.Type == SDYNIMPORT || s.Type == SHOSTOBJ {
 			if s.Reachable {
 				put(s, "", 'D', 0, 0, 0, nil)
@@ -655,12 +620,10 @@
 }
 
 func machosymorder() {
-	var i int
-
 	// On Mac OS X Mountain Lion, we must sort exported symbols
 	// So we sort them here and pre-allocate dynid for them
 	// See http://golang.org/issue/4029
-	for i = 0; i < len(dynexp); i++ {
+	for i := 0; i < len(dynexp); i++ {
 		dynexp[i].Reachable = true
 	}
 	machogenasmsym(addsym)
@@ -668,23 +631,20 @@
 	nsortsym = 0
 	machogenasmsym(addsym)
 	sort.Sort(machoscmp(sortsym[:nsortsym]))
-	for i = 0; i < nsortsym; i++ {
+	for i := 0; i < nsortsym; i++ {
 		sortsym[i].Dynid = int32(i)
 	}
 }
 
 func machosymtab() {
-	var i int
-	var symtab *LSym
-	var symstr *LSym
 	var s *LSym
 	var o *LSym
 	var p string
 
-	symtab = Linklookup(Ctxt, ".machosymtab", 0)
-	symstr = Linklookup(Ctxt, ".machosymstr", 0)
+	symtab := Linklookup(Ctxt, ".machosymtab", 0)
+	symstr := Linklookup(Ctxt, ".machosymstr", 0)
 
-	for i = 0; i < nsortsym; i++ {
+	for i := 0; i < nsortsym; i++ {
 		s = sortsym[i]
 		Adduint32(Ctxt, symtab, uint32(symstr.Size))
 
@@ -737,15 +697,9 @@
 }
 
 func machodysymtab() {
-	var n int
-	var ml *MachoLoad
-	var s1 *LSym
-	var s2 *LSym
-	var s3 *LSym
+	ml := newMachoLoad(11, 18) /* LC_DYSYMTAB */
 
-	ml = newMachoLoad(11, 18) /* LC_DYSYMTAB */
-
-	n = 0
+	n := 0
 	ml.data[0] = uint32(n)                   /* ilocalsym */
 	ml.data[1] = uint32(nkind[SymKindLocal]) /* nlocalsym */
 	n += nkind[SymKindLocal]
@@ -765,10 +719,10 @@
 	ml.data[11] = 0 /* nextrefsyms */
 
 	// must match domacholink below
-	s1 = Linklookup(Ctxt, ".machosymtab", 0)
+	s1 := Linklookup(Ctxt, ".machosymtab", 0)
 
-	s2 = Linklookup(Ctxt, ".linkedit.plt", 0)
-	s3 = Linklookup(Ctxt, ".linkedit.got", 0)
+	s2 := Linklookup(Ctxt, ".linkedit.plt", 0)
+	s3 := Linklookup(Ctxt, ".linkedit.got", 0)
 	ml.data[12] = uint32(linkoff + s1.Size)       /* indirectsymoff */
 	ml.data[13] = uint32((s2.Size + s3.Size) / 4) /* nindirectsyms */
 
@@ -779,20 +733,14 @@
 }
 
 func Domacholink() int64 {
-	var size int
-	var s1 *LSym
-	var s2 *LSym
-	var s3 *LSym
-	var s4 *LSym
-
 	machosymtab()
 
 	// write data that will be linkedit section
-	s1 = Linklookup(Ctxt, ".machosymtab", 0)
+	s1 := Linklookup(Ctxt, ".machosymtab", 0)
 
-	s2 = Linklookup(Ctxt, ".linkedit.plt", 0)
-	s3 = Linklookup(Ctxt, ".linkedit.got", 0)
-	s4 = Linklookup(Ctxt, ".machosymstr", 0)
+	s2 := Linklookup(Ctxt, ".linkedit.plt", 0)
+	s3 := Linklookup(Ctxt, ".linkedit.got", 0)
+	s4 := Linklookup(Ctxt, ".machosymstr", 0)
 
 	// Force the linkedit section to end on a 16-byte
 	// boundary.  This allows pure (non-cgo) Go binaries
@@ -815,7 +763,7 @@
 		Adduint8(Ctxt, s4, 0)
 	}
 
-	size = int(s1.Size + s2.Size + s3.Size + s4.Size)
+	size := int(s1.Size + s2.Size + s3.Size + s4.Size)
 
 	if size > 0 {
 		linkoff = Rnd(int64(uint64(HEADR)+Segtext.Length), int64(INITRND)) + Rnd(int64(Segdata.Filelen), int64(INITRND)) + Rnd(int64(Segdwarf.Filelen), int64(INITRND))
@@ -831,17 +779,13 @@
 }
 
 func machorelocsect(sect *Section, first *LSym) {
-	var sym *LSym
-	var eaddr int32
-	var ri int
-	var r *Reloc
-
 	// If main section has no bits, nothing to relocate.
 	if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
 		return
 	}
 
 	sect.Reloff = uint64(Cpos())
+	var sym *LSym
 	for sym = first; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -851,7 +795,9 @@
 		}
 	}
 
-	eaddr = int32(sect.Vaddr + sect.Length)
+	eaddr := int32(sect.Vaddr + sect.Length)
+	var r *Reloc
+	var ri int
 	for ; sym != nil; sym = sym.Next {
 		if !sym.Reachable {
 			continue
@@ -876,17 +822,15 @@
 }
 
 func Machoemitreloc() {
-	var sect *Section
-
 	for Cpos()&7 != 0 {
 		Cput(0)
 	}
 
 	machorelocsect(Segtext.Sect, Ctxt.Textp)
-	for sect = Segtext.Sect.Next; sect != nil; sect = sect.Next {
+	for sect := Segtext.Sect.Next; sect != nil; sect = sect.Next {
 		machorelocsect(sect, datap)
 	}
-	for sect = Segdata.Sect; sect != nil; sect = sect.Next {
+	for sect := Segdata.Sect; sect != nil; sect = sect.Next {
 		machorelocsect(sect, datap)
 	}
 }
diff --git a/src/cmd/internal/ld/objfile.go b/src/cmd/internal/ld/objfile.go
index 98b7ba6..003c106 100644
--- a/src/cmd/internal/ld/objfile.go
+++ b/src/cmd/internal/ld/objfile.go
@@ -17,23 +17,19 @@
 var endmagic string = "\xff\xffgo13ld"
 
 func ldobjfile(ctxt *Link, f *Biobuf, pkg string, length int64, pn string) {
-	var c int
-	var buf [8]uint8
-	var start int64
-	var lib string
-
-	start = Boffset(f)
+	start := Boffset(f)
 	ctxt.Version++
-	buf = [8]uint8{}
+	buf := [8]uint8{}
 	Bread(f, buf[:])
 	if string(buf[:]) != startmagic {
 		log.Fatalf("%s: invalid file start %x %x %x %x %x %x %x %x", pn, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7])
 	}
-	c = Bgetc(f)
+	c := Bgetc(f)
 	if c != 1 {
 		log.Fatalf("%s: invalid file version number %d", pn, c)
 	}
 
+	var lib string
 	for {
 		lib = rdstring(f)
 		if lib == "" {
@@ -65,45 +61,28 @@
 var readsym_ndup int
 
 func readsym(ctxt *Link, f *Biobuf, pkg string, pn string) {
-	var i int
-	var j int
-	var c int
-	var t int
-	var v int
-	var n int
-	var nreloc int
-	var size int
-	var dupok int
-	var name string
-	var data []byte
-	var r *Reloc
-	var s *LSym
-	var dup *LSym
-	var typ *LSym
-	var pc *Pcln
-	var a *Auto
-
 	if Bgetc(f) != 0xfe {
 		log.Fatalf("readsym out of sync")
 	}
-	t = int(rdint(f))
-	name = expandpkg(rdstring(f), pkg)
-	v = int(rdint(f))
+	t := int(rdint(f))
+	name := expandpkg(rdstring(f), pkg)
+	v := int(rdint(f))
 	if v != 0 && v != 1 {
 		log.Fatalf("invalid symbol version %d", v)
 	}
-	dupok = int(rdint(f))
+	dupok := int(rdint(f))
 	dupok &= 1
-	size = int(rdint(f))
-	typ = rdsym(ctxt, f, pkg)
+	size := int(rdint(f))
+	typ := rdsym(ctxt, f, pkg)
+	var data []byte
 	rddata(f, &data)
-	nreloc = int(rdint(f))
+	nreloc := int(rdint(f))
 
 	if v != 0 {
 		v = ctxt.Version
 	}
-	s = Linklookup(ctxt, name, v)
-	dup = nil
+	s := Linklookup(ctxt, name, v)
+	dup := (*LSym)(nil)
 	if s.Type != 0 && s.Type != SXREF {
 		if (t == SDATA || t == SBSS || t == SNOPTRBSS) && len(data) == 0 && nreloc == 0 {
 			if s.Size < int64(size) {
@@ -155,7 +134,8 @@
 	if nreloc > 0 {
 		s.R = make([]Reloc, nreloc)
 		s.R = s.R[:nreloc]
-		for i = 0; i < nreloc; i++ {
+		var r *Reloc
+		for i := 0; i < nreloc; i++ {
 			r = &s.R[i]
 			r.Off = int32(rdint(f))
 			r.Siz = uint8(rdint(f))
@@ -179,11 +159,12 @@
 		s.Args = int32(rdint(f))
 		s.Locals = int32(rdint(f))
 		s.Nosplit = uint8(rdint(f))
-		v = int(rdint(f))
+		v := int(rdint(f))
 		s.Leaf = uint8(v & 1)
 		s.Cfunc = uint8(v & 2)
-		n = int(rdint(f))
-		for i = 0; i < n; i++ {
+		n := int(rdint(f))
+		var a *Auto
+		for i := 0; i < n; i++ {
 			a = new(Auto)
 			a.Asym = rdsym(ctxt, f, pkg)
 			a.Aoffset = int32(rdint(f))
@@ -194,30 +175,30 @@
 		}
 
 		s.Pcln = new(Pcln)
-		pc = s.Pcln
+		pc := s.Pcln
 		rddata(f, &pc.Pcsp.P)
 		rddata(f, &pc.Pcfile.P)
 		rddata(f, &pc.Pcline.P)
 		n = int(rdint(f))
 		pc.Pcdata = make([]Pcdata, n)
 		pc.Npcdata = n
-		for i = 0; i < n; i++ {
+		for i := 0; i < n; i++ {
 			rddata(f, &pc.Pcdata[i].P)
 		}
 		n = int(rdint(f))
 		pc.Funcdata = make([]*LSym, n)
 		pc.Funcdataoff = make([]int64, n)
 		pc.Nfuncdata = n
-		for i = 0; i < n; i++ {
+		for i := 0; i < n; i++ {
 			pc.Funcdata[i] = rdsym(ctxt, f, pkg)
 		}
-		for i = 0; i < n; i++ {
+		for i := 0; i < n; i++ {
 			pc.Funcdataoff[i] = rdint(f)
 		}
 		n = int(rdint(f))
 		pc.File = make([]*LSym, n)
 		pc.Nfile = n
-		for i = 0; i < n; i++ {
+		for i := 0; i < n; i++ {
 			pc.File[i] = rdsym(ctxt, f, pkg)
 		}
 
@@ -257,7 +238,9 @@
 			fmt.Fprintf(ctxt.Bso, " args=%#x locals=%#x", uint64(s.Args), uint64(s.Locals))
 		}
 		fmt.Fprintf(ctxt.Bso, "\n")
-		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])
@@ -279,7 +262,8 @@
 			i += 16
 		}
 
-		for i = 0; i < len(s.R); i++ {
+		var r *Reloc
+		for i := 0; i < len(s.R); i++ {
 			r = &s.R[i]
 			fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s+%d\n", int(r.Off), r.Siz, r.Type, r.Sym.Name, int64(r.Add))
 		}
@@ -288,11 +272,9 @@
 
 func rdint(f *Biobuf) int64 {
 	var c int
-	var uv uint64
-	var shift int
 
-	uv = 0
-	for shift = 0; ; shift += 7 {
+	uv := uint64(0)
+	for shift := 0; ; shift += 7 {
 		if shift >= 64 {
 			log.Fatalf("corrupt input")
 		}
@@ -322,12 +304,7 @@
 var symbuf []byte
 
 func rdsym(ctxt *Link, f *Biobuf, pkg string) *LSym {
-	var n int
-	var v int
-	var p string
-	var s *LSym
-
-	n = int(rdint(f))
+	n := int(rdint(f))
 	if n == 0 {
 		rdint(f)
 		return nil
@@ -337,25 +314,23 @@
 		symbuf = make([]byte, n)
 	}
 	Bread(f, symbuf[:n])
-	p = string(symbuf[:n])
-	v = int(rdint(f))
+	p := string(symbuf[:n])
+	v := int(rdint(f))
 	if v != 0 {
 		v = ctxt.Version
 	}
-	s = Linklookup(ctxt, expandpkg(p, pkg), v)
+	s := Linklookup(ctxt, expandpkg(p, pkg), v)
 
 	if v == 0 && s.Name[0] == '$' && s.Type == 0 {
 		if strings.HasPrefix(s.Name, "$f32.") {
-			var i32 int32
 			x, _ := strconv.ParseUint(s.Name[5:], 16, 32)
-			i32 = int32(x)
+			i32 := int32(x)
 			s.Type = SRODATA
 			Adduint32(ctxt, s, uint32(i32))
 			s.Reachable = false
 		} else if strings.HasPrefix(s.Name, "$f64.") || strings.HasPrefix(s.Name, "$i64.") {
-			var i64 int64
 			x, _ := strconv.ParseUint(s.Name[5:], 16, 64)
-			i64 = int64(x)
+			i64 := int64(x)
 			s.Type = SRODATA
 			Adduint64(ctxt, s, uint64(i64))
 			s.Reachable = false
diff --git a/src/cmd/internal/ld/pcln.go b/src/cmd/internal/ld/pcln.go
index 2900664..e8ef252 100644
--- a/src/cmd/internal/ld/pcln.go
+++ b/src/cmd/internal/ld/pcln.go
@@ -40,13 +40,9 @@
 // iteration over encoded pcdata tables.
 
 func getvarint(pp *[]byte) uint32 {
-	var p []byte
-	var shift int
-	var v uint32
-
-	v = 0
-	p = *pp
-	for shift = 0; ; shift += 7 {
+	v := uint32(0)
+	p := *pp
+	for shift := 0; ; shift += 7 {
 		v |= uint32(p[0]&0x7F) << uint(shift)
 		tmp4 := p
 		p = p[1:]
@@ -60,9 +56,6 @@
 }
 
 func pciternext(it *Pciter) {
-	var v uint32
-	var dv int32
-
 	it.pc = it.nextpc
 	if it.done != 0 {
 		return
@@ -73,7 +66,7 @@
 	}
 
 	// value delta
-	v = getvarint(&it.p)
+	v := getvarint(&it.p)
 
 	if v == 0 && it.start == 0 {
 		it.done = 1
@@ -81,7 +74,7 @@
 	}
 
 	it.start = 0
-	dv = int32(v>>1) ^ (int32(v<<31) >> 31)
+	dv := int32(v>>1) ^ (int32(v<<31) >> 31)
 	it.value += dv
 
 	// pc delta
@@ -107,12 +100,8 @@
 // license that can be found in the LICENSE file.
 
 func addvarint(d *Pcdata, val uint32) {
-	var n int32
-	var v uint32
-	var p []byte
-
-	n = 0
-	for v = val; v >= 0x80; v >>= 7 {
+	n := int32(0)
+	for v := val; v >= 0x80; v >>= 7 {
 		n++
 	}
 	n++
@@ -123,7 +112,8 @@
 	}
 	d.P = d.P[:old+int(n)]
 
-	p = d.P[old:]
+	p := d.P[old:]
+	var v uint32
 	for v = val; v >= 0x80; v >>= 7 {
 		p[0] = byte(v | 0x80)
 		p = p[1:]
@@ -132,9 +122,7 @@
 }
 
 func addpctab(ftab *LSym, off int32, d *Pcdata) int32 {
-	var start int32
-
-	start = int32(len(ftab.P))
+	start := int32(len(ftab.P))
 	Symgrow(Ctxt, ftab, int64(start)+int64(len(d.P)))
 	copy(ftab.P[start:], d.P)
 
@@ -142,29 +130,18 @@
 }
 
 func ftabaddstring(ftab *LSym, s string) int32 {
-	var n int32
-	var start int32
-
-	n = int32(len(s)) + 1
-	start = int32(len(ftab.P))
+	n := int32(len(s)) + 1
+	start := int32(len(ftab.P))
 	Symgrow(Ctxt, ftab, int64(start)+int64(n)+1)
 	copy(ftab.P[start:], s)
 	return start
 }
 
 func renumberfiles(ctxt *Link, files []*LSym, d *Pcdata) {
-	var i int
 	var f *LSym
-	var out Pcdata
-	var it Pciter
-	var v uint32
-	var oldval int32
-	var newval int32
-	var val int32
-	var dv int32
 
 	// Give files numbers.
-	for i = 0; i < len(files); i++ {
+	for i := 0; i < len(files); i++ {
 		f = files[i]
 		if f.Type != SFILEPATH {
 			ctxt.Nhistfile++
@@ -175,9 +152,14 @@
 		}
 	}
 
-	newval = -1
-	out = Pcdata{}
+	newval := int32(-1)
+	out := Pcdata{}
 
+	var dv int32
+	var it Pciter
+	var oldval int32
+	var v uint32
+	var val int32
 	for pciterinit(ctxt, &it, d); it.done == 0; pciternext(&it) {
 		// value delta
 		oldval = it.value
@@ -221,22 +203,8 @@
 var pclntab_zpcln Pcln
 
 func pclntab() {
-	var i int32
-	var nfunc int32
-	var start int32
-	var funcstart int32
-	var ftab *LSym
-	var s *LSym
-	var last *LSym
-	var off int32
-	var end int32
-	var frameptrsize int32
-	var funcdata_bytes int64
-	var pcln *Pcln
-	var it Pciter
-
-	funcdata_bytes = 0
-	ftab = Linklookup(Ctxt, "runtime.pclntab", 0)
+	funcdata_bytes := int64(0)
+	ftab := Linklookup(Ctxt, "runtime.pclntab", 0)
 	ftab.Type = SPCLNTAB
 	ftab.Reachable = true
 
@@ -246,7 +214,7 @@
 	//	function table, alternating PC and offset to func struct [each entry thearch.ptrsize bytes]
 	//	end PC [thearch.ptrsize bytes]
 	//	offset to file table [4 bytes]
-	nfunc = 0
+	nfunc := int32(0)
 
 	for Ctxt.Cursym = Ctxt.Textp; Ctxt.Cursym != nil; Ctxt.Cursym = Ctxt.Cursym.Next {
 		if container(Ctxt.Cursym) == 0 {
@@ -261,7 +229,14 @@
 	setuintxx(Ctxt, ftab, 8, uint64(nfunc), int64(Thearch.Ptrsize))
 
 	nfunc = 0
-	last = nil
+	last := (*LSym)(nil)
+	var end int32
+	var frameptrsize int32
+	var funcstart int32
+	var i int32
+	var it Pciter
+	var off int32
+	var pcln *Pcln
 	for Ctxt.Cursym = Ctxt.Textp; Ctxt.Cursym != nil; Ctxt.Cursym = Ctxt.Cursym.Next {
 		last = Ctxt.Cursym
 		if container(Ctxt.Cursym) != 0 {
@@ -366,14 +341,14 @@
 	setaddrplus(Ctxt, ftab, 8+int64(Thearch.Ptrsize)+int64(nfunc)*2*int64(Thearch.Ptrsize), last, last.Size)
 
 	// Start file table.
-	start = int32(len(ftab.P))
+	start := int32(len(ftab.P))
 
 	start += int32(-len(ftab.P)) & (int32(Thearch.Ptrsize) - 1)
 	setuint32(Ctxt, ftab, 8+int64(Thearch.Ptrsize)+int64(nfunc)*2*int64(Thearch.Ptrsize)+int64(Thearch.Ptrsize), uint32(start))
 
 	Symgrow(Ctxt, ftab, int64(start)+(int64(Ctxt.Nhistfile)+1)*4)
 	setuint32(Ctxt, ftab, int64(start), uint32(Ctxt.Nhistfile))
-	for s = Ctxt.Filesyms; s != nil; s = s.Next {
+	for s := Ctxt.Filesyms; s != nil; s = s.Next {
 		setuint32(Ctxt, ftab, int64(start)+s.Value*4, uint32(ftabaddstring(ftab, s.Name)))
 	}
 
@@ -394,43 +369,32 @@
 // findfunctab generates a lookup table to quickly find the containing
 // function for a pc.  See src/runtime/symtab.go:findfunc for details.
 func findfunctab() {
-	var t *LSym
-	var s *LSym
-	var e *LSym
-	var idx int32
-	var i int32
-	var j int32
-	var nbuckets int32
-	var n int32
-	var base int32
-	var min int64
-	var max int64
-	var p int64
-	var q int64
-	var indexes []int32
-
-	t = Linklookup(Ctxt, "runtime.findfunctab", 0)
+	t := Linklookup(Ctxt, "runtime.findfunctab", 0)
 	t.Type = SRODATA
 	t.Reachable = true
 
 	// find min and max address
-	min = Ctxt.Textp.Value
+	min := Ctxt.Textp.Value
 
-	max = 0
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	max := int64(0)
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		max = s.Value + s.Size
 	}
 
 	// for each subbucket, compute the minimum of all symbol indexes
 	// that map to that subbucket.
-	n = int32((max - min + SUBBUCKETSIZE - 1) / SUBBUCKETSIZE)
+	n := int32((max - min + SUBBUCKETSIZE - 1) / SUBBUCKETSIZE)
 
-	indexes = make([]int32, n)
-	for i = 0; i < n; i++ {
+	indexes := make([]int32, n)
+	for i := int32(0); i < n; i++ {
 		indexes[i] = NOIDX
 	}
-	idx = 0
-	for s = Ctxt.Textp; s != nil; s = s.Next {
+	idx := int32(0)
+	var e *LSym
+	var i int32
+	var p int64
+	var q int64
+	for s := Ctxt.Textp; s != nil; s = s.Next {
 		if container(s) != 0 {
 			continue
 		}
@@ -461,12 +425,14 @@
 	}
 
 	// allocate table
-	nbuckets = int32((max - min + BUCKETSIZE - 1) / BUCKETSIZE)
+	nbuckets := int32((max - min + BUCKETSIZE - 1) / BUCKETSIZE)
 
 	Symgrow(Ctxt, t, 4*int64(nbuckets)+int64(n))
 
 	// fill in table
-	for i = 0; i < nbuckets; i++ {
+	var base int32
+	var j int32
+	for i := int32(0); i < nbuckets; i++ {
 		base = indexes[i*SUBBUCKETS]
 		if base == NOIDX {
 			Diag("hole in findfunctab")
diff --git a/src/cmd/internal/ld/pe.go b/src/cmd/internal/ld/pe.go
index c2ef49f..30fe400 100644
--- a/src/cmd/internal/ld/pe.go
+++ b/src/cmd/internal/ld/pe.go
@@ -371,14 +371,12 @@
 var ncoffsym int
 
 func addpesection(name string, sectsize int, filesize int) *IMAGE_SECTION_HEADER {
-	var h *IMAGE_SECTION_HEADER
-
 	if pensect == 16 {
 		Diag("too many sections")
 		Errorexit()
 	}
 
-	h = &sh[pensect]
+	h := &sh[pensect]
 	pensect++
 	copy(h.Name[:], name)
 	h.VirtualSize = uint32(sectsize)
@@ -466,14 +464,11 @@
 }
 
 func initdynimport() *Dll {
-	var m *Imp
 	var d *Dll
-	var s *LSym
-	var dynamic *LSym
 
 	dr = nil
-	m = nil
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	m := (*Imp)(nil)
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if !s.Reachable || s.Type != SDYNIMPORT {
 			continue
 		}
@@ -497,10 +492,10 @@
 		d.ms = m
 	}
 
-	dynamic = Linklookup(Ctxt, ".windynamic", 0)
+	dynamic := Linklookup(Ctxt, ".windynamic", 0)
 	dynamic.Reachable = true
 	dynamic.Type = SWINDOWS
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		for m = d.ms; m != nil; m = m.next {
 			m.s.Type = SWINDOWS | SSUB
 			m.s.Sub = dynamic.Sub
@@ -516,35 +511,26 @@
 }
 
 func addimports(datsect *IMAGE_SECTION_HEADER) {
-	var isect *IMAGE_SECTION_HEADER
-	var n uint64
-	var oftbase uint64
-	var ftbase uint64
-	var startoff int64
-	var endoff int64
-	var m *Imp
-	var d *Dll
-	var dynamic *LSym
-
-	startoff = Cpos()
-	dynamic = Linklookup(Ctxt, ".windynamic", 0)
+	startoff := Cpos()
+	dynamic := Linklookup(Ctxt, ".windynamic", 0)
 
 	// skip import descriptor table (will write it later)
-	n = 0
+	n := uint64(0)
 
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		n++
 	}
 	Cseek(startoff + int64(binary.Size(&IMAGE_IMPORT_DESCRIPTOR{}))*int64(n+1))
 
 	// write dll names
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		d.nameoff = uint64(Cpos()) - uint64(startoff)
 		strput(d.name)
 	}
 
 	// write function names
-	for d = dr; d != nil; d = d.next {
+	var m *Imp
+	for d := dr; d != nil; d = d.next {
 		for m = d.ms; m != nil; m = m.next {
 			m.off = uint64(nextsectoff) + uint64(Cpos()) - uint64(startoff)
 			Wputl(0) // hint
@@ -553,10 +539,10 @@
 	}
 
 	// write OriginalFirstThunks
-	oftbase = uint64(Cpos()) - uint64(startoff)
+	oftbase := uint64(Cpos()) - uint64(startoff)
 
 	n = uint64(Cpos())
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		d.thunkoff = uint64(Cpos()) - n
 		for m = d.ms; m != nil; m = m.next {
 			if pe64 != 0 {
@@ -576,17 +562,17 @@
 	// add pe section and pad it at the end
 	n = uint64(Cpos()) - uint64(startoff)
 
-	isect = addpesection(".idata", int(n), int(n))
+	isect := addpesection(".idata", int(n), int(n))
 	isect.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE
 	chksectoff(isect, startoff)
 	strnput("", int(uint64(isect.SizeOfRawData)-n))
-	endoff = Cpos()
+	endoff := Cpos()
 
 	// write FirstThunks (allocated in .data section)
-	ftbase = uint64(dynamic.Value) - uint64(datsect.VirtualAddress) - PEBASE
+	ftbase := uint64(dynamic.Value) - uint64(datsect.VirtualAddress) - PEBASE
 
 	Cseek(int64(uint64(datsect.PointerToRawData) + ftbase))
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		for m = d.ms; m != nil; m = m.next {
 			if pe64 != 0 {
 				Vputl(m.off)
@@ -605,7 +591,7 @@
 	// finally write import descriptor table
 	Cseek(startoff)
 
-	for d = dr; d != nil; d = d.next {
+	for d := dr; d != nil; d = d.next {
 		Lputl(uint32(uint64(isect.VirtualAddress) + oftbase + d.thunkoff))
 		Lputl(0)
 		Lputl(0)
@@ -640,19 +626,14 @@
 }
 
 func (x pescmp) Less(i, j int) bool {
-	var s1 *LSym
-	var s2 *LSym
-
-	s1 = x[i]
-	s2 = x[j]
+	s1 := x[i]
+	s2 := x[j]
 	return stringsCompare(s1.Extname, s2.Extname) < 0
 }
 
 func initdynexport() {
-	var s *LSym
-
 	nexport = 0
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if !s.Reachable || s.Cgoexport&CgoExportDynamic == 0 {
 			continue
 		}
@@ -669,18 +650,10 @@
 }
 
 func addexports() {
-	var sect *IMAGE_SECTION_HEADER
 	var e IMAGE_EXPORT_DIRECTORY
-	var size int
-	var i int
-	var va int
-	var va_name int
-	var va_addr int
-	var va_na int
-	var v int
 
-	size = binary.Size(&e) + 10*nexport + len(outfile) + 1
-	for i = 0; i < nexport; i++ {
+	size := binary.Size(&e) + 10*nexport + len(outfile) + 1
+	for i := 0; i < nexport; i++ {
 		size += len(dexport[i].Extname) + 1
 	}
 
@@ -688,16 +661,16 @@
 		return
 	}
 
-	sect = addpesection(".edata", size, size)
+	sect := addpesection(".edata", size, size)
 	sect.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
 	chksectoff(sect, Cpos())
-	va = int(sect.VirtualAddress)
+	va := int(sect.VirtualAddress)
 	dd[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress = uint32(va)
 	dd[IMAGE_DIRECTORY_ENTRY_EXPORT].Size = sect.VirtualSize
 
-	va_name = va + binary.Size(&e) + nexport*4
-	va_addr = va + binary.Size(&e)
-	va_na = va + binary.Size(&e) + nexport*8
+	va_name := va + binary.Size(&e) + nexport*4
+	va_addr := va + binary.Size(&e)
+	va_na := va + binary.Size(&e) + nexport*8
 
 	e.Characteristics = 0
 	e.MajorVersion = 0
@@ -714,37 +687,35 @@
 	binary.Write(&coutbuf, binary.LittleEndian, &e)
 
 	// put EXPORT Address Table
-	for i = 0; i < nexport; i++ {
+	for i := 0; i < nexport; i++ {
 		Lputl(uint32(dexport[i].Value - PEBASE))
 	}
 
 	// put EXPORT Name Pointer Table
-	v = int(e.Name + uint32(len(outfile)) + 1)
+	v := int(e.Name + uint32(len(outfile)) + 1)
 
-	for i = 0; i < nexport; i++ {
+	for i := 0; i < nexport; i++ {
 		Lputl(uint32(v))
 		v += len(dexport[i].Extname) + 1
 	}
 
 	// put EXPORT Ordinal Table
-	for i = 0; i < nexport; i++ {
+	for i := 0; i < nexport; i++ {
 		Wputl(uint16(i))
 	}
 
 	// put Names
 	strnput(outfile, len(outfile)+1)
 
-	for i = 0; i < nexport; i++ {
+	for i := 0; i < nexport; i++ {
 		strnput(dexport[i].Extname, len(dexport[i].Extname)+1)
 	}
 	strnput("", int(sect.SizeOfRawData-uint32(size)))
 }
 
 func dope() {
-	var rel *LSym
-
 	/* relocation table */
-	rel = Linklookup(Ctxt, ".rel", 0)
+	rel := Linklookup(Ctxt, ".rel", 0)
 
 	rel.Reachable = true
 	rel.Type = SELFROSECT
@@ -768,25 +739,19 @@
  * <http://www.microsoft.com/whdc/system/platform/firmware/PECOFFdwn.mspx>
  */
 func newPEDWARFSection(name string, size int64) *IMAGE_SECTION_HEADER {
-	var h *IMAGE_SECTION_HEADER
-	var s string
-	var off int
-
 	if size == 0 {
 		return nil
 	}
 
-	off = strtbladd(name)
-	s = fmt.Sprintf("/%d", off)
-	h = addpesection(s, int(size), int(size))
+	off := strtbladd(name)
+	s := fmt.Sprintf("/%d", off)
+	h := addpesection(s, int(size), int(size))
 	h.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
 
 	return h
 }
 
 func addpesym(s *LSym, name string, type_ int, addr int64, size int64, ver int, gotype *LSym) {
-	var cs *COFFSym
-
 	if s == nil {
 		return
 	}
@@ -806,7 +771,7 @@
 	}
 
 	if coffsym != nil {
-		cs = &coffsym[ncoffsym]
+		cs := &coffsym[ncoffsym]
 		cs.sym = s
 		if len(s.Name) > 8 {
 			cs.strtbloff = strtbladd(s.Name)
@@ -828,11 +793,6 @@
 }
 
 func addpesymtable() {
-	var h *IMAGE_SECTION_HEADER
-	var i int
-	var size int
-	var s *COFFSym
-
 	if Debug['s'] == 0 {
 		genasmsym(addpesym)
 		coffsym = make([]COFFSym, ncoffsym)
@@ -840,15 +800,16 @@
 		genasmsym(addpesym)
 	}
 
-	size = len(strtbl) + 4 + 18*ncoffsym
-	h = addpesection(".symtab", size, size)
+	size := len(strtbl) + 4 + 18*ncoffsym
+	h := addpesection(".symtab", size, size)
 	h.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
 	chksectoff(h, Cpos())
 	fh.PointerToSymbolTable = uint32(Cpos())
 	fh.NumberOfSymbols = uint32(ncoffsym)
 
 	// put COFF symbol table
-	for i = 0; i < ncoffsym; i++ {
+	var s *COFFSym
+	for i := 0; i < ncoffsym; i++ {
 		s = &coffsym[i]
 		if s.strtbloff == 0 {
 			strnput(s.sym.Name, 8)
@@ -867,7 +828,7 @@
 	// put COFF string table
 	Lputl(uint32(len(strtbl)) + 4)
 
-	for i = 0; i < len(strtbl); i++ {
+	for i := 0; i < len(strtbl); i++ {
 		Cput(uint8(strtbl[i]))
 	}
 	strnput("", int(h.SizeOfRawData-uint32(size)))
@@ -882,22 +843,19 @@
 }
 
 func addpersrc() {
-	var h *IMAGE_SECTION_HEADER
-	var p []byte
-	var val uint32
-	var r *Reloc
-	var ri int
-
 	if rsrcsym == nil {
 		return
 	}
 
-	h = addpesection(".rsrc", int(rsrcsym.Size), int(rsrcsym.Size))
+	h := addpesection(".rsrc", int(rsrcsym.Size), int(rsrcsym.Size))
 	h.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_CNT_INITIALIZED_DATA
 	chksectoff(h, Cpos())
 
 	// relocation
-	for ri = 0; ri < len(rsrcsym.R); ri++ {
+	var p []byte
+	var r *Reloc
+	var val uint32
+	for ri := 0; ri < len(rsrcsym.R); ri++ {
 		r = &rsrcsym.R[ri]
 		p = rsrcsym.P[r.Off:]
 		val = uint32(int64(h.VirtualAddress) + r.Add)
@@ -920,9 +878,6 @@
 }
 
 func Asmbpe() {
-	var t *IMAGE_SECTION_HEADER
-	var d *IMAGE_SECTION_HEADER
-
 	switch Thearch.Thechar {
 	default:
 		Diag("unknown PE architecture")
@@ -936,12 +891,12 @@
 		fh.Machine = IMAGE_FILE_MACHINE_I386
 	}
 
-	t = addpesection(".text", int(Segtext.Length), int(Segtext.Length))
+	t := addpesection(".text", int(Segtext.Length), int(Segtext.Length))
 	t.Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
 	chksectseg(t, &Segtext)
 	textsect = pensect
 
-	d = addpesection(".data", int(Segdata.Length), int(Segdata.Filelen))
+	d := addpesection(".data", int(Segdata.Length), int(Segdata.Filelen))
 	d.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE
 	chksectseg(d, &Segdata)
 	datasect = pensect
diff --git a/src/cmd/internal/ld/sym.go b/src/cmd/internal/ld/sym.go
index 7e275a6..cbaa364a 100644
--- a/src/cmd/internal/ld/sym.go
+++ b/src/cmd/internal/ld/sym.go
@@ -63,21 +63,18 @@
 }
 
 func linknew(arch *LinkArch) *Link {
-	var ctxt *Link
-	var p string
-	var buf string
-
-	ctxt = new(Link)
+	ctxt := new(Link)
 	ctxt.Hash = make(map[symVer]*LSym)
 	ctxt.Arch = arch
 	ctxt.Version = HistVersion
 	ctxt.Goroot = obj.Getgoroot()
 
-	p = obj.Getgoarch()
+	p := obj.Getgoarch()
 	if p != arch.Name {
 		log.Fatalf("invalid goarch %s (want %s)", p, arch.Name)
 	}
 
+	var buf string
 	buf, _ = os.Getwd()
 	if buf == "" {
 		buf = "/???"
@@ -149,7 +146,7 @@
 
 	// On arm, record goarm.
 	if ctxt.Arch.Thechar == '5' {
-		p = obj.Getgoarm()
+		p := obj.Getgoarm()
 		if p != "" {
 			ctxt.Goarm = int32(obj.Atoi(p))
 		} else {
@@ -161,9 +158,7 @@
 }
 
 func linknewsym(ctxt *Link, symb string, v int) *LSym {
-	var s *LSym
-
-	s = new(LSym)
+	s := new(LSym)
 	*s = LSym{}
 
 	s.Dynid = -1
@@ -215,9 +210,7 @@
 var headstr_buf string
 
 func Headstr(v int) string {
-	var i int
-
-	for i = 0; i < len(headers); i++ {
+	for i := 0; i < len(headers); i++ {
 		if v == headers[i].val {
 			return headers[i].name
 		}
@@ -227,9 +220,7 @@
 }
 
 func headtype(name string) int {
-	var i int
-
-	for i = 0; i < len(headers); i++ {
+	for i := 0; i < len(headers); i++ {
 		if name == headers[i].name {
 			return headers[i].val
 		}
diff --git a/src/cmd/internal/ld/symtab.go b/src/cmd/internal/ld/symtab.go
index 997300c..79c1bf6 100644
--- a/src/cmd/internal/ld/symtab.go
+++ b/src/cmd/internal/ld/symtab.go
@@ -37,9 +37,6 @@
 var maxelfstr int
 
 func putelfstr(s string) int {
-	var off int
-	var n int
-
 	if len(Elfstrdat) == 0 && s != "" {
 		// first entry must be empty string
 		putelfstr("")
@@ -48,12 +45,12 @@
 	// Rewrite · to . for ASCII-only tools like DTrace (sigh)
 	s = strings.Replace(s, "·", ".", -1)
 
-	n = len(s) + 1
+	n := len(s) + 1
 	for len(Elfstrdat)+n > cap(Elfstrdat) {
 		Elfstrdat = append(Elfstrdat[:cap(Elfstrdat)], 0)[:len(Elfstrdat)]
 	}
 
-	off = len(Elfstrdat)
+	off := len(Elfstrdat)
 	Elfstrdat = Elfstrdat[:off+n]
 	copy(Elfstrdat[off:], s)
 
@@ -88,11 +85,7 @@
 var elfbind int
 
 func putelfsym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ *LSym) {
-	var bind int
 	var type_ int
-	var off int
-	var other int
-	var xo *LSym
 
 	switch t {
 	default:
@@ -108,7 +101,7 @@
 		type_ = STT_OBJECT
 	}
 
-	xo = x
+	xo := x
 	for xo.Outer != nil {
 		xo = xo.Outer
 	}
@@ -126,7 +119,7 @@
 
 	// One pass for each binding: STB_LOCAL, STB_GLOBAL,
 	// maybe one day STB_WEAK.
-	bind = STB_GLOBAL
+	bind := STB_GLOBAL
 
 	if ver != 0 || (x.Type&SHIDDEN != 0) {
 		bind = STB_LOCAL
@@ -144,11 +137,11 @@
 		return
 	}
 
-	off = putelfstr(s)
+	off := putelfstr(s)
 	if Linkmode == LinkExternal {
 		addr -= int64((xo.Sect.(*Section)).Vaddr)
 	}
-	other = 2
+	other := 2
 	if x.Type&SHIDDEN != 0 {
 		other = 0
 	}
@@ -164,9 +157,7 @@
 }
 
 func putelfsymshndx(sympos int64, shndx int) {
-	var here int64
-
-	here = Cpos()
+	here := Cpos()
 	switch Thearch.Thechar {
 	case '6':
 		Cseek(sympos + 6)
@@ -180,9 +171,6 @@
 }
 
 func Asmelfsym() {
-	var s *LSym
-	var name string
-
 	// the first symbol entry is reserved
 	putelfsyment(0, 0, 0, STB_LOCAL<<4|STT_NOTYPE, 0, 0)
 
@@ -192,7 +180,7 @@
 	genasmsym(putelfsym)
 
 	if Linkmode == LinkExternal && HEADTYPE != Hopenbsd {
-		s = Linklookup(Ctxt, "runtime.tlsg", 0)
+		s := Linklookup(Ctxt, "runtime.tlsg", 0)
 		if s.Sect == nil {
 			Ctxt.Cursym = nil
 			Diag("missing section for %s", s.Name)
@@ -214,7 +202,8 @@
 	elfglobalsymndx = numelfsym
 	genasmsym(putelfsym)
 
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	var name string
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if s.Type != SHOSTOBJ && (s.Type != SDYNIMPORT || !s.Reachable) {
 			continue
 		}
@@ -230,9 +219,6 @@
 }
 
 func putplan9sym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ *LSym) {
-	var i int
-	var l int
-
 	switch t {
 	case 'T',
 		'L',
@@ -249,7 +235,7 @@
 		'z',
 		'Z',
 		'm':
-		l = 4
+		l := 4
 		if HEADTYPE == Hplan9 && Thearch.Thechar == '6' && Debug['8'] == 0 {
 			Lputb(uint32(addr >> 32))
 			l = 8
@@ -258,6 +244,7 @@
 		Lputb(uint32(addr))
 		Cput(uint8(t + 0x80)) /* 0x80 is variable length */
 
+		var i int
 		if t == 'z' || t == 'Z' {
 			Cput(uint8(s[0]))
 			for i = 1; s[i] != 0 || s[i+1] != 0; i += 2 {
@@ -327,12 +314,6 @@
 }
 
 func symtab() {
-	var s *LSym
-	var symtype *LSym
-	var symtypelink *LSym
-	var symgostring *LSym
-	var symgofunc *LSym
-
 	dosymtype()
 
 	// Define these so that they'll get put into the symbol table.
@@ -357,7 +338,7 @@
 	xdefine("runtime.esymtab", SRODATA, 0)
 
 	// garbage collection symbols
-	s = Linklookup(Ctxt, "runtime.gcdata", 0)
+	s := Linklookup(Ctxt, "runtime.gcdata", 0)
 
 	s.Type = SRODATA
 	s.Size = 0
@@ -376,21 +357,21 @@
 	s.Type = STYPE
 	s.Size = 0
 	s.Reachable = true
-	symtype = s
+	symtype := s
 
 	s = Linklookup(Ctxt, "go.string.*", 0)
 	s.Type = SGOSTRING
 	s.Size = 0
 	s.Reachable = true
-	symgostring = s
+	symgostring := s
 
 	s = Linklookup(Ctxt, "go.func.*", 0)
 	s.Type = SGOFUNC
 	s.Size = 0
 	s.Reachable = true
-	symgofunc = s
+	symgofunc := s
 
-	symtypelink = Linklookup(Ctxt, "runtime.typelink", 0)
+	symtypelink := Linklookup(Ctxt, "runtime.typelink", 0)
 
 	symt = Linklookup(Ctxt, "runtime.symtab", 0)
 	symt.Type = SSYMTAB
@@ -401,7 +382,7 @@
 	// within a type they sort by size, so the .* symbols
 	// just defined above will be first.
 	// hide the specific symbols.
-	for s = Ctxt.Allsym; s != nil; s = s.Allsym {
+	for s := Ctxt.Allsym; s != nil; s = s.Allsym {
 		if !s.Reachable || s.Special != 0 || s.Type != SRODATA {
 			continue
 		}
diff --git a/src/cmd/internal/ld/util.go b/src/cmd/internal/ld/util.go
index 9a56f09..8c37cab 100644
--- a/src/cmd/internal/ld/util.go
+++ b/src/cmd/internal/ld/util.go
@@ -26,17 +26,14 @@
 
 func plan9quote(s string) string {
 	if s == "" {
-		goto needquote
+		return "'" + strings.Replace(s, "'", "''", -1) + "'"
 	}
 	for i := 0; i < len(s); i++ {
 		if s[i] <= ' ' || s[i] == '\'' {
-			goto needquote
+			return "'" + strings.Replace(s, "'", "''", -1) + "'"
 		}
 	}
 	return s
-
-needquote:
-	return "'" + strings.Replace(s, "'", "''", -1) + "'"
 }
 
 func tokenize(s string) []string {
diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index f82b737..064cbe2 100644
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -304,13 +304,7 @@
 // In rare cases, asmoutnacl might split p into two instructions.
 // origPC is the PC for this Prog (no padding is taken into account).
 func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint32) int {
-	var size int
-	var reg int
-	var q *obj.Prog
-	var a *obj.Addr
-	var a2 *obj.Addr
-
-	size = int(o.size)
+	size := int(o.size)
 
 	// instruction specific
 	switch p.As {
@@ -437,11 +431,12 @@
 			// split it into two instructions:
 			// 	ADD $-100004, R13
 			// 	MOVW R14, 0(R13)
-			q = ctxt.NewProg()
+			q := ctxt.NewProg()
 
 			p.Scond &^= C_WBIT
 			*q = *p
-			a = &p.To
+			a := &p.To
+			var a2 *obj.Addr
 			if p.To.Type == obj.TYPE_MEM {
 				a2 = &q.To
 			} else {
@@ -479,12 +474,13 @@
 		}
 
 		if (p.To.Type == obj.TYPE_MEM && p.To.Reg != REG_R13 && p.To.Reg != REG_R9) || (p.From.Type == obj.TYPE_MEM && p.From.Reg != REG_R13 && p.From.Reg != REG_R9) { // MOVW Rx, X(Ry), y != 13 && y != 9 // MOVW X(Rx), Ry, x != 13 && x != 9
+			var a *obj.Addr
 			if p.To.Type == obj.TYPE_MEM {
 				a = &p.To
 			} else {
 				a = &p.From
 			}
-			reg = int(a.Reg)
+			reg := int(a.Reg)
 			if size == 4 {
 				// if addr.reg == 0, then it is probably load from x(FP) with small x, no need to modify.
 				if reg == 0 {
@@ -514,8 +510,9 @@
 				if p.Scond&(C_PBIT|C_WBIT) != 0 {
 					ctxt.Diag("unsupported instruction (.P/.W): %v", p)
 				}
-				q = ctxt.NewProg()
+				q := ctxt.NewProg()
 				*q = *p
+				var a2 *obj.Addr
 				if p.To.Type == obj.TYPE_MEM {
 					a2 = &q.To
 				} else {
@@ -577,16 +574,6 @@
 func span5(ctxt *obj.Link, cursym *obj.LSym) {
 	var p *obj.Prog
 	var op *obj.Prog
-	var o *Optab
-	var m int
-	var bflag int
-	var i int
-	var v int
-	var times int
-	var c int32
-	var opc int32
-	var out [6 + 3]uint32
-	var bp []byte
 
 	p = cursym.Text
 	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
@@ -600,10 +587,13 @@
 	ctxt.Cursym = cursym
 
 	ctxt.Autosize = int32(p.To.Offset + 4)
-	c = 0
+	c := int32(0)
 
 	op = p
 	p = p.Link
+	var i int
+	var m int
+	var o *Optab
 	for ; p != nil || ctxt.Blitrl != nil; (func() { op = p; p = p.Link })() {
 		if p == nil {
 			if checkpool(ctxt, op, 0) {
@@ -676,8 +666,11 @@
 	 * generate extra passes putting branches
 	 * around jmps to fix. this is rare.
 	 */
-	times = 0
+	times := 0
 
+	var bflag int
+	var opc int32
+	var out [6 + 3]uint32
 	for {
 		if ctxt.Debugvlog != 0 {
 			fmt.Fprintf(ctxt.Bso, "%5.2f span1\n", obj.Cputime())
@@ -774,8 +767,9 @@
 	ctxt.Autosize = int32(p.To.Offset + 4)
 	obj.Symgrow(ctxt, cursym, cursym.Size)
 
-	bp = cursym.P
+	bp := cursym.P
 	c = int32(p.Pc) // even p->link might need extra padding
+	var v int
 	for p = p.Link; p != nil; p = p.Link {
 		ctxt.Pc = p.Pc
 		ctxt.Curp = p
@@ -844,14 +838,12 @@
 }
 
 func flushpool(ctxt *obj.Link, p *obj.Prog, skip int, force int) bool {
-	var q *obj.Prog
-
 	if ctxt.Blitrl != nil {
 		if skip != 0 {
 			if false && skip == 1 {
 				fmt.Printf("note: flush literal pool at %x: len=%d ref=%x\n", uint64(p.Pc+4), pool.size, pool.start)
 			}
-			q = ctxt.NewProg()
+			q := ctxt.NewProg()
 			q.As = AB
 			q.To.Type = obj.TYPE_BRANCH
 			q.Pcond = p.Link
@@ -863,7 +855,7 @@
 		}
 		if ctxt.Headtype == obj.Hnacl && pool.size%16 != 0 {
 			// if pool is not multiple of 16 bytes, add an alignment marker
-			q = ctxt.NewProg()
+			q := ctxt.NewProg()
 
 			q.As = ADATABUNDLEEND
 			ctxt.Elitrl.Link = q
@@ -893,11 +885,9 @@
 }
 
 func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
-	var q *obj.Prog
 	var t obj.Prog
-	var c int
 
-	c = aclass(ctxt, a)
+	c := aclass(ctxt, a)
 
 	t.Ctxt = ctxt
 	t.As = AWORD
@@ -928,7 +918,7 @@
 	}
 
 	if t.Pcrel == nil {
-		for q = ctxt.Blitrl; q != nil; q = q.Link { /* could hash on t.t0.offset */
+		for q := ctxt.Blitrl; q != nil; q = q.Link { /* could hash on t.t0.offset */
 			if q.Pcrel == nil && q.To == t.To {
 				p.Pcond = q
 				return
@@ -938,7 +928,7 @@
 
 	if ctxt.Headtype == obj.Hnacl && pool.size%16 == 0 {
 		// start a new data bundle
-		q = ctxt.NewProg()
+		q := ctxt.NewProg()
 		q.As = ADATABUNDLE
 		q.Pc = int64(pool.size)
 		pool.size += 4
@@ -952,7 +942,7 @@
 		ctxt.Elitrl = q
 	}
 
-	q = ctxt.NewProg()
+	q := ctxt.NewProg()
 	*q = t
 	q.Pc = int64(pool.size)
 
@@ -975,9 +965,7 @@
 }
 
 func immrot(v uint32) int32 {
-	var i int
-
-	for i = 0; i < 16; i++ {
+	for i := 0; i < 16; i++ {
 		if v&^0xff == 0 {
 			return int32(uint32(int32(i)<<8) | v | 1<<25)
 		}
@@ -1012,9 +1000,6 @@
 }
 
 func aclass(ctxt *obj.Link, a *obj.Addr) int {
-	var s *obj.LSym
-	var t int
-
 	switch a.Type {
 	case obj.TYPE_NONE:
 		return C_NONE
@@ -1060,7 +1045,7 @@
 
 		case obj.NAME_AUTO:
 			ctxt.Instoffset = int64(ctxt.Autosize) + a.Offset
-			t = int(immaddr(int32(ctxt.Instoffset)))
+			t := int(immaddr(int32(ctxt.Instoffset)))
 			if t != 0 {
 				if immhalf(int32(ctxt.Instoffset)) {
 					if immfloat(int32(t)) {
@@ -1079,7 +1064,7 @@
 
 		case obj.NAME_PARAM:
 			ctxt.Instoffset = int64(ctxt.Autosize) + a.Offset + 4
-			t = int(immaddr(int32(ctxt.Instoffset)))
+			t := int(immaddr(int32(ctxt.Instoffset)))
 			if t != 0 {
 				if immhalf(int32(ctxt.Instoffset)) {
 					if immfloat(int32(t)) {
@@ -1098,7 +1083,7 @@
 
 		case obj.TYPE_NONE:
 			ctxt.Instoffset = a.Offset
-			t = int(immaddr(int32(ctxt.Instoffset)))
+			t := int(immaddr(int32(ctxt.Instoffset)))
 			if t != 0 {
 				if immhalf(int32(ctxt.Instoffset)) { /* n.b. that it will also satisfy immrot */
 					if immfloat(int32(t)) {
@@ -1110,7 +1095,7 @@
 				if immfloat(int32(t)) {
 					return C_FOREG /* n.b. that it will also satisfy immrot */
 				}
-				t = int(immrot(uint32(ctxt.Instoffset)))
+				t := int(immrot(uint32(ctxt.Instoffset)))
 				if t != 0 {
 					return C_SROREG
 				}
@@ -1150,7 +1135,7 @@
 				return aconsize(ctxt)
 			}
 
-			t = int(immrot(uint32(ctxt.Instoffset)))
+			t := int(immrot(uint32(ctxt.Instoffset)))
 			if t != 0 {
 				return C_RCON
 			}
@@ -1162,7 +1147,7 @@
 
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC:
-			s = a.Sym
+			s := a.Sym
 			if s == nil {
 				break
 			}
@@ -1188,9 +1173,7 @@
 }
 
 func aconsize(ctxt *obj.Link) int {
-	var t int
-
-	t = int(immrot(uint32(ctxt.Instoffset)))
+	t := int(immrot(uint32(ctxt.Instoffset)))
 	if t != 0 {
 		return C_RACON
 	}
@@ -1202,16 +1185,7 @@
 }
 
 func oplook(ctxt *obj.Link, p *obj.Prog) *Optab {
-	var a1 int
-	var a2 int
-	var a3 int
-	var r int
-	var c1 []byte
-	var c3 []byte
-	var o []Optab
-	var e []Optab
-
-	a1 = int(p.Optab)
+	a1 := int(p.Optab)
 	if a1 != 0 {
 		return &optab[a1-1:][0]
 	}
@@ -1222,19 +1196,19 @@
 	}
 
 	a1--
-	a3 = int(p.To.Class)
+	a3 := int(p.To.Class)
 	if a3 == 0 {
 		a3 = aclass(ctxt, &p.To) + 1
 		p.To.Class = int8(a3)
 	}
 
 	a3--
-	a2 = C_NONE
+	a2 := C_NONE
 	if p.Reg != 0 {
 		a2 = C_REG
 	}
-	r = int(p.As)
-	o = oprange[r].start
+	r := int(p.As)
+	o := oprange[r].start
 	if o == nil {
 		o = oprange[r].stop /* just generate an error */
 	}
@@ -1244,9 +1218,9 @@
 		fmt.Printf("\t\t%d %d\n", p.From.Type, p.To.Type)
 	}
 
-	e = oprange[r].stop
-	c1 = xcmp[a1][:]
-	c3 = xcmp[a3][:]
+	e := oprange[r].stop
+	c1 := xcmp[a1][:]
+	c3 := xcmp[a3][:]
 	for ; -cap(o) < -cap(e); o = o[1:] {
 		if int(o[0].a2) == a2 {
 			if c1[o[0].a1] != 0 {
@@ -1340,13 +1314,9 @@
 }
 
 func (x ocmp) Less(i, j int) bool {
-	var p1 *Optab
-	var p2 *Optab
-	var n int
-
-	p1 = &x[i]
-	p2 = &x[j]
-	n = int(p1.as) - int(p2.as)
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
 	if n != 0 {
 		return n < 0
 	}
@@ -1366,11 +1336,9 @@
 }
 
 func buildop(ctxt *obj.Link) {
-	var i int
 	var n int
-	var r int
 
-	for i = 0; i < C_GOK; i++ {
+	for i := 0; i < C_GOK; i++ {
 		for n = 0; n < C_GOK; n++ {
 			if cmp(n, i) {
 				xcmp[i][n] = 1
@@ -1388,7 +1356,8 @@
 	}
 
 	sort.Sort(ocmp(optab[:n]))
-	for i = 0; i < n; i++ {
+	var r int
+	for i := 0; i < n; i++ {
 		r = int(optab[i].as)
 		oprange[r].start = optab[i:]
 		for int(optab[i].as) == r {
@@ -1536,26 +1505,13 @@
 }
 
 func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
-	var o1 uint32
-	var o2 uint32
-	var o3 uint32
-	var o4 uint32
-	var o5 uint32
-	var o6 uint32
-	var v int32
-	var r int
-	var rf int
-	var rt int
-	var rt2 int
-	var rel *obj.Reloc
-
 	ctxt.Printp = p
-	o1 = 0
-	o2 = 0
-	o3 = 0
-	o4 = 0
-	o5 = 0
-	o6 = 0
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+	o5 := uint32(0)
+	o6 := uint32(0)
 	ctxt.Armsize += int32(o.size)
 	if false { /*debug['P']*/
 		fmt.Printf("%x: %v\ttype %d\n", uint32(p.Pc), p, o.type_)
@@ -1573,9 +1529,9 @@
 	case 1: /* op R,[R],R */
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 
-		rf = int(p.From.Reg)
-		rt = int(p.To.Reg)
-		r = int(p.Reg)
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
 		if p.To.Type == obj.TYPE_NONE {
 			rt = 0
 		}
@@ -1591,8 +1547,8 @@
 
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 		o1 |= uint32(immrot(uint32(ctxt.Instoffset)))
-		rt = int(p.To.Reg)
-		r = int(p.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
 		if p.To.Type == obj.TYPE_NONE {
 			rt = 0
 		}
@@ -1611,7 +1567,7 @@
 
 		o1 = oprrr(ctxt, AADD, int(p.Scond))
 		o1 |= uint32(immrot(uint32(ctxt.Instoffset)))
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1621,9 +1577,9 @@
 	case 5: /* bra s */
 		o1 = opbra(ctxt, int(p.As), int(p.Scond))
 
-		v = -8
+		v := int32(-8)
 		if p.To.Sym != nil {
-			rel = obj.Addrel(ctxt.Cursym)
+			rel := obj.Addrel(ctxt.Cursym)
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 4
 			rel.Sym = p.To.Sym
@@ -1654,7 +1610,7 @@
 		}
 		o1 = oprrr(ctxt, ABL, int(p.Scond))
 		o1 |= (uint32(p.To.Reg) & 15) << 0
-		rel = obj.Addrel(ctxt.Cursym)
+		rel := obj.Addrel(ctxt.Cursym)
 		rel.Off = int32(ctxt.Pc)
 		rel.Siz = 0
 		rel.Type = obj.R_CALLIND
@@ -1663,7 +1619,7 @@
 		aclass(ctxt, &p.From)
 
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1674,7 +1630,7 @@
 	case 9: /* sll R,[R],R -> mov (R<<R),R */
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1697,7 +1653,7 @@
 		if p.To.Sym != nil {
 			// This case happens with words generated
 			// in the PC stream as part of the literal pool.
-			rel = obj.Addrel(ctxt.Cursym)
+			rel := obj.Addrel(ctxt.Cursym)
 
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 4
@@ -1742,7 +1698,7 @@
 		}
 		o2 = oprrr(ctxt, int(p.As), int(p.Scond))
 		o2 |= REGTMP & 15
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if p.As == AMOVW || p.As == AMVN {
 			r = 0
 		} else if r == 0 {
@@ -1762,7 +1718,7 @@
 			o2 = oprrr(ctxt, ASRA, int(p.Scond))
 		}
 
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		o1 |= (uint32(p.From.Reg)&15)<<0 | (uint32(r)&15)<<12
 		o2 |= uint32(r)&15 | (uint32(r)&15)<<12
 		if p.As == AMOVB || p.As == AMOVBS || p.As == AMOVBU {
@@ -1776,9 +1732,9 @@
 	case 15: /* mul r,[r,]r */
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 
-		rf = int(p.From.Reg)
-		rt = int(p.To.Reg)
-		r = int(p.Reg)
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = rt
 		}
@@ -1803,16 +1759,16 @@
 
 	case 17:
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
-		rf = int(p.From.Reg)
-		rt = int(p.To.Reg)
-		rt2 = int(p.To.Offset)
-		r = int(p.Reg)
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		rt2 := int(p.To.Offset)
+		r := int(p.Reg)
 		o1 |= (uint32(rf)&15)<<8 | (uint32(r)&15)<<0 | (uint32(rt)&15)<<16 | (uint32(rt2)&15)<<12
 
 	case 20: /* mov/movb/movbu R,O(R) */
 		aclass(ctxt, &p.To)
 
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1821,7 +1777,7 @@
 	case 21: /* mov/movbu O(R),R -> lr */
 		aclass(ctxt, &p.From)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1836,7 +1792,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1851,7 +1807,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1869,7 +1825,7 @@
 
 		o2 = oprrr(ctxt, AADD, int(p.Scond))
 		o2 |= REGTMP & 15
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1961,18 +1917,18 @@
 		o1 = 0xe8fd8000
 
 	case 50: /* floating point store */
-		v = regoff(ctxt, &p.To)
+		v := regoff(ctxt, &p.To)
 
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
 		o1 = ofsr(ctxt, int(p.As), int(p.From.Reg), v, r, int(p.Scond), p)
 
 	case 51: /* floating point load */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1984,7 +1940,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1997,7 +1953,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2007,9 +1963,9 @@
 	case 54: /* floating point arith */
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 
-		rf = int(p.From.Reg)
-		rt = int(p.To.Reg)
-		r = int(p.Reg)
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = rt
 			if p.As == AMOVF || p.As == AMOVD || p.As == AMOVFD || p.As == AMOVDF || p.As == ASQRTF || p.As == ASQRTD || p.As == AABSF || p.As == AABSD {
@@ -2033,8 +1989,8 @@
 		o1 = oprrr(ctxt, AAND, int(p.Scond))
 
 		o1 |= uint32(immrot(0xff))
-		rt = int(p.To.Reg)
-		r = int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.From.Reg)
 		if p.To.Type == obj.TYPE_NONE {
 			rt = 0
 		}
@@ -2095,7 +2051,7 @@
 
 	case 63: /* bcase */
 		if p.Pcond != nil {
-			rel = obj.Addrel(ctxt.Cursym)
+			rel := obj.Addrel(ctxt.Cursym)
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 4
 			if p.To.Sym != nil && p.To.Sym.Type != 0 {
@@ -2171,7 +2127,7 @@
 	case 70: /* movh/movhu R,O(R) -> strh */
 		aclass(ctxt, &p.To)
 
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2180,7 +2136,7 @@
 	case 71: /* movb/movh/movhu O(R),R -> ldrsb/ldrsh/ldrh */
 		aclass(ctxt, &p.From)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2197,7 +2153,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2209,7 +2165,7 @@
 		if o1 == 0 {
 			break
 		}
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2278,8 +2234,8 @@
 			o2 = oprrr(ctxt, ASUBF, int(p.Scond))
 		}
 
-		v = 0x70 // 1.0
-		r = (int(p.To.Reg) & 15) << 0
+		v := int32(0x70) // 1.0
+		r := (int(p.To.Reg) & 15) << 0
 
 		// movf $1.0, r
 		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
@@ -2298,7 +2254,7 @@
 		}
 		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
 		o1 |= (uint32(p.To.Reg) & 15) << 12
-		v = int32(chipfloat5(ctxt, p.From.U.Dval))
+		v := int32(chipfloat5(ctxt, p.From.U.Dval))
 		o1 |= (uint32(v) & 0xf) << 0
 		o1 |= (uint32(v) & 0xf0) << 12
 
@@ -2475,18 +2431,14 @@
 }
 
 func mov(ctxt *obj.Link, p *obj.Prog) uint32 {
-	var o1 uint32
-	var rt int
-	var r int
-
 	aclass(ctxt, &p.From)
-	o1 = oprrr(ctxt, int(p.As), int(p.Scond))
+	o1 := oprrr(ctxt, int(p.As), int(p.Scond))
 	o1 |= uint32(p.From.Offset)
-	rt = int(p.To.Reg)
+	rt := int(p.To.Reg)
 	if p.To.Type == obj.TYPE_NONE {
 		rt = 0
 	}
-	r = int(p.Reg)
+	r := int(p.Reg)
 	if p.As == AMOVW || p.As == AMVN {
 		r = 0
 	} else if r == 0 {
@@ -2497,9 +2449,7 @@
 }
 
 func oprrr(ctxt *obj.Link, a int, sc int) uint32 {
-	var o uint32
-
-	o = ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
 	if sc&C_SBIT != 0 {
 		o |= 1 << 20
 	}
@@ -2716,12 +2666,10 @@
 }
 
 func olr(ctxt *obj.Link, v int32, b int, r int, sc int) uint32 {
-	var o uint32
-
 	if sc&C_SBIT != 0 {
 		ctxt.Diag(".nil on LDR/STR instruction")
 	}
-	o = ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
 	if sc&C_PBIT == 0 {
 		o |= 1 << 24
 	}
@@ -2750,12 +2698,10 @@
 }
 
 func olhr(ctxt *obj.Link, v int32, b int, r int, sc int) uint32 {
-	var o uint32
-
 	if sc&C_SBIT != 0 {
 		ctxt.Diag(".nil on LDRH/STRH instruction")
 	}
-	o = ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
 	if sc&C_PBIT == 0 {
 		o |= 1 << 24
 	}
@@ -2778,9 +2724,7 @@
 }
 
 func osr(ctxt *obj.Link, a int, r int, v int32, b int, sc int) uint32 {
-	var o uint32
-
-	o = olr(ctxt, v, b, r, sc) ^ (1 << 20)
+	o := olr(ctxt, v, b, r, sc) ^ (1 << 20)
 	if a != AMOVW {
 		o |= 1 << 22
 	}
@@ -2788,9 +2732,7 @@
 }
 
 func oshr(ctxt *obj.Link, r int, v int32, b int, sc int) uint32 {
-	var o uint32
-
-	o = olhr(ctxt, v, b, r, sc) ^ (1 << 20)
+	o := olhr(ctxt, v, b, r, sc) ^ (1 << 20)
 	return o
 }
 
@@ -2811,12 +2753,10 @@
 }
 
 func ofsr(ctxt *obj.Link, a int, r int, v int32, b int, sc int, p *obj.Prog) uint32 {
-	var o uint32
-
 	if sc&C_SBIT != 0 {
 		ctxt.Diag(".nil on FLDR/FSTR instruction")
 	}
-	o = ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
 	if sc&C_PBIT == 0 {
 		o |= 1 << 24
 	}
@@ -2855,11 +2795,10 @@
 }
 
 func omvl(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, dr int) uint32 {
-	var v int32
 	var o1 uint32
 	if p.Pcond == nil {
 		aclass(ctxt, a)
-		v = immrot(^uint32(ctxt.Instoffset))
+		v := immrot(^uint32(ctxt.Instoffset))
 		if v == 0 {
 			ctxt.Diag("missing literal")
 			prasm(p)
@@ -2870,7 +2809,7 @@
 		o1 |= uint32(v)
 		o1 |= (uint32(dr) & 15) << 12
 	} else {
-		v = int32(p.Pcond.Pc - p.Pc - 8)
+		v := int32(p.Pcond.Pc - p.Pc - 8)
 		o1 = olr(ctxt, v, REGPC, dr, int(p.Scond)&C_SCOND)
 	}
 
@@ -2886,29 +2825,23 @@
 }
 
 func chipfloat5(ctxt *obj.Link, e float64) int {
-	var n int
-	var h1 uint32
-	var l uint32
-	var h uint32
-	var ei uint64
-
 	// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
 	if ctxt.Goarm < 7 {
-		goto no
+		return -1
 	}
 
-	ei = math.Float64bits(e)
-	l = uint32(ei)
-	h = uint32(ei >> 32)
+	ei := math.Float64bits(e)
+	l := uint32(ei)
+	h := uint32(ei >> 32)
 
 	if l != 0 || h&0xffff != 0 {
-		goto no
+		return -1
 	}
-	h1 = h & 0x7fc00000
+	h1 := h & 0x7fc00000
 	if h1 != 0x40000000 && h1 != 0x3fc00000 {
-		goto no
+		return -1
 	}
-	n = 0
+	n := 0
 
 	// sign bit (a)
 	if h&0x80000000 != 0 {
@@ -2925,7 +2858,4 @@
 
 	//print("match %.8lux %.8lux %d\n", l, h, n);
 	return n
-
-no:
-	return -1
 }
diff --git a/src/cmd/internal/obj/arm/list5.go b/src/cmd/internal/obj/arm/list5.go
index 70280f3..60caede 100644
--- a/src/cmd/internal/obj/arm/list5.go
+++ b/src/cmd/internal/obj/arm/list5.go
@@ -61,16 +61,9 @@
 var bigP *obj.Prog
 
 func Pconv(p *obj.Prog) string {
-	var str string
-	var sc string
-	var fp string
-
-	var a int
-	var s int
-
-	a = int(p.As)
-	s = int(p.Scond)
-	sc = extra[(s&C_SCOND)^C_SCOND_XOR]
+	a := int(p.As)
+	s := int(p.Scond)
+	sc := extra[(s&C_SCOND)^C_SCOND_XOR]
 	if s&C_SBIT != 0 {
 		sc += ".S"
 	}
@@ -83,6 +76,7 @@
 	if s&C_UBIT != 0 { /* ambiguous with FBIT */
 		sc += ".U"
 	}
+	var str string
 	if a == obj.ADATA {
 		str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
 			p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
@@ -97,30 +91,23 @@
 			p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, &p.From), Rconv(int(p.Reg)), obj.Dconv(p, &p.To))
 	}
 
+	var fp string
 	fp += str
 	return fp
 }
 
 func Aconv(a int) string {
-	var s string
-	var fp string
-
-	s = "???"
+	s := "???"
 	if a >= obj.AXXX && a < ALAST {
 		s = Anames[a]
 	}
+	var fp string
 	fp += s
 	return fp
 }
 
 func RAconv(a *obj.Addr) string {
-	var str string
-	var fp string
-
-	var i int
-	var v int
-
-	str = fmt.Sprintf("GOK-reglist")
+	str := fmt.Sprintf("GOK-reglist")
 	switch a.Type {
 	case obj.TYPE_CONST:
 		if a.Reg != 0 {
@@ -129,9 +116,9 @@
 		if a.Sym != nil {
 			break
 		}
-		v = int(a.Offset)
+		v := int(a.Offset)
 		str = ""
-		for i = 0; i < NREG; i++ {
+		for i := 0; i < NREG; i++ {
 			if v&(1<<uint(i)) != 0 {
 				if str == "" {
 					str += "[R"
@@ -145,6 +132,7 @@
 		str += "]"
 	}
 
+	var fp string
 	fp += str
 	return fp
 }
@@ -182,13 +170,11 @@
 }
 
 func DRconv(a int) string {
-	var s string
-	var fp string
-
-	s = "C_??"
+	s := "C_??"
 	if a >= C_NONE && a <= C_NCLASS {
 		s = cnames5[a]
 	}
+	var fp string
 	fp += s
 	return fp
 }
diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 9c1baca..0b7e1f7 100644
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -41,9 +41,6 @@
 var progedit_tlsfallback *obj.LSym
 
 func progedit(ctxt *obj.Link, p *obj.Prog) {
-	var literal string
-	var s *obj.LSym
-
 	p.From.Class = 0
 	p.To.Class = 0
 
@@ -111,12 +108,10 @@
 	switch p.As {
 	case AMOVF:
 		if p.From.Type == obj.TYPE_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
-			var i32 uint32
-			var f32 float32
-			f32 = float32(p.From.U.Dval)
-			i32 = math.Float32bits(f32)
-			literal = fmt.Sprintf("$f32.%08x", i32)
-			s = obj.Linklookup(ctxt, literal, 0)
+			f32 := float32(p.From.U.Dval)
+			i32 := math.Float32bits(f32)
+			literal := fmt.Sprintf("$f32.%08x", i32)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint32(ctxt, s, i32)
@@ -131,10 +126,9 @@
 
 	case AMOVD:
 		if p.From.Type == obj.TYPE_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
-			var i64 uint64
-			i64 = math.Float64bits(p.From.U.Dval)
-			literal = fmt.Sprintf("$f64.%016x", i64)
-			s = obj.Linklookup(ctxt, literal, 0)
+			i64 := math.Float64bits(p.From.U.Dval)
+			literal := fmt.Sprintf("$f64.%016x", i64)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint64(ctxt, s, i64)
@@ -175,9 +169,7 @@
 )
 
 func linkcase(casep *obj.Prog) {
-	var p *obj.Prog
-
-	for p = casep; p != nil; p = p.Link {
+	for p := casep; p != nil; p = p.Link {
 		if p.As == ABCASE {
 			for ; p != nil && p.As == ABCASE; p = p.Link {
 				p.Pcrel = casep
@@ -188,25 +180,14 @@
 }
 
 func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var pl *obj.Prog
-	var p1 *obj.Prog
-	var p2 *obj.Prog
-	var q *obj.Prog
-	var q1 *obj.Prog
-	var q2 *obj.Prog
-	var o int
-	var autosize int32
-	var autoffset int32
-
-	autosize = 0
+	autosize := int32(0)
 
 	if ctxt.Symmorestack[0] == nil {
 		ctxt.Symmorestack[0] = obj.Linklookup(ctxt, "runtime.morestack", 0)
 		ctxt.Symmorestack[1] = obj.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
 	}
 
-	q = nil
+	q := (*obj.Prog)(nil)
 
 	ctxt.Cursym = cursym
 
@@ -216,8 +197,8 @@
 
 	softfloat(ctxt, cursym)
 
-	p = cursym.Text
-	autoffset = int32(p.To.Offset)
+	p := cursym.Text
+	autoffset := int32(p.To.Offset)
 	if autoffset < 0 {
 		autoffset = 0
 	}
@@ -259,8 +240,8 @@
 			//	MOVW.nil R3, 0(R1) +4
 			//	CMP R1, R2
 			//	BNE L
-			pl = obj.Appendp(ctxt, p)
-			p = pl
+			pl := obj.Appendp(ctxt, p)
+			p := pl
 
 			p.As = AMOVW
 			p.From.Type = obj.TYPE_REG
@@ -289,7 +270,8 @@
 	 * expand RET
 	 * expand BECOME pseudo
 	 */
-	for p = cursym.Text; p != nil; p = p.Link {
+	var q1 *obj.Prog
+	for p := cursym.Text; p != nil; p = p.Link {
 		switch p.As {
 		case ACASE:
 			if ctxt.Flag_shared != 0 {
@@ -358,7 +340,11 @@
 		q = p
 	}
 
-	for p = cursym.Text; p != nil; p = p.Link {
+	var o int
+	var p1 *obj.Prog
+	var p2 *obj.Prog
+	var q2 *obj.Prog
+	for p := cursym.Text; p != nil; p = p.Link {
 		o = int(p.As)
 		switch o {
 		case obj.ATEXT:
@@ -667,24 +653,20 @@
 }
 
 func softfloat(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var next *obj.Prog
-	var symsfloat *obj.LSym
-	var wasfloat int
-
 	if ctxt.Goarm > 5 {
 		return
 	}
 
-	symsfloat = obj.Linklookup(ctxt, "_sfloat", 0)
+	symsfloat := obj.Linklookup(ctxt, "_sfloat", 0)
 
-	wasfloat = 0
-	for p = cursym.Text; p != nil; p = p.Link {
+	wasfloat := 0
+	for p := cursym.Text; p != nil; p = p.Link {
 		if p.Pcond != nil {
 			p.Pcond.Mark |= LABEL
 		}
 	}
-	for p = cursym.Text; p != nil; p = p.Link {
+	var next *obj.Prog
+	for p := cursym.Text; p != nil; p = p.Link {
 		switch p.As {
 		case AMOVW:
 			if isfloatreg(&p.To) || isfloatreg(&p.From) {
@@ -880,13 +862,10 @@
 }
 
 func follow(ctxt *obj.Link, s *obj.LSym) {
-	var firstp *obj.Prog
-	var lastp *obj.Prog
-
 	ctxt.Cursym = s
 
-	firstp = ctxt.NewProg()
-	lastp = firstp
+	firstp := ctxt.NewProg()
+	lastp := firstp
 	xfol(ctxt, s.Text, &lastp)
 	lastp.Link = nil
 	s.Text = firstp.Link
diff --git a/src/cmd/internal/obj/i386/asm8.go b/src/cmd/internal/obj/i386/asm8.go
index 4284586..112e839 100644
--- a/src/cmd/internal/obj/i386/asm8.go
+++ b/src/cmd/internal/obj/i386/asm8.go
@@ -1132,16 +1132,6 @@
 }
 
 func span8(ctxt *obj.Link, s *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var c int32
-	var v int32
-	var loop int32
-	var bp []byte
-	var n int
-	var m int
-	var i int
-
 	ctxt.Cursym = s
 
 	if s.Text == nil || s.Text.Link == nil {
@@ -1152,7 +1142,8 @@
 		instinit()
 	}
 
-	for p = s.Text; p != nil; p = p.Link {
+	var v int32
+	for p := s.Text; p != nil; p = p.Link {
 		if p.To.Type == obj.TYPE_BRANCH {
 			if p.Pcond == nil {
 				p.Pcond = p
@@ -1176,7 +1167,8 @@
 		}
 	}
 
-	for p = s.Text; p != nil; p = p.Link {
+	var q *obj.Prog
+	for p := s.Text; p != nil; p = p.Link {
 		p.Back = 2 // use short branches first time through
 		q = p.Pcond
 		if q != nil && (q.Back&2 != 0) {
@@ -1201,7 +1193,13 @@
 		}
 	}
 
-	n = 0
+	n := 0
+	var bp []byte
+	var c int32
+	var i int
+	var loop int32
+	var m int
+	var p *obj.Prog
 	for {
 		loop = 0
 		for i = 0; i < len(s.R); i++ {
@@ -1313,6 +1311,7 @@
 
 	if false { /* debug['a'] > 1 */
 		fmt.Printf("span1 %s %d (%d tries)\n %.6x", s.Name, s.Size, n, 0)
+		var i int
 		for i = 0; i < len(s.P); i++ {
 			fmt.Printf(" %.2x", s.P[i])
 			if i%16 == 15 {
@@ -1324,20 +1323,17 @@
 			fmt.Printf("\n")
 		}
 
-		for i = 0; i < len(s.R); i++ {
-			var r *obj.Reloc
-
-			r = &s.R[i]
+		for i := 0; i < len(s.R); i++ {
+			r := &s.R[i]
 			fmt.Printf(" rel %#.4x/%d %s%+d\n", uint32(r.Off), r.Siz, r.Sym.Name, r.Add)
 		}
 	}
 }
 
 func instinit() {
-	var i int
 	var c int
 
-	for i = 1; optab[i].as != 0; i++ {
+	for i := 1; optab[i].as != 0; i++ {
 		c = int(optab[i].as)
 		if opindex[c] != nil {
 			log.Fatalf("phase error in optab: %d (%v)", i, Aconv(c))
@@ -1345,7 +1341,7 @@
 		opindex[c] = &optab[i]
 	}
 
-	for i = 0; i < Ymax; i++ {
+	for i := 0; i < Ymax; i++ {
 		ycover[i*Ymax+i] = 1
 	}
 
@@ -1395,7 +1391,7 @@
 	ycover[Ym*Ymax+Yxm] = 1
 	ycover[Yxr*Ymax+Yxm] = 1
 
-	for i = 0; i < MAXREG; i++ {
+	for i := 0; i < MAXREG; i++ {
 		reg[i] = -1
 		if i >= REG_AL && i <= REG_BH {
 			reg[i] = (i - REG_AL) & 7
@@ -1455,8 +1451,6 @@
 }
 
 func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
-	var v int32
-
 	// TODO(rsc): This special case is for SHRQ $3, AX:DX,
 	// which encodes as SHRQ $32(DX*0), AX.
 	// Similarly SHRQ CX, AX:DX is really SHRQ CX(DX*0), AX.
@@ -1512,7 +1506,7 @@
 			ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
 		}
 
-		v = int32(a.Offset)
+		v := int32(a.Offset)
 		if v == 0 {
 			return Yi0
 		}
@@ -1742,16 +1736,14 @@
 }
 
 func relput4(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
-	var v int64
 	var rel obj.Reloc
-	var r *obj.Reloc
 
-	v = int64(vaddr(ctxt, p, a, &rel))
+	v := int64(vaddr(ctxt, p, a, &rel))
 	if rel.Siz != 0 {
 		if rel.Siz != 4 {
 			ctxt.Diag("bad reloc")
 		}
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		*r = rel
 		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
 	}
@@ -1760,8 +1752,6 @@
 }
 
 func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 {
-	var s *obj.LSym
-
 	if r != nil {
 		*r = obj.Reloc{}
 	}
@@ -1769,7 +1759,7 @@
 	switch a.Name {
 	case obj.NAME_STATIC,
 		obj.NAME_EXTERN:
-		s = a.Sym
+		s := a.Sym
 		if s != nil {
 			if r == nil {
 				ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
@@ -1804,11 +1794,10 @@
 }
 
 func asmand(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int) {
-	var v int32
 	var base int
 	var rel obj.Reloc
 
-	v = int32(a.Offset)
+	v := int32(a.Offset)
 	rel.Siz = 0
 
 	switch a.Type {
@@ -1838,7 +1827,7 @@
 	}
 
 	if a.Index != REG_NONE && a.Index != REG_TLS {
-		base = int(a.Reg)
+		base := int(a.Reg)
 		switch a.Name {
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC:
@@ -1956,14 +1945,12 @@
 
 putrelv:
 	if rel.Siz != 0 {
-		var r *obj.Reloc
-
 		if rel.Siz != 4 {
 			ctxt.Diag("bad rel")
 			goto bad
 		}
 
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		*r = rel
 		r.Off = int32(ctxt.Curp.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
 	}
@@ -2568,15 +2555,10 @@
 // If a is empty, it returns BX to account for MULB-like instructions
 // that might use DX and AX.
 func byteswapreg(ctxt *obj.Link, a *obj.Addr) int {
-	var cana int
-	var canb int
-	var canc int
-	var cand int
-
-	cand = 1
-	canc = cand
-	canb = canc
-	cana = canb
+	cand := 1
+	canc := cand
+	canb := canc
+	cana := canb
 
 	if a.Type == obj.TYPE_NONE {
 		cand = 0
@@ -2707,25 +2689,9 @@
 }
 
 func doasm(ctxt *obj.Link, p *obj.Prog) {
-	var o *Optab
-	var q *obj.Prog
-	var pp obj.Prog
-	var t []byte
-	var z int
-	var op int
-	var ft int
-	var tt int
-	var breg int
-	var v int32
-	var pre int32
-	var rel obj.Reloc
-	var r *obj.Reloc
-	var a *obj.Addr
-	var yt ytab
-
 	ctxt.Curp = p // TODO
 
-	pre = int32(prefixof(ctxt, &p.From))
+	pre := int32(prefixof(ctxt, &p.From))
 
 	if pre != 0 {
 		ctxt.Andptr[0] = byte(pre)
@@ -2744,458 +2710,637 @@
 		p.Tt = uint8(oclass(ctxt, p, &p.To))
 	}
 
-	ft = int(p.Ft) * Ymax
-	tt = int(p.Tt) * Ymax
-	o = opindex[p.As]
+	ft := int(p.Ft) * Ymax
+	tt := int(p.Tt) * Ymax
+	o := opindex[p.As]
 
-	z = 0
+	z := 0
+	var a *obj.Addr
+	var op int
+	var q *obj.Prog
+	var r *obj.Reloc
+	var rel obj.Reloc
+	var v int32
+	var yt ytab
 	for _, yt = range o.ytab {
 		if ycover[ft+int(yt.from)] != 0 && ycover[tt+int(yt.to)] != 0 {
-			goto found
+			switch o.prefix {
+			case Pq: /* 16 bit escape and opcode escape */
+				ctxt.Andptr[0] = Pe
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Pf2, /* xmm opcode escape */
+				Pf3:
+				ctxt.Andptr[0] = byte(o.prefix)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Pm: /* opcode escape */
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Pe: /* 16 bit escape */
+				ctxt.Andptr[0] = Pe
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Pb: /* botch */
+				break
+			}
+
+			op = int(o.op[z])
+			switch yt.zcase {
+			default:
+				ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
+				return
+
+			case Zpseudo:
+				break
+
+			case Zlit:
+				for ; ; z++ {
+					op = int(o.op[z])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+
+			case Zlitm_r:
+				for ; ; z++ {
+					op = int(o.op[z])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+			case Zm_r:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+			case Zm2_r:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(o.op[z+1])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+			case Zm_r_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+			case Zm_r_i_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+				ctxt.Andptr[0] = byte(p.To.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zibm_r:
+				for {
+					tmp2 := z
+					z++
+					op = int(o.op[tmp2])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+				ctxt.Andptr[0] = byte(p.To.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zaut_r:
+				ctxt.Andptr[0] = 0x8d
+				ctxt.Andptr = ctxt.Andptr[1:] /* leal */
+				if p.From.Type != obj.TYPE_ADDR {
+					ctxt.Diag("asmins: Zaut sb type ADDR")
+				}
+				p.From.Type = obj.TYPE_MEM
+				p.Ft = 0
+				asmand(ctxt, p, &p.From, reg[p.To.Reg])
+				p.From.Type = obj.TYPE_ADDR
+				p.Ft = 0
+
+			case Zm_o:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, int(o.op[z+1]))
+
+			case Zr_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, reg[p.From.Reg])
+
+			case Zr_m_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.To, reg[p.From.Reg])
+
+			case Zr_m_i_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.To, reg[p.From.Reg])
+				ctxt.Andptr[0] = byte(p.From.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zcallindreg:
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc)
+				r.Type = obj.R_CALLIND
+				r.Siz = 0
+				fallthrough
+
+				// fallthrough
+			case Zo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+				asmand(ctxt, p, &p.To, int(o.op[z+1]))
+
+			case Zm_ibo:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, int(o.op[z+1]))
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.To, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zibo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, int(o.op[z+1]))
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Z_ib,
+				Zib_:
+				if yt.zcase == Zib_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
+				v = vaddr(ctxt, p, a, nil)
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(v)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zib_rp:
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zil_rp:
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, &p.From)
+				}
+
+			case Zib_rr:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, reg[p.To.Reg])
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Z_il,
+				Zil_:
+				if yt.zcase == Zil_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, a)
+				}
+
+			case Zm_ilo,
+				Zilo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if yt.zcase == Zilo_m {
+					a = &p.From
+					asmand(ctxt, p, &p.To, int(o.op[z+1]))
+				} else {
+					a = &p.To
+					asmand(ctxt, p, &p.From, int(o.op[z+1]))
+				}
+
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, a)
+				}
+
+			case Zil_rr:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, reg[p.To.Reg])
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, &p.From)
+				}
+
+			case Z_rp:
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zrp_:
+				ctxt.Andptr[0] = byte(op + reg[p.From.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zclr:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, reg[p.To.Reg])
+
+			case Zcall:
+				if p.To.Sym == nil {
+					ctxt.Diag("call without target")
+					log.Fatalf("bad code")
+				}
+
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				r.Type = obj.R_CALL
+				r.Siz = 4
+				r.Sym = p.To.Sym
+				r.Add = p.To.Offset
+				put4(ctxt, 0)
+
+			case Zbr,
+				Zjmp,
+				Zloop:
+				if p.To.Sym != nil {
+					if yt.zcase != Zjmp {
+						ctxt.Diag("branch to ATEXT")
+						log.Fatalf("bad code")
+					}
+
+					ctxt.Andptr[0] = byte(o.op[z+1])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					r = obj.Addrel(ctxt.Cursym)
+					r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+					r.Sym = p.To.Sym
+					r.Type = obj.R_PCREL
+					r.Siz = 4
+					put4(ctxt, 0)
+					break
+				}
+
+				// Assumes q is in this function.
+				// Fill in backward jump now.
+				q = p.Pcond
+
+				if q == nil {
+					ctxt.Diag("jmp/branch/loop without target")
+					log.Fatalf("bad code")
+				}
+
+				if p.Back&1 != 0 {
+					v = int32(q.Pc - (p.Pc + 2))
+					if v >= -128 {
+						if p.As == AJCXZW {
+							ctxt.Andptr[0] = 0x67
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+						ctxt.Andptr[0] = byte(op)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v)
+						ctxt.Andptr = ctxt.Andptr[1:]
+					} else if yt.zcase == Zloop {
+						ctxt.Diag("loop too far: %v", p)
+					} else {
+						v -= 5 - 2
+						if yt.zcase == Zbr {
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							v--
+						}
+
+						ctxt.Andptr[0] = byte(o.op[z+1])
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 8)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 16)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 24)
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+
+					break
+				}
+
+				// Annotate target; will fill in later.
+				p.Forwd = q.Comefrom
+
+				q.Comefrom = p
+				if p.Back&2 != 0 { // short
+					if p.As == AJCXZW {
+						ctxt.Andptr[0] = 0x67
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else if yt.zcase == Zloop {
+					ctxt.Diag("loop too far: %v", p)
+				} else {
+					if yt.zcase == Zbr {
+						ctxt.Andptr[0] = 0x0f
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+					ctxt.Andptr[0] = byte(o.op[z+1])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+
+			case Zcallcon,
+				Zjmpcon:
+				if yt.zcase == Zcallcon {
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					ctxt.Andptr[0] = byte(o.op[z+1])
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				r.Type = obj.R_PCREL
+				r.Siz = 4
+				r.Add = p.To.Offset
+				put4(ctxt, 0)
+
+			case Zcallind:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(o.op[z+1])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				r.Type = obj.R_ADDR
+				r.Siz = 4
+				r.Add = p.To.Offset
+				r.Sym = p.To.Sym
+				put4(ctxt, 0)
+
+			case Zbyte:
+				v = vaddr(ctxt, p, &p.From, &rel)
+				if rel.Siz != 0 {
+					rel.Siz = uint8(op)
+					r = obj.Addrel(ctxt.Cursym)
+					*r = rel
+					r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				}
+
+				ctxt.Andptr[0] = byte(v)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if op > 1 {
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					if op > 2 {
+						ctxt.Andptr[0] = byte(v >> 16)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 24)
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+				}
+
+			case Zmov:
+				goto domov
+			}
+
+			return
 		}
 		z += int(yt.zoffset)
 	}
 	goto domov
 
-found:
-	switch o.prefix {
-	case Pq: /* 16 bit escape and opcode escape */
-		ctxt.Andptr[0] = Pe
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Pf2, /* xmm opcode escape */
-		Pf3:
-		ctxt.Andptr[0] = byte(o.prefix)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Pm: /* opcode escape */
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Pe: /* 16 bit escape */
-		ctxt.Andptr[0] = Pe
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Pb: /* botch */
-		break
-	}
-
-	op = int(o.op[z])
-	switch yt.zcase {
-	default:
-		ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
-		return
-
-	case Zpseudo:
-		break
-
-	case Zlit:
-		for ; ; z++ {
-			op = int(o.op[z])
-			if op == 0 {
-				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-	case Zlitm_r:
-		for ; ; z++ {
-			op = int(o.op[z])
-			if op == 0 {
-				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-	case Zm_r:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-	case Zm2_r:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(o.op[z+1])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-	case Zm_r_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-	case Zm_r_i_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-		ctxt.Andptr[0] = byte(p.To.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zibm_r:
-		for {
-			tmp2 := z
-			z++
-			op = int(o.op[tmp2])
-			if op == 0 {
-				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-		ctxt.Andptr[0] = byte(p.To.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zaut_r:
-		ctxt.Andptr[0] = 0x8d
-		ctxt.Andptr = ctxt.Andptr[1:] /* leal */
-		if p.From.Type != obj.TYPE_ADDR {
-			ctxt.Diag("asmins: Zaut sb type ADDR")
-		}
-		p.From.Type = obj.TYPE_MEM
-		p.Ft = 0
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-		p.From.Type = obj.TYPE_ADDR
-		p.Ft = 0
-
-	case Zm_o:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, int(o.op[z+1]))
-
-	case Zr_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, reg[p.From.Reg])
-
-	case Zr_m_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.To, reg[p.From.Reg])
-
-	case Zr_m_i_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.To, reg[p.From.Reg])
-		ctxt.Andptr[0] = byte(p.From.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zcallindreg:
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc)
-		r.Type = obj.R_CALLIND
-		r.Siz = 0
-		fallthrough
-
-		// fallthrough
-	case Zo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmand(ctxt, p, &p.To, int(o.op[z+1]))
-
-	case Zm_ibo:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, int(o.op[z+1]))
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.To, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zibo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, int(o.op[z+1]))
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Z_ib,
-		Zib_:
-		if yt.zcase == Zib_ {
-			a = &p.From
-		} else {
-			a = &p.To
-		}
-		v = vaddr(ctxt, p, a, nil)
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(v)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zib_rp:
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zil_rp:
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, &p.From, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, &p.From)
-		}
-
-	case Zib_rr:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, reg[p.To.Reg])
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Z_il,
-		Zil_:
-		if yt.zcase == Zil_ {
-			a = &p.From
-		} else {
-			a = &p.To
-		}
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, a, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, a)
-		}
-
-	case Zm_ilo,
-		Zilo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if yt.zcase == Zilo_m {
-			a = &p.From
-			asmand(ctxt, p, &p.To, int(o.op[z+1]))
-		} else {
-			a = &p.To
-			asmand(ctxt, p, &p.From, int(o.op[z+1]))
-		}
-
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, a, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, a)
-		}
-
-	case Zil_rr:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, reg[p.To.Reg])
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, &p.From, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, &p.From)
-		}
-
-	case Z_rp:
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zrp_:
-		ctxt.Andptr[0] = byte(op + reg[p.From.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zclr:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, reg[p.To.Reg])
-
-	case Zcall:
-		if p.To.Sym == nil {
-			ctxt.Diag("call without target")
-			log.Fatalf("bad code")
-		}
-
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		r.Type = obj.R_CALL
-		r.Siz = 4
-		r.Sym = p.To.Sym
-		r.Add = p.To.Offset
-		put4(ctxt, 0)
-
-	case Zbr,
-		Zjmp,
-		Zloop:
-		if p.To.Sym != nil {
-			if yt.zcase != Zjmp {
-				ctxt.Diag("branch to ATEXT")
-				log.Fatalf("bad code")
-			}
-
-			ctxt.Andptr[0] = byte(o.op[z+1])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			r = obj.Addrel(ctxt.Cursym)
-			r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-			r.Sym = p.To.Sym
-			r.Type = obj.R_PCREL
-			r.Siz = 4
-			put4(ctxt, 0)
-			break
-		}
-
-		// Assumes q is in this function.
-		// Fill in backward jump now.
-		q = p.Pcond
-
-		if q == nil {
-			ctxt.Diag("jmp/branch/loop without target")
-			log.Fatalf("bad code")
-		}
-
-		if p.Back&1 != 0 {
-			v = int32(q.Pc - (p.Pc + 2))
-			if v >= -128 {
-				if p.As == AJCXZW {
-					ctxt.Andptr[0] = 0x67
-					ctxt.Andptr = ctxt.Andptr[1:]
-				}
-				ctxt.Andptr[0] = byte(op)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v)
-				ctxt.Andptr = ctxt.Andptr[1:]
-			} else if yt.zcase == Zloop {
-				ctxt.Diag("loop too far: %v", p)
-			} else {
-				v -= 5 - 2
-				if yt.zcase == Zbr {
-					ctxt.Andptr[0] = 0x0f
-					ctxt.Andptr = ctxt.Andptr[1:]
-					v--
-				}
-
-				ctxt.Andptr[0] = byte(o.op[z+1])
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 8)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 16)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 24)
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-
-			break
-		}
-
-		// Annotate target; will fill in later.
-		p.Forwd = q.Comefrom
-
-		q.Comefrom = p
-		if p.Back&2 != 0 { // short
-			if p.As == AJCXZW {
-				ctxt.Andptr[0] = 0x67
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else if yt.zcase == Zloop {
-			ctxt.Diag("loop too far: %v", p)
-		} else {
-			if yt.zcase == Zbr {
-				ctxt.Andptr[0] = 0x0f
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-			ctxt.Andptr[0] = byte(o.op[z+1])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-	case Zcallcon,
-		Zjmpcon:
-		if yt.zcase == Zcallcon {
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			ctxt.Andptr[0] = byte(o.op[z+1])
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		r.Type = obj.R_PCREL
-		r.Siz = 4
-		r.Add = p.To.Offset
-		put4(ctxt, 0)
-
-	case Zcallind:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(o.op[z+1])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		r.Type = obj.R_ADDR
-		r.Siz = 4
-		r.Add = p.To.Offset
-		r.Sym = p.To.Sym
-		put4(ctxt, 0)
-
-	case Zbyte:
-		v = vaddr(ctxt, p, &p.From, &rel)
-		if rel.Siz != 0 {
-			rel.Siz = uint8(op)
-			r = obj.Addrel(ctxt.Cursym)
-			*r = rel
-			r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		}
-
-		ctxt.Andptr[0] = byte(v)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if op > 1 {
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			if op > 2 {
-				ctxt.Andptr[0] = byte(v >> 16)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 24)
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-		}
-
-	case Zmov:
-		goto domov
-	}
-
-	return
-
 domov:
-	for t = []byte(ymovtab); t[0] != 0; t = t[8:] {
+	var pp obj.Prog
+	for t := []byte(ymovtab); t[0] != 0; t = t[8:] {
 		if p.As == int16(t[0]) {
 			if ycover[ft+int(t[1])] != 0 {
 				if ycover[tt+int(t[2])] != 0 {
-					goto mfound
+					switch t[3] {
+					default:
+						ctxt.Diag("asmins: unknown mov %d %v", t[3], p)
+
+					case 0: /* lit */
+						for z = 4; t[z] != E; z++ {
+							ctxt.Andptr[0] = t[z]
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+
+					case 1: /* r,m */
+						ctxt.Andptr[0] = t[4]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						asmand(ctxt, p, &p.To, int(t[5]))
+
+					case 2: /* m,r */
+						ctxt.Andptr[0] = t[4]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						asmand(ctxt, p, &p.From, int(t[5]))
+
+					case 3: /* r,m - 2op */
+						ctxt.Andptr[0] = t[4]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						ctxt.Andptr[0] = t[5]
+						ctxt.Andptr = ctxt.Andptr[1:]
+						asmand(ctxt, p, &p.To, int(t[6]))
+
+					case 4: /* m,r - 2op */
+						ctxt.Andptr[0] = t[4]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						ctxt.Andptr[0] = t[5]
+						ctxt.Andptr = ctxt.Andptr[1:]
+						asmand(ctxt, p, &p.From, int(t[6]))
+
+					case 5: /* load full pointer, trash heap */
+						if t[4] != 0 {
+							ctxt.Andptr[0] = t[4]
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+						switch p.To.Index {
+						default:
+							goto bad
+
+						case REG_DS:
+							ctxt.Andptr[0] = 0xc5
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_SS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb2
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_ES:
+							ctxt.Andptr[0] = 0xc4
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_FS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb4
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_GS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb5
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+
+						asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+					case 6: /* double shift */
+						switch p.From.Type {
+						default:
+							goto bad
+
+						case obj.TYPE_CONST:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = t[4]
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &p.To, reg[p.From.Index])
+							ctxt.Andptr[0] = byte(p.From.Offset)
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case obj.TYPE_REG:
+							switch p.From.Reg {
+							default:
+								goto bad
+
+							case REG_CL,
+								REG_CX:
+								ctxt.Andptr[0] = 0x0f
+								ctxt.Andptr = ctxt.Andptr[1:]
+								ctxt.Andptr[0] = t[5]
+								ctxt.Andptr = ctxt.Andptr[1:]
+								asmand(ctxt, p, &p.To, reg[p.From.Index])
+							}
+						}
+
+					case 7: /* imul rm,r */
+						if t[4] == Pq {
+							ctxt.Andptr[0] = Pe
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = Pm
+							ctxt.Andptr = ctxt.Andptr[1:]
+						} else {
+							ctxt.Andptr[0] = t[4]
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+						ctxt.Andptr[0] = t[5]
+						ctxt.Andptr = ctxt.Andptr[1:]
+						asmand(ctxt, p, &p.From, reg[p.To.Reg])
+
+						// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
+					// where you load the TLS base register into a register and then index off that
+					// register to access the actual TLS variables. Systems that allow direct TLS access
+					// are handled in prefixof above and should not be listed here.
+					case 8: /* mov tls, r */
+						switch ctxt.Headtype {
+						default:
+							log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
+
+							// ELF TLS base is 0(GS).
+						case obj.Hlinux,
+							obj.Hnacl:
+							pp.From = p.From
+
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Reg = REG_GS
+							pp.From.Offset = 0
+							pp.From.Index = REG_NONE
+							pp.From.Scale = 0
+							ctxt.Andptr[0] = 0x65
+							ctxt.Andptr = ctxt.Andptr[1:] // GS
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, reg[p.To.Reg])
+
+						case obj.Hplan9:
+							if ctxt.Plan9privates == nil {
+								ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
+							}
+							pp.From = obj.Addr{}
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Name = obj.NAME_EXTERN
+							pp.From.Sym = ctxt.Plan9privates
+							pp.From.Offset = 0
+							pp.From.Index = REG_NONE
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, reg[p.To.Reg])
+
+							// Windows TLS base is always 0x14(FS).
+						case obj.Hwindows:
+							pp.From = p.From
+
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Reg = REG_FS
+							pp.From.Offset = 0x14
+							pp.From.Index = REG_NONE
+							pp.From.Scale = 0
+							ctxt.Andptr[0] = 0x64
+							ctxt.Andptr = ctxt.Andptr[1:] // FS
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, reg[p.To.Reg])
+						}
+					}
+					return
 				}
 			}
 		}
@@ -3213,7 +3358,7 @@
 
 	z = int(p.From.Reg)
 	if p.From.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
-		breg = byteswapreg(ctxt, &p.To)
+		breg := byteswapreg(ctxt, &p.To)
 		if breg != REG_AX {
 			ctxt.Andptr[0] = 0x87
 			ctxt.Andptr = ctxt.Andptr[1:] /* xchg lhs,bx */
@@ -3237,7 +3382,7 @@
 
 	z = int(p.To.Reg)
 	if p.To.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
-		breg = byteswapreg(ctxt, &p.From)
+		breg := byteswapreg(ctxt, &p.From)
 		if breg != REG_AX {
 			ctxt.Andptr[0] = 0x87
 			ctxt.Andptr = ctxt.Andptr[1:] /* xchg rhs,bx */
@@ -3261,182 +3406,6 @@
 
 	ctxt.Diag("doasm: notfound t2=%d from=%d to=%d %v", yt.zcase, p.Ft, p.Tt, p)
 	return
-
-mfound:
-	switch t[3] {
-	default:
-		ctxt.Diag("asmins: unknown mov %d %v", t[3], p)
-
-	case 0: /* lit */
-		for z = 4; t[z] != E; z++ {
-			ctxt.Andptr[0] = t[z]
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-	case 1: /* r,m */
-		ctxt.Andptr[0] = t[4]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmand(ctxt, p, &p.To, int(t[5]))
-
-	case 2: /* m,r */
-		ctxt.Andptr[0] = t[4]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmand(ctxt, p, &p.From, int(t[5]))
-
-	case 3: /* r,m - 2op */
-		ctxt.Andptr[0] = t[4]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = t[5]
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, int(t[6]))
-
-	case 4: /* m,r - 2op */
-		ctxt.Andptr[0] = t[4]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = t[5]
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, int(t[6]))
-
-	case 5: /* load full pointer, trash heap */
-		if t[4] != 0 {
-			ctxt.Andptr[0] = t[4]
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		switch p.To.Index {
-		default:
-			goto bad
-
-		case REG_DS:
-			ctxt.Andptr[0] = 0xc5
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_SS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb2
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_ES:
-			ctxt.Andptr[0] = 0xc4
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_FS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb4
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_GS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb5
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-	case 6: /* double shift */
-		switch p.From.Type {
-		default:
-			goto bad
-
-		case obj.TYPE_CONST:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = t[4]
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &p.To, reg[p.From.Index])
-			ctxt.Andptr[0] = byte(p.From.Offset)
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case obj.TYPE_REG:
-			switch p.From.Reg {
-			default:
-				goto bad
-
-			case REG_CL,
-				REG_CX:
-				ctxt.Andptr[0] = 0x0f
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = t[5]
-				ctxt.Andptr = ctxt.Andptr[1:]
-				asmand(ctxt, p, &p.To, reg[p.From.Index])
-			}
-		}
-
-	case 7: /* imul rm,r */
-		if t[4] == Pq {
-			ctxt.Andptr[0] = Pe
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = Pm
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			ctxt.Andptr[0] = t[4]
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		ctxt.Andptr[0] = t[5]
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, reg[p.To.Reg])
-
-		// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
-	// where you load the TLS base register into a register and then index off that
-	// register to access the actual TLS variables. Systems that allow direct TLS access
-	// are handled in prefixof above and should not be listed here.
-	case 8: /* mov tls, r */
-		switch ctxt.Headtype {
-		default:
-			log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
-
-			// ELF TLS base is 0(GS).
-		case obj.Hlinux,
-			obj.Hnacl:
-			pp.From = p.From
-
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Reg = REG_GS
-			pp.From.Offset = 0
-			pp.From.Index = REG_NONE
-			pp.From.Scale = 0
-			ctxt.Andptr[0] = 0x65
-			ctxt.Andptr = ctxt.Andptr[1:] // GS
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, reg[p.To.Reg])
-
-		case obj.Hplan9:
-			if ctxt.Plan9privates == nil {
-				ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
-			}
-			pp.From = obj.Addr{}
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Name = obj.NAME_EXTERN
-			pp.From.Sym = ctxt.Plan9privates
-			pp.From.Offset = 0
-			pp.From.Index = REG_NONE
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, reg[p.To.Reg])
-
-			// Windows TLS base is always 0x14(FS).
-		case obj.Hwindows:
-			pp.From = p.From
-
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Reg = REG_FS
-			pp.From.Offset = 0x14
-			pp.From.Index = REG_NONE
-			pp.From.Scale = 0
-			ctxt.Andptr[0] = 0x64
-			ctxt.Andptr = ctxt.Andptr[1:] // FS
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, reg[p.To.Reg])
-		}
-	}
 }
 
 var naclret = []uint8{
@@ -3450,12 +3419,10 @@
 }
 
 func asmins(ctxt *obj.Link, p *obj.Prog) {
-	var r *obj.Reloc
-
 	ctxt.Andptr = ctxt.And[:]
 
 	if p.As == obj.AUSEFIELD {
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		r.Off = 0
 		r.Sym = p.From.Sym
 		r.Type = obj.R_USEFIELD
diff --git a/src/cmd/internal/obj/i386/list8.go b/src/cmd/internal/obj/i386/list8.go
index 3aef35b..f843006 100644
--- a/src/cmd/internal/obj/i386/list8.go
+++ b/src/cmd/internal/obj/i386/list8.go
@@ -43,7 +43,6 @@
 
 func Pconv(p *obj.Prog) string {
 	var str string
-	var fp string
 
 	switch p.As {
 	case obj.ADATA:
@@ -72,6 +71,7 @@
 		}
 	}
 
+	var fp string
 	fp += str
 	return fp
 }
diff --git a/src/cmd/internal/obj/i386/obj8.go b/src/cmd/internal/obj/i386/obj8.go
index 88adba0..63cb7f2 100644
--- a/src/cmd/internal/obj/i386/obj8.go
+++ b/src/cmd/internal/obj/i386/obj8.go
@@ -51,10 +51,6 @@
 }
 
 func progedit(ctxt *obj.Link, p *obj.Prog) {
-	var literal string
-	var s *obj.LSym
-	var q *obj.Prog
-
 	// See obj6.c for discussion of TLS.
 	if canuselocaltls(ctxt) {
 		// Reduce TLS initial exec model to TLS local exec model.
@@ -92,7 +88,7 @@
 		//	MOVL off(BX)(TLS*1), BX
 		// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
 		if p.As == AMOVL && p.From.Type == obj.TYPE_MEM && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_DI {
-			q = obj.Appendp(ctxt, p)
+			q := obj.Appendp(ctxt, p)
 			q.As = p.As
 			q.From.Type = obj.TYPE_MEM
 			q.From.Reg = p.To.Reg
@@ -159,12 +155,10 @@
 		ACOMISS,
 		AUCOMISS:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i32 uint32
-			var f32 float32
-			f32 = float32(p.From.U.Dval)
-			i32 = math.Float32bits(f32)
-			literal = fmt.Sprintf("$f32.%08x", i32)
-			s = obj.Linklookup(ctxt, literal, 0)
+			f32 := float32(p.From.U.Dval)
+			i32 := math.Float32bits(f32)
+			literal := fmt.Sprintf("$f32.%08x", i32)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint32(ctxt, s, i32)
@@ -208,10 +202,9 @@
 		ACOMISD,
 		AUCOMISD:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i64 uint64
-			i64 = math.Float64bits(p.From.U.Dval)
-			literal = fmt.Sprintf("$f64.%016x", i64)
-			s = obj.Linklookup(ctxt, literal, 0)
+			i64 := math.Float64bits(p.From.U.Dval)
+			literal := fmt.Sprintf("$f64.%016x", i64)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint64(ctxt, s, i64)
@@ -227,14 +220,6 @@
 }
 
 func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var p1 *obj.Prog
-	var p2 *obj.Prog
-	var autoffset int32
-	var deltasp int32
-	var a int
-
 	if ctxt.Symmorestack[0] == nil {
 		ctxt.Symmorestack[0] = obj.Linklookup(ctxt, "runtime.morestack", 0)
 		ctxt.Symmorestack[1] = obj.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
@@ -250,8 +235,8 @@
 		return
 	}
 
-	p = cursym.Text
-	autoffset = int32(p.To.Offset)
+	p := cursym.Text
+	autoffset := int32(p.To.Offset)
 	if autoffset < 0 {
 		autoffset = 0
 	}
@@ -259,7 +244,7 @@
 	cursym.Locals = autoffset
 	cursym.Args = p.To.U.Argsize
 
-	q = nil
+	q := (*obj.Prog)(nil)
 
 	if p.From3.Offset&obj.NOSPLIT == 0 || (p.From3.Offset&obj.WRAPPER != 0) {
 		p = obj.Appendp(ctxt, p)
@@ -292,7 +277,7 @@
 	if q != nil {
 		q.Pcond = p
 	}
-	deltasp = autoffset
+	deltasp := autoffset
 
 	if cursym.Text.From3.Offset&obj.WRAPPER != 0 {
 		// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
@@ -329,7 +314,7 @@
 		p = obj.Appendp(ctxt, p)
 		p.As = AJEQ
 		p.To.Type = obj.TYPE_BRANCH
-		p1 = p
+		p1 := p
 
 		p = obj.Appendp(ctxt, p)
 		p.As = ALEAL
@@ -350,7 +335,7 @@
 		p = obj.Appendp(ctxt, p)
 		p.As = AJNE
 		p.To.Type = obj.TYPE_BRANCH
-		p2 = p
+		p2 := p
 
 		p = obj.Appendp(ctxt, p)
 		p.As = AMOVL
@@ -400,6 +385,7 @@
 		p.As = ASTOSL
 	}
 
+	var a int
 	for ; p != nil; p = p.Link {
 		a = int(p.From.Name)
 		if a == obj.NAME_AUTO {
@@ -479,8 +465,6 @@
 // prologue (caller must call appendp first) and in the epilogue.
 // Returns last new instruction.
 func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog {
-	var next *obj.Prog
-
 	p.As = AMOVL
 	p.From.Type = obj.TYPE_MEM
 	p.From.Reg = REG_TLS
@@ -488,7 +472,7 @@
 	p.To.Type = obj.TYPE_REG
 	p.To.Reg = REG_CX
 
-	next = p.Link
+	next := p.Link
 	progedit(ctxt, p)
 	for p.Link != next {
 		p = p.Link
@@ -508,9 +492,6 @@
 // On return, *jmpok is the instruction that should jump
 // to the stack frame allocation if no split is needed.
 func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok **obj.Prog) *obj.Prog {
-	var q *obj.Prog
-	var q1 *obj.Prog
-
 	if ctxt.Debugstack != 0 {
 		// 8l -K means check not only for stack
 		// overflow but stack underflow.
@@ -530,7 +511,7 @@
 		p.As = AJCC
 		p.To.Type = obj.TYPE_BRANCH
 		p.To.Offset = 4
-		q1 = p
+		q1 := p
 
 		p = obj.Appendp(ctxt, p)
 		p.As = AINT
@@ -542,7 +523,7 @@
 		q1.Pcond = p
 	}
 
-	q1 = nil
+	q1 := (*obj.Prog)(nil)
 
 	if framesize <= obj.StackSmall {
 		// small stack: SP <= stackguard
@@ -651,7 +632,7 @@
 	p.As = AJHI
 	p.To.Type = obj.TYPE_BRANCH
 	p.To.Offset = 4
-	q = p
+	q := p
 
 	p = obj.Appendp(ctxt, p)
 	p.As = obj.ACALL
@@ -679,13 +660,10 @@
 }
 
 func follow(ctxt *obj.Link, s *obj.LSym) {
-	var firstp *obj.Prog
-	var lastp *obj.Prog
-
 	ctxt.Cursym = s
 
-	firstp = ctxt.NewProg()
-	lastp = firstp
+	firstp := ctxt.NewProg()
+	lastp := firstp
 	xfol(ctxt, s.Text, &lastp)
 	lastp.Link = nil
 	s.Text = firstp.Link
diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index e665229..16d1626 100644
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -407,18 +407,7 @@
 var xcmp [C_NCLASS][C_NCLASS]uint8
 
 func span9(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var o *Optab
-	var m int
-	var bflag int
-	var c int64
-	var otxt int64
-	var out [6]uint32
-	var i int32
-	var bp []byte
-
-	p = cursym.Text
+	p := cursym.Text
 	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
 		return
 	}
@@ -429,9 +418,11 @@
 		buildop(ctxt)
 	}
 
-	c = 0
+	c := int64(0)
 	p.Pc = c
 
+	var m int
+	var o *Optab
 	for p = p.Link; p != nil; p = p.Link {
 		ctxt.Curp = p
 		p.Pc = c
@@ -455,8 +446,10 @@
 	 * generate extra passes putting branches
 	 * around jmps to fix. this is rare.
 	 */
-	bflag = 1
+	bflag := 1
 
+	var otxt int64
+	var q *obj.Prog
 	for bflag != 0 {
 		if ctxt.Debugvlog != 0 {
 			fmt.Fprintf(ctxt.Bso, "%5.2f span1\n", obj.Cputime())
@@ -517,8 +510,10 @@
 
 	obj.Symgrow(ctxt, cursym, cursym.Size)
 
-	bp = cursym.P
-	for p = cursym.Text.Link; p != nil; p = p.Link {
+	bp := cursym.P
+	var i int32
+	var out [6]uint32
+	for p := cursym.Text.Link; p != nil; p = p.Link {
 		ctxt.Pc = p.Pc
 		ctxt.Curp = p
 		o = oplook(ctxt, p)
@@ -542,8 +537,6 @@
 }
 
 func aclass(ctxt *obj.Link, a *obj.Addr) int {
-	var s *obj.LSym
-
 	switch a.Type {
 	case obj.TYPE_NONE:
 		return C_NONE
@@ -646,7 +639,7 @@
 
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC:
-			s = a.Sym
+			s := a.Sym
 			if s == nil {
 				break
 			}
@@ -720,18 +713,7 @@
 }
 
 func oplook(ctxt *obj.Link, p *obj.Prog) *Optab {
-	var a1 int
-	var a2 int
-	var a3 int
-	var a4 int
-	var r int
-	var c1 []byte
-	var c3 []byte
-	var c4 []byte
-	var o []Optab
-	var e []Optab
-
-	a1 = int(p.Optab)
+	a1 := int(p.Optab)
 	if a1 != 0 {
 		return &optab[a1-1:][0]
 	}
@@ -742,36 +724,36 @@
 	}
 
 	a1--
-	a3 = int(p.From3.Class)
+	a3 := int(p.From3.Class)
 	if a3 == 0 {
 		a3 = aclass(ctxt, &p.From3) + 1
 		p.From3.Class = int8(a3)
 	}
 
 	a3--
-	a4 = int(p.To.Class)
+	a4 := int(p.To.Class)
 	if a4 == 0 {
 		a4 = aclass(ctxt, &p.To) + 1
 		p.To.Class = int8(a4)
 	}
 
 	a4--
-	a2 = C_NONE
+	a2 := C_NONE
 	if p.Reg != 0 {
 		a2 = C_REG
 	}
 
 	//print("oplook %P %d %d %d %d\n", p, a1, a2, a3, a4);
-	r = int(p.As)
+	r := int(p.As)
 
-	o = oprange[r].start
+	o := oprange[r].start
 	if o == nil {
 		o = oprange[r].stop /* just generate an error */
 	}
-	e = oprange[r].stop
-	c1 = xcmp[a1][:]
-	c3 = xcmp[a3][:]
-	c4 = xcmp[a4][:]
+	e := oprange[r].stop
+	c1 := xcmp[a1][:]
+	c3 := xcmp[a3][:]
+	c4 := xcmp[a4][:]
 	for ; -cap(o) < -cap(e); o = o[1:] {
 		if int(o[0].a2) == a2 {
 			if c1[o[0].a1] != 0 {
@@ -881,13 +863,9 @@
 }
 
 func (x ocmp) Less(i, j int) bool {
-	var p1 *Optab
-	var p2 *Optab
-	var n int
-
-	p1 = &x[i]
-	p2 = &x[j]
-	n = int(p1.as) - int(p2.as)
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
 	if n != 0 {
 		return n < 0
 	}
@@ -911,11 +889,9 @@
 }
 
 func buildop(ctxt *obj.Link) {
-	var i int
 	var n int
-	var r int
 
-	for i = 0; i < C_NCLASS; i++ {
+	for i := 0; i < C_NCLASS; i++ {
 		for n = 0; n < C_NCLASS; n++ {
 			if cmp(n, i) {
 				xcmp[i][n] = 1
@@ -925,7 +901,8 @@
 	for n = 0; optab[n].as != obj.AXXX; n++ {
 	}
 	sort.Sort(ocmp(optab[:n]))
-	for i = 0; i < n; i++ {
+	var r int
+	for i := 0; i < n; i++ {
 		r = int(optab[i].as)
 		oprange[r].start = optab[i:]
 		for int(optab[i].as) == r {
@@ -1393,9 +1370,7 @@
 
 // add R_ADDRPOWER relocation to symbol s for the two instructions o1 and o2.
 func addaddrreloc(ctxt *obj.Link, s *obj.LSym, o1 *uint32, o2 *uint32) {
-	var rel *obj.Reloc
-
-	rel = obj.Addrel(ctxt.Cursym)
+	rel := obj.Addrel(ctxt.Cursym)
 	rel.Off = int32(ctxt.Pc)
 	rel.Siz = 8
 	rel.Sym = s
@@ -1407,13 +1382,11 @@
  * 32-bit masks
  */
 func getmask(m []byte, v uint32) bool {
-	var i int
-
 	m[1] = 0
 	m[0] = m[1]
 	if v != ^uint32(0) && v&(1<<31) != 0 && v&1 != 0 { /* MB > ME */
 		if getmask(m, ^v) {
-			i = int(m[0])
+			i := int(m[0])
 			m[0] = m[1] + 1
 			m[1] = byte(i - 1)
 			return true
@@ -1422,7 +1395,7 @@
 		return false
 	}
 
-	for i = 0; i < 32; i++ {
+	for i := 0; i < 32; i++ {
 		if v&(1<<uint(31-i)) != 0 {
 			m[0] = byte(i)
 			for {
@@ -1455,11 +1428,9 @@
  * 64-bit masks (rldic etc)
  */
 func getmask64(m []byte, v uint64) bool {
-	var i int
-
 	m[1] = 0
 	m[0] = m[1]
-	for i = 0; i < 64; i++ {
+	for i := 0; i < 64; i++ {
 		if v&(uint64(1)<<uint(63-i)) != 0 {
 			m[0] = byte(i)
 			for {
@@ -1489,9 +1460,7 @@
 }
 
 func loadu32(r int, d int64) uint32 {
-	var v int32
-
-	v = int32(d >> 16)
+	v := int32(d >> 16)
 	if isuint32(uint64(d)) {
 		return LOP_IRR(OP_ORIS, uint32(r), REGZERO, uint32(v))
 	}
@@ -1506,24 +1475,11 @@
 }
 
 func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
-	var o1 uint32
-	var o2 uint32
-	var o3 uint32
-	var o4 uint32
-	var o5 uint32
-	var v int32
-	var t int32
-	var d int64
-	var r int
-	var a int
-	var mask [2]uint8
-	var rel *obj.Reloc
-
-	o1 = 0
-	o2 = 0
-	o3 = 0
-	o4 = 0
-	o5 = 0
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+	o5 := uint32(0)
 
 	//print("%P => case %d\n", p, o->type);
 	switch o.type_ {
@@ -1536,7 +1492,7 @@
 
 	case 1: /* mov r1,r2 ==> OR Rs,Rs,Ra */
 		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
-			v = regoff(ctxt, &p.From)
+			v := regoff(ctxt, &p.From)
 			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
 				//nerrors--;
 				ctxt.Diag("literal operation on R0\n%v", p)
@@ -1549,7 +1505,7 @@
 		o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
 
 	case 2: /* int/cr/fp op Rb,[Ra],Rd */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -1557,17 +1513,17 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
 
 	case 3: /* mov $soreg/addcon/ucon, r ==> addis/addi $i,reg',r */
-		d = vregoff(ctxt, &p.From)
+		d := vregoff(ctxt, &p.From)
 
-		v = int32(d)
-		r = int(p.From.Reg)
+		v := int32(d)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
 		if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 && (r != 0 || v != 0) {
 			ctxt.Diag("literal operation on R0\n%v", p)
 		}
-		a = OP_ADDI
+		a := OP_ADDI
 		if o.a1 == C_UCON {
 			if d&0xffff != 0 {
 				log.Fatalf("invalid handling of %v", p)
@@ -1588,9 +1544,9 @@
 		o1 = AOP_IRR(uint32(a), uint32(p.To.Reg), uint32(r), uint32(v))
 
 	case 4: /* add/mul $scon,[r1],r2 */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1606,7 +1562,7 @@
 		o1 = uint32(oprrr(ctxt, int(p.As)))
 
 	case 6: /* logical op Rb,[Rs,]Ra; no literal */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -1614,12 +1570,12 @@
 		o1 = LOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
 
 	case 7: /* mov r, soreg ==> stw o(r) */
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 
 		if r == 0 {
 			r = int(o.param)
 		}
-		v = regoff(ctxt, &p.To)
+		v := regoff(ctxt, &p.To)
 		if p.To.Type == obj.TYPE_MEM && p.Reg != 0 {
 			if v != 0 {
 				ctxt.Diag("illegal indexed instruction\n%v", p)
@@ -1633,12 +1589,12 @@
 		}
 
 	case 8: /* mov soreg, r ==> lbz/lhz/lwz o(r) */
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 
 		if r == 0 {
 			r = int(o.param)
 		}
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 		if p.From.Type == obj.TYPE_MEM && p.Reg != 0 {
 			if v != 0 {
 				ctxt.Diag("illegal indexed instruction\n%v", p)
@@ -1652,12 +1608,12 @@
 		}
 
 	case 9: /* movb soreg, r ==> lbz o(r),r2; extsb r2,r2 */
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 
 		if r == 0 {
 			r = int(o.param)
 		}
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 		if p.From.Type == obj.TYPE_MEM && p.Reg != 0 {
 			if v != 0 {
 				ctxt.Diag("illegal indexed instruction\n%v", p)
@@ -1669,7 +1625,7 @@
 		o2 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
 
 	case 10: /* sub Ra,[Rb],Rd => subf Rd,Ra,Rb */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -1677,7 +1633,7 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(p.From.Reg), uint32(r))
 
 	case 11: /* br/bl lbra */
-		v = 0
+		v := int32(0)
 
 		if p.Pcond != nil {
 			v = int32(p.Pcond.Pc - p.Pc)
@@ -1693,7 +1649,7 @@
 
 		o1 = OP_BR(uint32(opirr(ctxt, int(p.As))), uint32(v), 0)
 		if p.To.Sym != nil {
-			rel = obj.Addrel(ctxt.Cursym)
+			rel := obj.Addrel(ctxt.Cursym)
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 4
 			rel.Sym = p.To.Sym
@@ -1709,7 +1665,7 @@
 
 	case 12: /* movb r,r (extsb); movw r,r (extsw) */
 		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
-			v = regoff(ctxt, &p.From)
+			v := regoff(ctxt, &p.From)
 			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
 				ctxt.Diag("literal operation on R0\n%v", p)
 			}
@@ -1738,13 +1694,15 @@
 		}
 
 	case 14: /* rldc[lr] Rb,Rs,$mask,Ra -- left, right give different masks */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
-		d = vregoff(ctxt, &p.From3)
+		d := vregoff(ctxt, &p.From3)
+		var mask [2]uint8
 		maskgen64(ctxt, p, mask[:], uint64(d))
+		var a int
 		switch p.As {
 		case ARLDCL,
 			ARLDCLCC:
@@ -1773,16 +1731,16 @@
 
 	case 17, /* bc bo,bi,lbra (same for now) */
 		16: /* bc bo,bi,sbra */
-		a = 0
+		a := 0
 
 		if p.From.Type == obj.TYPE_CONST {
 			a = int(regoff(ctxt, &p.From))
 		}
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = 0
 		}
-		v = 0
+		v := int32(0)
 		if p.Pcond != nil {
 			v = int32(p.Pcond.Pc - p.Pc)
 		}
@@ -1797,12 +1755,13 @@
 		o1 = OP_BC(uint32(opirr(ctxt, int(p.As))), uint32(a), uint32(r), uint32(v), 0)
 
 	case 15: /* br/bl (r) => mov r,lr; br/bl (lr) */
+		var v int32
 		if p.As == ABC || p.As == ABCL {
 			v = regoff(ctxt, &p.To) & 31
 		} else {
 			v = 20 /* unconditional */
 		}
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = 0
 		}
@@ -1814,12 +1773,13 @@
 		o2 = OP_BCR(o2, uint32(v), uint32(r))
 
 	case 18: /* br/bl (lr/ctr); bc/bcl bo,bi,(lr/ctr) */
+		var v int32
 		if p.As == ABC || p.As == ABCL {
 			v = regoff(ctxt, &p.From) & 31
 		} else {
 			v = 20 /* unconditional */
 		}
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = 0
 		}
@@ -1841,7 +1801,7 @@
 		o1 = OP_BCR(o1, uint32(v), uint32(r))
 
 	case 19: /* mov $lcon,r ==> cau+or */
-		d = vregoff(ctxt, &p.From)
+		d := vregoff(ctxt, &p.From)
 
 		if p.From.Sym == nil {
 			o1 = loadu32(int(p.To.Reg), d)
@@ -1855,9 +1815,9 @@
 	//if(dlm) reloc(&p->from, p->pc, 0);
 
 	case 20: /* add $ucon,,r */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1870,10 +1830,10 @@
 		if p.To.Reg == REGTMP || p.Reg == REGTMP {
 			ctxt.Diag("cant synthesize large constant\n%v", p)
 		}
-		d = vregoff(ctxt, &p.From)
+		d := vregoff(ctxt, &p.From)
 		o1 = loadu32(REGTMP, d)
 		o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1888,10 +1848,10 @@
 		if p.To.Reg == REGTMP || p.Reg == REGTMP {
 			ctxt.Diag("cant synthesize large constant\n%v", p)
 		}
-		d = vregoff(ctxt, &p.From)
+		d := vregoff(ctxt, &p.From)
 		o1 = loadu32(REGTMP, d)
 		o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -1905,17 +1865,18 @@
 		/*24*/
 	case 25:
 		/* sld[.] $sh,rS,rA -> rldicr[.] $sh,rS,mask(0,63-sh),rA; srd[.] -> rldicl */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
 		if v < 0 {
 			v = 0
 		} else if v > 63 {
 			v = 63
 		}
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
+		var a int
 		switch p.As {
 		case ASLD,
 			ASLDCC:
@@ -1950,8 +1911,8 @@
 		if p.To.Reg == REGTMP {
 			ctxt.Diag("can't synthesize large constant\n%v", p)
 		}
-		v = regoff(ctxt, &p.From)
-		r = int(p.From.Reg)
+		v := regoff(ctxt, &p.From)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -1959,16 +1920,16 @@
 		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
 
 	case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
-		v = regoff(ctxt, &p.From3)
+		v := regoff(ctxt, &p.From3)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		o1 = AOP_IRR(uint32(opirr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), uint32(v))
 
 	case 28: /* subc r1,$lcon,r2 ==> cau+or+subfc */
 		if p.To.Reg == REGTMP || p.From.Reg == REGTMP {
 			ctxt.Diag("can't synthesize large constant\n%v", p)
 		}
-		v = regoff(ctxt, &p.From3)
+		v := regoff(ctxt, &p.From3)
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(v)>>16)
 		o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(v))
 		o3 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(p.From.Reg), REGTMP)
@@ -1979,10 +1940,12 @@
 	//if(dlm) reloc(&p->from3, p->pc, 0);
 
 	case 29: /* rldic[lr]? $sh,s,$mask,a -- left, right, plain give different masks */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		d = vregoff(ctxt, &p.From3)
+		d := vregoff(ctxt, &p.From3)
+		var mask [2]uint8
 		maskgen64(ctxt, p, mask[:], uint64(d))
+		var a int
 		switch p.As {
 		case ARLDC,
 			ARLDCCC:
@@ -2020,9 +1983,10 @@
 		}
 
 	case 30: /* rldimi $sh,s,$mask,a */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		d = vregoff(ctxt, &p.From3)
+		d := vregoff(ctxt, &p.From3)
+		var mask [2]uint8
 		maskgen64(ctxt, p, mask[:], uint64(d))
 		if int32(mask[1]) != (63 - v) {
 			ctxt.Diag("invalid mask for shift: %x (shift %d)\n%v", uint64(d), v, p)
@@ -2037,7 +2001,7 @@
 		}
 
 	case 31: /* dword */
-		d = vregoff(ctxt, &p.From)
+		d := vregoff(ctxt, &p.From)
 
 		if ctxt.Arch.ByteOrder == binary.BigEndian {
 			o1 = uint32(d >> 32)
@@ -2048,7 +2012,7 @@
 		}
 
 		if p.From.Sym != nil {
-			rel = obj.Addrel(ctxt.Cursym)
+			rel := obj.Addrel(ctxt.Cursym)
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 8
 			rel.Sym = p.From.Sym
@@ -2059,7 +2023,7 @@
 		}
 
 	case 32: /* fmul frc,fra,frd */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -2067,7 +2031,7 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), 0) | (uint32(p.From.Reg)&31)<<6
 
 	case 33: /* fabs [frb,]frd; fmr. frb,frd */
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 
 		if oclass(&p.From) == C_NONE {
 			r = int(p.To.Reg)
@@ -2078,9 +2042,9 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg)) | (uint32(p.From3.Reg)&31)<<6
 
 	case 35: /* mov r,lext/lauto/loreg ==> cau $(v>>16),sb,r'; store o(r') */
-		v = regoff(ctxt, &p.To)
+		v := regoff(ctxt, &p.To)
 
-		r = int(p.To.Reg)
+		r := int(p.To.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2088,9 +2052,9 @@
 		o2 = AOP_IRR(uint32(opstore(ctxt, int(p.As))), uint32(p.From.Reg), REGTMP, uint32(v))
 
 	case 36: /* mov bz/h/hz lext/lauto/lreg,r ==> lbz/lha/lhz etc */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2098,9 +2062,9 @@
 		o2 = AOP_IRR(uint32(opload(ctxt, int(p.As))), uint32(p.To.Reg), REGTMP, uint32(v))
 
 	case 37: /* movb lext/lauto/lreg,r ==> lbz o(reg),r; extsb r */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 		if r == 0 {
 			r = int(o.param)
 		}
@@ -2118,7 +2082,7 @@
 		o1 = AOP_RRR(uint32(opirr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(p.From.Reg), 0) | (uint32(regoff(ctxt, &p.From3))&0x7F)<<11
 
 	case 43: /* unary indexed source: dcbf (b); dcbf (a+b) */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = 0
@@ -2126,7 +2090,7 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), 0, uint32(r), uint32(p.From.Reg))
 
 	case 44: /* indexed store */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = 0
@@ -2134,7 +2098,7 @@
 		o1 = AOP_RRR(uint32(opstorex(ctxt, int(p.As))), uint32(p.From.Reg), uint32(r), uint32(p.To.Reg))
 
 	case 45: /* indexed load */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = 0
@@ -2145,7 +2109,7 @@
 		o1 = uint32(oprrr(ctxt, int(p.As)))
 
 	case 47: /* op Ra, Rd; also op [Ra,] Rd */
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -2153,7 +2117,7 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), 0)
 
 	case 48: /* op Rs, Ra */
-		r = int(p.From.Reg)
+		r := int(p.From.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
@@ -2162,20 +2126,20 @@
 
 	case 49: /* op Rb; op $n, Rb */
 		if p.From.Type != obj.TYPE_REG { /* tlbie $L, rB */
-			v = regoff(ctxt, &p.From) & 1
+			v := regoff(ctxt, &p.From) & 1
 			o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), 0, 0, uint32(p.To.Reg)) | uint32(v)<<21
 		} else {
 			o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), 0, 0, uint32(p.From.Reg))
 		}
 
 	case 50: /* rem[u] r1[,r2],r3 */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
-		v = oprrr(ctxt, int(p.As))
-		t = v & (1<<10 | 1) /* OE|Rc */
+		v := oprrr(ctxt, int(p.As))
+		t := v & (1<<10 | 1) /* OE|Rc */
 		o1 = AOP_RRR(uint32(v)&^uint32(t), REGTMP, uint32(r), uint32(p.From.Reg))
 		o2 = AOP_RRR(OP_MULLW, REGTMP, REGTMP, uint32(p.From.Reg))
 		o3 = AOP_RRR(OP_SUBF|uint32(t), uint32(p.To.Reg), REGTMP, uint32(r))
@@ -2187,19 +2151,19 @@
 		}
 
 	case 51: /* remd[u] r1[,r2],r3 */
-		r = int(p.Reg)
+		r := int(p.Reg)
 
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
-		v = oprrr(ctxt, int(p.As))
-		t = v & (1<<10 | 1) /* OE|Rc */
+		v := oprrr(ctxt, int(p.As))
+		t := v & (1<<10 | 1) /* OE|Rc */
 		o1 = AOP_RRR(uint32(v)&^uint32(t), REGTMP, uint32(r), uint32(p.From.Reg))
 		o2 = AOP_RRR(OP_MULLD, REGTMP, REGTMP, uint32(p.From.Reg))
 		o3 = AOP_RRR(OP_SUBF|uint32(t), uint32(p.To.Reg), REGTMP, uint32(r))
 
 	case 52: /* mtfsbNx cr(n) */
-		v = regoff(ctxt, &p.From) & 31
+		v := regoff(ctxt, &p.From) & 31
 
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(v), 0, 0)
 
@@ -2221,9 +2185,9 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), 0, uint32(p.From.Reg))
 
 	case 56: /* sra $sh,[s,]a; srd $sh,[s,]a */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -2233,9 +2197,9 @@
 		}
 
 	case 57: /* slw $sh,[s,]a -> rlwinm ... */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
@@ -2252,6 +2216,7 @@
 		} else if v > 32 {
 			v = 32
 		}
+		var mask [2]uint8
 		if p.As == ASRW || p.As == ASRWCC { /* shift right */
 			mask[0] = uint8(v)
 			mask[1] = 31
@@ -2267,48 +2232,51 @@
 		}
 
 	case 58: /* logical $andcon,[s],a */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
 		o1 = LOP_IRR(uint32(opirr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), uint32(v))
 
 	case 59: /* or/and $ucon,,r */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
-		r = int(p.Reg)
+		r := int(p.Reg)
 		if r == 0 {
 			r = int(p.To.Reg)
 		}
 		o1 = LOP_IRR(uint32(opirr(ctxt, int(p.As)+ALAST)), uint32(p.To.Reg), uint32(r), uint32(v)>>16) /* oris, xoris, andis */
 
 	case 60: /* tw to,a,b */
-		r = int(regoff(ctxt, &p.From) & 31)
+		r := int(regoff(ctxt, &p.From) & 31)
 
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(r), uint32(p.Reg), uint32(p.To.Reg))
 
 	case 61: /* tw to,a,$simm */
-		r = int(regoff(ctxt, &p.From) & 31)
+		r := int(regoff(ctxt, &p.From) & 31)
 
-		v = regoff(ctxt, &p.To)
+		v := regoff(ctxt, &p.To)
 		o1 = AOP_IRR(uint32(opirr(ctxt, int(p.As))), uint32(r), uint32(p.Reg), uint32(v))
 
 	case 62: /* rlwmi $sh,s,$mask,a */
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 
+		var mask [2]uint8
 		maskgen(ctxt, p, mask[:], uint32(regoff(ctxt, &p.From3)))
 		o1 = AOP_RRR(uint32(opirr(ctxt, int(p.As))), uint32(p.Reg), uint32(p.To.Reg), uint32(v))
 		o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
 
 	case 63: /* rlwmi b,s,$mask,a */
+		var mask [2]uint8
 		maskgen(ctxt, p, mask[:], uint32(regoff(ctxt, &p.From3)))
 
 		o1 = AOP_RRR(uint32(opirr(ctxt, int(p.As))), uint32(p.Reg), uint32(p.To.Reg), uint32(p.From.Reg))
 		o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
 
 	case 64: /* mtfsf fr[, $m] {,fpcsr} */
+		var v int32
 		if p.From3.Type != obj.TYPE_NONE {
 			v = regoff(ctxt, &p.From3) & 255
 		} else {
@@ -2323,6 +2291,8 @@
 		o1 = OP_MTFSFI | (uint32(p.To.Reg)&15)<<23 | (uint32(regoff(ctxt, &p.From))&31)<<12
 
 	case 66: /* mov spr,r1; mov r1,spr, also dcr */
+		var r int
+		var v int32
 		if REG_R0 <= p.From.Reg && p.From.Reg <= REG_R31 {
 			r = int(p.From.Reg)
 			v = int32(p.To.Reg)
@@ -2351,13 +2321,14 @@
 
 	case 68: /* mfcr rD; mfocrf CRM,rD */
 		if p.From.Type == obj.TYPE_REG && REG_CR0 <= p.From.Reg && p.From.Reg <= REG_CR7 {
-			v = 1 << uint(7-(p.To.Reg&7))                                         /* CR(n) */
+			v := int32(1 << uint(7-(p.To.Reg&7)))                                 /* CR(n) */
 			o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) | 1<<20 | uint32(v)<<12 /* new form, mfocrf */
 		} else {
 			o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) /* old form, whole register */
 		}
 
 	case 69: /* mtcrf CRM,rS */
+		var v int32
 		if p.From3.Type != obj.TYPE_NONE {
 			if p.To.Reg != 0 {
 				ctxt.Diag("can't use both mask and CR(n)\n%v", p)
@@ -2374,6 +2345,7 @@
 		o1 = AOP_RRR(OP_MTCRF, uint32(p.From.Reg), 0, 0) | uint32(v)<<12
 
 	case 70: /* [f]cmp r,r,cr*/
+		var r int
 		if p.Reg == 0 {
 			r = 0
 		} else {
@@ -2382,6 +2354,7 @@
 		o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(r), uint32(p.From.Reg), uint32(p.To.Reg))
 
 	case 71: /* cmp[l] r,i,cr*/
+		var r int
 		if p.Reg == 0 {
 			r = 0
 		} else {
@@ -2420,7 +2393,7 @@
 
 		/* relocation operations */
 	case 74:
-		v = regoff(ctxt, &p.To)
+		v := regoff(ctxt, &p.To)
 
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(high16adjusted(v)))
 		o2 = AOP_IRR(uint32(opstore(ctxt, int(p.As))), uint32(p.From.Reg), REGTMP, uint32(v))
@@ -2429,7 +2402,7 @@
 	//if(dlm) reloc(&p->to, p->pc, 1);
 
 	case 75:
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(high16adjusted(v)))
 		o2 = AOP_IRR(uint32(opload(ctxt, int(p.As))), uint32(p.To.Reg), REGTMP, uint32(v))
 		addaddrreloc(ctxt, p.From.Sym, &o1, &o2)
@@ -2437,7 +2410,7 @@
 	//if(dlm) reloc(&p->from, p->pc, 1);
 
 	case 76:
-		v = regoff(ctxt, &p.From)
+		v := regoff(ctxt, &p.From)
 		o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(high16adjusted(v)))
 		o2 = AOP_IRR(uint32(opload(ctxt, int(p.As))), uint32(p.To.Reg), REGTMP, uint32(v))
 		addaddrreloc(ctxt, p.From.Sym, &o1, &o2)
diff --git a/src/cmd/internal/obj/ppc64/list9.go b/src/cmd/internal/obj/ppc64/list9.go
index 21a8642..6c62fad 100644
--- a/src/cmd/internal/obj/ppc64/list9.go
+++ b/src/cmd/internal/obj/ppc64/list9.go
@@ -54,14 +54,9 @@
 var bigP *obj.Prog
 
 func Pconv(p *obj.Prog) string {
-	var str string
-	var fp string
+	a := int(p.As)
 
-	var a int
-
-	a = int(p.As)
-
-	str = ""
+	str := ""
 	if a == obj.ADATA {
 		str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
 			p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
@@ -107,23 +102,23 @@
 		}
 
 		if p.Spadj != 0 {
+			var fp string
 			fp += fmt.Sprintf("%s # spadj=%d", str, p.Spadj)
 			return fp
 		}
 	}
 
+	var fp string
 	fp += str
 	return fp
 }
 
 func Aconv(a int) string {
-	var s string
-	var fp string
-
-	s = "???"
+	s := "???"
 	if a >= obj.AXXX && a < ALAST {
 		s = Anames[a]
 	}
+	var fp string
 	fp += s
 	return fp
 }
@@ -177,13 +172,11 @@
 }
 
 func DRconv(a int) string {
-	var s string
-	var fp string
-
-	s = "C_??"
+	s := "C_??"
 	if a >= C_NONE && a <= C_NCLASS {
 		s = cnames9[a]
 	}
+	var fp string
 	fp += s
 	return fp
 }
diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index a507449..f858bb3 100644
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -37,9 +37,6 @@
 )
 
 func progedit(ctxt *obj.Link, p *obj.Prog) {
-	var literal string
-	var s *obj.LSym
-
 	p.From.Class = 0
 	p.To.Class = 0
 
@@ -59,12 +56,10 @@
 	switch p.As {
 	case AFMOVS:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i32 uint32
-			var f32 float32
-			f32 = float32(p.From.U.Dval)
-			i32 = math.Float32bits(f32)
-			literal = fmt.Sprintf("$f32.%08x", i32)
-			s = obj.Linklookup(ctxt, literal, 0)
+			f32 := float32(p.From.U.Dval)
+			i32 := math.Float32bits(f32)
+			literal := fmt.Sprintf("$f32.%08x", i32)
+			s := obj.Linklookup(ctxt, literal, 0)
 			s.Size = 4
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = s
@@ -74,10 +69,9 @@
 
 	case AFMOVD:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i64 uint64
-			i64 = math.Float64bits(p.From.U.Dval)
-			literal = fmt.Sprintf("$f64.%016x", i64)
-			s = obj.Linklookup(ctxt, literal, 0)
+			i64 := math.Float64bits(p.From.U.Dval)
+			literal := fmt.Sprintf("$f64.%016x", i64)
+			s := obj.Linklookup(ctxt, literal, 0)
 			s.Size = 8
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = s
@@ -88,8 +82,8 @@
 		// Put >32-bit constants in memory and load them
 	case AMOVD:
 		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
-			literal = fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
-			s = obj.Linklookup(ctxt, literal, 0)
+			literal := fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
+			s := obj.Linklookup(ctxt, literal, 0)
 			s.Size = 8
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = s
@@ -121,17 +115,6 @@
 }
 
 func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var p1 *obj.Prog
-	var p2 *obj.Prog
-	var q1 *obj.Prog
-	var o int
-	var mov int
-	var aoffset int
-	var textstksiz int64
-	var autosize int32
-
 	if ctxt.Symmorestack[0] == nil {
 		ctxt.Symmorestack[0] = obj.Linklookup(ctxt, "runtime.morestack", 0)
 		ctxt.Symmorestack[1] = obj.Linklookup(ctxt, "runtime.morestack_noctxt", 0)
@@ -144,8 +127,8 @@
 		return
 	}
 
-	p = cursym.Text
-	textstksiz = p.To.Offset
+	p := cursym.Text
+	textstksiz := p.To.Offset
 
 	cursym.Args = p.To.U.Argsize
 	cursym.Locals = int32(textstksiz)
@@ -161,8 +144,9 @@
 	}
 	obj.Bflush(ctxt.Bso)
 
-	q = nil
-	for p = cursym.Text; p != nil; p = p.Link {
+	q := (*obj.Prog)(nil)
+	var q1 *obj.Prog
+	for p := cursym.Text; p != nil; p = p.Link {
 		switch p.As {
 		/* too hard, just leave alone */
 		case obj.ATEXT:
@@ -326,8 +310,13 @@
 		}
 	}
 
-	autosize = 0
-	for p = cursym.Text; p != nil; p = p.Link {
+	autosize := int32(0)
+	var aoffset int
+	var mov int
+	var o int
+	var p1 *obj.Prog
+	var p2 *obj.Prog
+	for p := cursym.Text; p != nil; p = p.Link {
 		o = int(p.As)
 		switch o {
 		case obj.ATEXT:
@@ -643,9 +632,6 @@
 	}
 */
 func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool) *obj.Prog {
-	var q *obj.Prog
-	var q1 *obj.Prog
-
 	// MOVD	g_stackguard(g), R3
 	p = obj.Appendp(ctxt, p)
 
@@ -659,7 +645,7 @@
 	p.To.Type = obj.TYPE_REG
 	p.To.Reg = REG_R3
 
-	q = nil
+	q := (*obj.Prog)(nil)
 	if framesize <= obj.StackSmall {
 		// small stack: SP < stackguard
 		//	CMP	stackguard, SP
@@ -750,7 +736,7 @@
 
 	// q1: BLT	done
 	p = obj.Appendp(ctxt, p)
-	q1 = p
+	q1 := p
 
 	p.As = ABLT
 	p.To.Type = obj.TYPE_BRANCH
@@ -795,13 +781,10 @@
 }
 
 func follow(ctxt *obj.Link, s *obj.LSym) {
-	var firstp *obj.Prog
-	var lastp *obj.Prog
-
 	ctxt.Cursym = s
 
-	firstp = ctxt.NewProg()
-	lastp = firstp
+	firstp := ctxt.NewProg()
+	lastp := firstp
 	xfol(ctxt, s.Text, &lastp)
 	lastp.Link = nil
 	s.Text = firstp.Link
diff --git a/src/cmd/internal/obj/sym.go b/src/cmd/internal/obj/sym.go
index d22a339..80ef0bf 100644
--- a/src/cmd/internal/obj/sym.go
+++ b/src/cmd/internal/obj/sym.go
@@ -123,8 +123,6 @@
 }
 
 func Linknew(arch *LinkArch) *Link {
-	var buf string
-
 	linksetexp()
 
 	ctxt := new(Link)
@@ -137,6 +135,7 @@
 		ctxt.Windows = 1
 	}
 
+	var buf string
 	buf, _ = os.Getwd()
 	if buf == "" {
 		buf = "/???"
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 5af037f..cb7d524 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -1492,16 +1492,6 @@
 }
 
 func span6(ctxt *obj.Link, s *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var c int32
-	var v int32
-	var loop int32
-	var bp []byte
-	var n int
-	var m int
-	var i int
-
 	ctxt.Cursym = s
 
 	if s.P != nil {
@@ -1512,7 +1502,8 @@
 		instinit()
 	}
 
-	for p = ctxt.Cursym.Text; p != nil; p = p.Link {
+	var v int32
+	for p := ctxt.Cursym.Text; p != nil; p = p.Link {
 		if p.To.Type == obj.TYPE_BRANCH {
 			if p.Pcond == nil {
 				p.Pcond = p
@@ -1536,7 +1527,8 @@
 		}
 	}
 
-	for p = s.Text; p != nil; p = p.Link {
+	var q *obj.Prog
+	for p := s.Text; p != nil; p = p.Link {
 		p.Back = 2 // use short branches first time through
 		q = p.Pcond
 		if q != nil && (q.Back&2 != 0) {
@@ -1562,7 +1554,13 @@
 		}
 	}
 
-	n = 0
+	n := 0
+	var bp []byte
+	var c int32
+	var i int
+	var loop int32
+	var m int
+	var p *obj.Prog
 	for {
 		loop = 0
 		for i = 0; i < len(s.R); i++ {
@@ -1686,6 +1684,7 @@
 
 	if false { /* debug['a'] > 1 */
 		fmt.Printf("span1 %s %d (%d tries)\n %.6x", s.Name, s.Size, n, 0)
+		var i int
 		for i = 0; i < len(s.P); i++ {
 			fmt.Printf(" %.2x", s.P[i])
 			if i%16 == 15 {
@@ -1697,10 +1696,8 @@
 			fmt.Printf("\n")
 		}
 
-		for i = 0; i < len(s.R); i++ {
-			var r *obj.Reloc
-
-			r = &s.R[i]
+		for i := 0; i < len(s.R); i++ {
+			r := &s.R[i]
 			fmt.Printf(" rel %#.4x/%d %s%+d\n", uint32(r.Off), r.Siz, r.Sym.Name, r.Add)
 		}
 	}
@@ -1708,9 +1705,8 @@
 
 func instinit() {
 	var c int
-	var i int
 
-	for i = 1; optab[i].as != 0; i++ {
+	for i := 1; optab[i].as != 0; i++ {
 		c = int(optab[i].as)
 		if opindex[c] != nil {
 			log.Fatalf("phase error in optab: %d (%v)", i, Aconv(c))
@@ -1718,7 +1714,7 @@
 		opindex[c] = &optab[i]
 	}
 
-	for i = 0; i < Ymax; i++ {
+	for i := 0; i < Ymax; i++ {
 		ycover[i*Ymax+i] = 1
 	}
 
@@ -1783,7 +1779,7 @@
 	ycover[Ym*Ymax+Yxm] = 1
 	ycover[Yxr*Ymax+Yxm] = 1
 
-	for i = 0; i < MAXREG; i++ {
+	for i := 0; i < MAXREG; i++ {
 		reg[i] = -1
 		if i >= REG_AL && i <= REG_R15B {
 			reg[i] = (i - REG_AL) & 7
@@ -1888,9 +1884,6 @@
 }
 
 func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
-	var v int64
-	var l int32
-
 	// TODO(rsc): This special case is for SHRQ $3, AX:DX,
 	// which encodes as SHRQ $32(DX*0), AX.
 	// Similarly SHRQ CX, AX:DX is really SHRQ CX(DX*0), AX.
@@ -1942,7 +1935,7 @@
 			ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
 		}
 
-		v = a.Offset
+		v := a.Offset
 		if v == 0 {
 			return Yi0
 		}
@@ -1952,7 +1945,7 @@
 		if v >= -128 && v <= 127 {
 			return Yi8
 		}
-		l = int32(v)
+		l := int32(v)
 		if int64(l) == v {
 			return Ys32 /* can sign extend */
 		}
@@ -2259,16 +2252,14 @@
 }
 
 func relput4(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
-	var v int64
 	var rel obj.Reloc
-	var r *obj.Reloc
 
-	v = vaddr(ctxt, p, a, &rel)
+	v := vaddr(ctxt, p, a, &rel)
 	if rel.Siz != 0 {
 		if rel.Siz != 4 {
 			ctxt.Diag("bad reloc")
 		}
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		*r = rel
 		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
 	}
@@ -2306,8 +2297,6 @@
 }
 */
 func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
-	var s *obj.LSym
-
 	if r != nil {
 		*r = obj.Reloc{}
 	}
@@ -2315,7 +2304,7 @@
 	switch a.Name {
 	case obj.NAME_STATIC,
 		obj.NAME_EXTERN:
-		s = a.Sym
+		s := a.Sym
 		if r == nil {
 			ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
 			log.Fatalf("reloc")
@@ -2358,12 +2347,11 @@
 }
 
 func asmandsz(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int) {
-	var v int32
 	var base int
 	var rel obj.Reloc
 
 	rex &= 0x40 | Rxr
-	v = int32(a.Offset)
+	v := int32(a.Offset)
 	rel.Siz = 0
 
 	switch a.Type {
@@ -2394,7 +2382,7 @@
 	}
 
 	if a.Index != REG_NONE && a.Index != REG_TLS {
-		base = int(a.Reg)
+		base := int(a.Reg)
 		switch a.Name {
 		case obj.NAME_EXTERN,
 			obj.NAME_STATIC:
@@ -2529,14 +2517,12 @@
 
 putrelv:
 	if rel.Siz != 0 {
-		var r *obj.Reloc
-
 		if rel.Siz != 4 {
 			ctxt.Diag("bad rel")
 			goto bad
 		}
 
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		*r = rel
 		r.Off = int32(ctxt.Curp.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
 	}
@@ -2770,34 +2756,16 @@
 }
 
 func doasm(ctxt *obj.Link, p *obj.Prog) {
-	var o *Optab
-	var q *obj.Prog
-	var pp obj.Prog
-	var t []byte
-	var mo []Movtab
-	var z int
-	var op int
-	var ft int
-	var tt int
-	var xo int
-	var l int
-	var pre int
-	var v int64
-	var rel obj.Reloc
-	var r *obj.Reloc
-	var a *obj.Addr
-	var yt ytab
-
 	ctxt.Curp = p // TODO
 
-	o = opindex[p.As]
+	o := opindex[p.As]
 
 	if o == nil {
 		ctxt.Diag("asmins: missing op %v", p)
 		return
 	}
 
-	pre = prefixof(ctxt, &p.From)
+	pre := prefixof(ctxt, &p.From)
 	if pre != 0 {
 		ctxt.Andptr[0] = byte(pre)
 		ctxt.Andptr = ctxt.Andptr[1:]
@@ -2815,593 +2783,776 @@
 		p.Tt = uint8(oclass(ctxt, p, &p.To))
 	}
 
-	ft = int(p.Ft) * Ymax
-	tt = int(p.Tt) * Ymax
+	ft := int(p.Ft) * Ymax
+	tt := int(p.Tt) * Ymax
 
-	xo = bool2int(o.op[0] == 0x0f)
-	z = 0
+	xo := bool2int(o.op[0] == 0x0f)
+	z := 0
+	var a *obj.Addr
+	var l int
+	var op int
+	var q *obj.Prog
+	var r *obj.Reloc
+	var rel obj.Reloc
+	var v int64
+	var yt ytab
 	for _, yt = range o.ytab {
 		if ycover[ft+int(yt.from)] != 0 && ycover[tt+int(yt.to)] != 0 {
-			goto found
-		}
-		z += int(yt.zoffset) + xo
-	}
-	goto domov
+			switch o.prefix {
+			case Pq: /* 16 bit escape and opcode escape */
+				ctxt.Andptr[0] = Pe
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-found:
-	switch o.prefix {
-	case Pq: /* 16 bit escape and opcode escape */
-		ctxt.Andptr[0] = Pe
-		ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
+			case Pq3: /* 16 bit escape, Rex.w, and opcode escape */
+				ctxt.Andptr[0] = Pe
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-	case Pq3: /* 16 bit escape, Rex.w, and opcode escape */
-		ctxt.Andptr[0] = Pe
-		ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = Pw
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-		ctxt.Andptr[0] = Pw
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
+			case Pf2, /* xmm opcode escape */
+				Pf3:
+				ctxt.Andptr[0] = byte(o.prefix)
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-	case Pf2, /* xmm opcode escape */
-		Pf3:
-		ctxt.Andptr[0] = byte(o.prefix)
-		ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
+			case Pm: /* opcode escape */
+				ctxt.Andptr[0] = Pm
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-	case Pm: /* opcode escape */
-		ctxt.Andptr[0] = Pm
-		ctxt.Andptr = ctxt.Andptr[1:]
+			case Pe: /* 16 bit escape */
+				ctxt.Andptr[0] = Pe
+				ctxt.Andptr = ctxt.Andptr[1:]
 
-	case Pe: /* 16 bit escape */
-		ctxt.Andptr[0] = Pe
-		ctxt.Andptr = ctxt.Andptr[1:]
+			case Pw: /* 64-bit escape */
+				if p.Mode != 64 {
+					ctxt.Diag("asmins: illegal 64: %v", p)
+				}
+				ctxt.Rexflag |= Pw
 
-	case Pw: /* 64-bit escape */
-		if p.Mode != 64 {
-			ctxt.Diag("asmins: illegal 64: %v", p)
-		}
-		ctxt.Rexflag |= Pw
+			case Pb: /* botch */
+				bytereg(&p.From, &p.Ft)
 
-	case Pb: /* botch */
-		bytereg(&p.From, &p.Ft)
+				bytereg(&p.To, &p.Tt)
 
-		bytereg(&p.To, &p.Tt)
+			case P32: /* 32 bit but illegal if 64-bit mode */
+				if p.Mode == 64 {
+					ctxt.Diag("asmins: illegal in 64-bit mode: %v", p)
+				}
 
-	case P32: /* 32 bit but illegal if 64-bit mode */
-		if p.Mode == 64 {
-			ctxt.Diag("asmins: illegal in 64-bit mode: %v", p)
-		}
+			case Py: /* 64-bit only, no prefix */
+				if p.Mode != 64 {
+					ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
+				}
+			}
 
-	case Py: /* 64-bit only, no prefix */
-		if p.Mode != 64 {
-			ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
-		}
-	}
-
-	if z >= len(o.op) {
-		log.Fatalf("asmins bad table %v", p)
-	}
-	op = int(o.op[z])
-	if op == 0x0f {
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		z++
-		op = int(o.op[z])
-	}
-
-	switch yt.zcase {
-	default:
-		ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
-		return
-
-	case Zpseudo:
-		break
-
-	case Zlit:
-		for ; ; z++ {
+			if z >= len(o.op) {
+				log.Fatalf("asmins bad table %v", p)
+			}
 			op = int(o.op[z])
-			if op == 0 {
+			if op == 0x0f {
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				z++
+				op = int(o.op[z])
+			}
+
+			switch yt.zcase {
+			default:
+				ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
+				return
+
+			case Zpseudo:
 				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
 
-	case Zlitm_r:
-		for ; ; z++ {
-			op = int(o.op[z])
-			if op == 0 {
-				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case Zmb_r:
-		bytereg(&p.From, &p.Ft)
-		fallthrough
-
-		/* fall through */
-	case Zm_r:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case Zm2_r:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(o.op[z+1])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case Zm_r_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case Zm_r_xm_nr:
-		ctxt.Rexflag = 0
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case Zm_r_i_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.From, &p.To)
-		ctxt.Andptr[0] = byte(p.To.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zm_r_3d:
-		ctxt.Andptr[0] = 0x0f
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = 0x0f
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.From, &p.To)
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zibm_r:
-		for {
-			tmp1 := z
-			z++
-			op = int(o.op[tmp1])
-			if op == 0 {
-				break
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		asmand(ctxt, p, &p.From, &p.To)
-		ctxt.Andptr[0] = byte(p.To.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zaut_r:
-		ctxt.Andptr[0] = 0x8d
-		ctxt.Andptr = ctxt.Andptr[1:] /* leal */
-		if p.From.Type != obj.TYPE_ADDR {
-			ctxt.Diag("asmins: Zaut sb type ADDR")
-		}
-		p.From.Type = obj.TYPE_MEM
-		asmand(ctxt, p, &p.From, &p.To)
-		p.From.Type = obj.TYPE_ADDR
-
-	case Zm_o:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.From, int(o.op[z+1]))
-
-	case Zr_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, &p.From)
-
-	case Zr_m_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.To, &p.From)
-
-	case Zr_m_xm_nr:
-		ctxt.Rexflag = 0
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.To, &p.From)
-
-	case Zr_m_i_xm:
-		mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmand(ctxt, p, &p.To, &p.From)
-		ctxt.Andptr[0] = byte(p.From.Offset)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.To, int(o.op[z+1]))
-
-	case Zcallindreg:
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc)
-		r.Type = obj.R_CALLIND
-		r.Siz = 0
-		fallthrough
-
-		// fallthrough
-	case Zo_m64:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmandsz(ctxt, p, &p.To, int(o.op[z+1]), 0, 1)
-
-	case Zm_ibo:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.From, int(o.op[z+1]))
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.To, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zibo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.To, int(o.op[z+1]))
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zibo_m_xm:
-		z = mediaop(ctxt, o, op, int(yt.zoffset), z)
-		asmando(ctxt, p, &p.To, int(o.op[z+1]))
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Z_ib,
-		Zib_:
-		if yt.zcase == Zib_ {
-			a = &p.From
-		} else {
-			a = &p.To
-		}
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, a, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zib_rp:
-		ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zil_rp:
-		ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, &p.From, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, &p.From)
-		}
-
-	case Zo_iw:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if p.From.Type != obj.TYPE_NONE {
-			v = vaddr(ctxt, p, &p.From, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-	case Ziq_rp:
-		v = vaddr(ctxt, p, &p.From, &rel)
-		l = int(v >> 32)
-		if l == 0 && rel.Siz != 8 {
-			//p->mark |= 0100;
-			//print("zero: %llux %P\n", v, p);
-			ctxt.Rexflag &^= (0x40 | Rxw)
-
-			ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
-			ctxt.Andptr[0] = byte(0xb8 + reg[p.To.Reg])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			if rel.Type != 0 {
-				r = obj.Addrel(ctxt.Cursym)
-				*r = rel
-				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-			}
-
-			put4(ctxt, int32(v))
-		} else if l == -1 && uint64(v)&(uint64(1)<<31) != 0 { /* sign extend */
-
-			//p->mark |= 0100;
-			//print("sign: %llux %P\n", v, p);
-			ctxt.Andptr[0] = 0xc7
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-			asmando(ctxt, p, &p.To, 0)
-			put4(ctxt, int32(v)) /* need all 8 */
-		} else {
-			//print("all: %llux %P\n", v, p);
-			ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
-
-			ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			if rel.Type != 0 {
-				r = obj.Addrel(ctxt.Cursym)
-				*r = rel
-				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-			}
-
-			put8(ctxt, v)
-		}
-
-	case Zib_rr:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, &p.To)
-		ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Z_il,
-		Zil_:
-		if yt.zcase == Zil_ {
-			a = &p.From
-		} else {
-			a = &p.To
-		}
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, a, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, a)
-		}
-
-	case Zm_ilo,
-		Zilo_m:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if yt.zcase == Zilo_m {
-			a = &p.From
-			asmando(ctxt, p, &p.To, int(o.op[z+1]))
-		} else {
-			a = &p.To
-			asmando(ctxt, p, &p.From, int(o.op[z+1]))
-		}
-
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, a, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, a)
-		}
-
-	case Zil_rr:
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, &p.To)
-		if o.prefix == Pe {
-			v = vaddr(ctxt, p, &p.From, nil)
-			ctxt.Andptr[0] = byte(v)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else {
-			relput4(ctxt, p, &p.From)
-		}
-
-	case Z_rp:
-		ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
-		ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zrp_:
-		ctxt.Rexflag |= regrex[p.From.Reg] & (Rxb | 0x40)
-		ctxt.Andptr[0] = byte(op + reg[p.From.Reg])
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-	case Zclr:
-		ctxt.Rexflag &^= Pw
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmand(ctxt, p, &p.To, &p.To)
-
-	case Zcall:
-		if p.To.Sym == nil {
-			ctxt.Diag("call without target")
-			log.Fatalf("bad code")
-		}
-
-		ctxt.Andptr[0] = byte(op)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		r = obj.Addrel(ctxt.Cursym)
-		r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		r.Sym = p.To.Sym
-		r.Add = p.To.Offset
-		r.Type = obj.R_CALL
-		r.Siz = 4
-		put4(ctxt, 0)
-
-		// TODO: jump across functions needs reloc
-	case Zbr,
-		Zjmp,
-		Zloop:
-		if p.To.Sym != nil {
-			if yt.zcase != Zjmp {
-				ctxt.Diag("branch to ATEXT")
-				log.Fatalf("bad code")
-			}
-
-			ctxt.Andptr[0] = byte(o.op[z+1])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			r = obj.Addrel(ctxt.Cursym)
-			r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-			r.Sym = p.To.Sym
-			r.Type = obj.R_PCREL
-			r.Siz = 4
-			put4(ctxt, 0)
-			break
-		}
-
-		// Assumes q is in this function.
-		// TODO: Check in input, preserve in brchain.
-
-		// Fill in backward jump now.
-		q = p.Pcond
-
-		if q == nil {
-			ctxt.Diag("jmp/branch/loop without target")
-			log.Fatalf("bad code")
-		}
-
-		if p.Back&1 != 0 {
-			v = q.Pc - (p.Pc + 2)
-			if v >= -128 {
-				if p.As == AJCXZL {
-					ctxt.Andptr[0] = 0x67
+			case Zlit:
+				for ; ; z++ {
+					op = int(o.op[z])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
 					ctxt.Andptr = ctxt.Andptr[1:]
 				}
+
+			case Zlitm_r:
+				for ; ; z++ {
+					op = int(o.op[z])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+				asmand(ctxt, p, &p.From, &p.To)
+
+			case Zmb_r:
+				bytereg(&p.From, &p.Ft)
+				fallthrough
+
+				/* fall through */
+			case Zm_r:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+				asmand(ctxt, p, &p.From, &p.To)
+
+			case Zm2_r:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(o.op[z+1])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, &p.To)
+
+			case Zm_r_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.From, &p.To)
+
+			case Zm_r_xm_nr:
+				ctxt.Rexflag = 0
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.From, &p.To)
+
+			case Zm_r_i_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.From, &p.To)
+				ctxt.Andptr[0] = byte(p.To.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zm_r_3d:
+				ctxt.Andptr[0] = 0x0f
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = 0x0f
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.From, &p.To)
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zibm_r:
+				for {
+					tmp1 := z
+					z++
+					op = int(o.op[tmp1])
+					if op == 0 {
+						break
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+				asmand(ctxt, p, &p.From, &p.To)
+				ctxt.Andptr[0] = byte(p.To.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zaut_r:
+				ctxt.Andptr[0] = 0x8d
+				ctxt.Andptr = ctxt.Andptr[1:] /* leal */
+				if p.From.Type != obj.TYPE_ADDR {
+					ctxt.Diag("asmins: Zaut sb type ADDR")
+				}
+				p.From.Type = obj.TYPE_MEM
+				asmand(ctxt, p, &p.From, &p.To)
+				p.From.Type = obj.TYPE_ADDR
+
+			case Zm_o:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmando(ctxt, p, &p.From, int(o.op[z+1]))
+
+			case Zr_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, &p.From)
+
+			case Zr_m_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.To, &p.From)
+
+			case Zr_m_xm_nr:
+				ctxt.Rexflag = 0
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.To, &p.From)
+
+			case Zr_m_i_xm:
+				mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmand(ctxt, p, &p.To, &p.From)
+				ctxt.Andptr[0] = byte(p.From.Offset)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmando(ctxt, p, &p.To, int(o.op[z+1]))
+
+			case Zcallindreg:
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc)
+				r.Type = obj.R_CALLIND
+				r.Siz = 0
+				fallthrough
+
+				// fallthrough
+			case Zo_m64:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+				asmandsz(ctxt, p, &p.To, int(o.op[z+1]), 0, 1)
+
+			case Zm_ibo:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmando(ctxt, p, &p.From, int(o.op[z+1]))
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.To, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zibo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmando(ctxt, p, &p.To, int(o.op[z+1]))
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zibo_m_xm:
+				z = mediaop(ctxt, o, op, int(yt.zoffset), z)
+				asmando(ctxt, p, &p.To, int(o.op[z+1]))
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Z_ib,
+				Zib_:
+				if yt.zcase == Zib_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
 				ctxt.Andptr[0] = byte(op)
 				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v)
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, a, nil))
 				ctxt.Andptr = ctxt.Andptr[1:]
-			} else if yt.zcase == Zloop {
-				ctxt.Diag("loop too far: %v", p)
-			} else {
-				v -= 5 - 2
-				if yt.zcase == Zbr {
-					ctxt.Andptr[0] = 0x0f
+
+			case Zib_rp:
+				ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zil_rp:
+				ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ctxt.Andptr[0] = byte(v)
 					ctxt.Andptr = ctxt.Andptr[1:]
-					v--
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, &p.From)
 				}
 
-				ctxt.Andptr[0] = byte(o.op[z+1])
+			case Zo_iw:
+				ctxt.Andptr[0] = byte(op)
 				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 8)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 16)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 24)
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-
-			break
-		}
-
-		// Annotate target; will fill in later.
-		p.Forwd = q.Comefrom
-
-		q.Comefrom = p
-		if p.Back&2 != 0 { // short
-			if p.As == AJCXZL {
-				ctxt.Andptr[0] = 0x67
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-			ctxt.Andptr[0] = byte(op)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-		} else if yt.zcase == Zloop {
-			ctxt.Diag("loop too far: %v", p)
-		} else {
-			if yt.zcase == Zbr {
-				ctxt.Andptr[0] = 0x0f
-				ctxt.Andptr = ctxt.Andptr[1:]
-			}
-			ctxt.Andptr[0] = byte(o.op[z+1])
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-		break
-
-	/*
-		v = q->pc - p->pc - 2;
-		if((v >= -128 && v <= 127) || p->pc == -1 || q->pc == -1) {
-			*ctxt->andptr++ = op;
-			*ctxt->andptr++ = v;
-		} else {
-			v -= 5-2;
-			if(yt.zcase == Zbr) {
-				*ctxt->andptr++ = 0x0f;
-				v--;
-			}
-			*ctxt->andptr++ = o->op[z+1];
-			*ctxt->andptr++ = v;
-			*ctxt->andptr++ = v>>8;
-			*ctxt->andptr++ = v>>16;
-			*ctxt->andptr++ = v>>24;
-		}
-	*/
-
-	case Zbyte:
-		v = vaddr(ctxt, p, &p.From, &rel)
-		if rel.Siz != 0 {
-			rel.Siz = uint8(op)
-			r = obj.Addrel(ctxt.Cursym)
-			*r = rel
-			r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
-		}
-
-		ctxt.Andptr[0] = byte(v)
-		ctxt.Andptr = ctxt.Andptr[1:]
-		if op > 1 {
-			ctxt.Andptr[0] = byte(v >> 8)
-			ctxt.Andptr = ctxt.Andptr[1:]
-			if op > 2 {
-				ctxt.Andptr[0] = byte(v >> 16)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = byte(v >> 24)
-				ctxt.Andptr = ctxt.Andptr[1:]
-				if op > 4 {
-					ctxt.Andptr[0] = byte(v >> 32)
+				if p.From.Type != obj.TYPE_NONE {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ctxt.Andptr[0] = byte(v)
 					ctxt.Andptr = ctxt.Andptr[1:]
-					ctxt.Andptr[0] = byte(v >> 40)
-					ctxt.Andptr = ctxt.Andptr[1:]
-					ctxt.Andptr[0] = byte(v >> 48)
-					ctxt.Andptr = ctxt.Andptr[1:]
-					ctxt.Andptr[0] = byte(v >> 56)
+					ctxt.Andptr[0] = byte(v >> 8)
 					ctxt.Andptr = ctxt.Andptr[1:]
 				}
+
+			case Ziq_rp:
+				v = vaddr(ctxt, p, &p.From, &rel)
+				l = int(v >> 32)
+				if l == 0 && rel.Siz != 8 {
+					//p->mark |= 0100;
+					//print("zero: %llux %P\n", v, p);
+					ctxt.Rexflag &^= (0x40 | Rxw)
+
+					ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
+					ctxt.Andptr[0] = byte(0xb8 + reg[p.To.Reg])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					if rel.Type != 0 {
+						r = obj.Addrel(ctxt.Cursym)
+						*r = rel
+						r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+					}
+
+					put4(ctxt, int32(v))
+				} else if l == -1 && uint64(v)&(uint64(1)<<31) != 0 { /* sign extend */
+
+					//p->mark |= 0100;
+					//print("sign: %llux %P\n", v, p);
+					ctxt.Andptr[0] = 0xc7
+					ctxt.Andptr = ctxt.Andptr[1:]
+
+					asmando(ctxt, p, &p.To, 0)
+					put4(ctxt, int32(v)) /* need all 8 */
+				} else {
+					//print("all: %llux %P\n", v, p);
+					ctxt.Rexflag |= regrex[p.To.Reg] & Rxb
+
+					ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					if rel.Type != 0 {
+						r = obj.Addrel(ctxt.Cursym)
+						*r = rel
+						r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+					}
+
+					put8(ctxt, v)
+				}
+
+			case Zib_rr:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, &p.To)
+				ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Z_il,
+				Zil_:
+				if yt.zcase == Zil_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, a)
+				}
+
+			case Zm_ilo,
+				Zilo_m:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if yt.zcase == Zilo_m {
+					a = &p.From
+					asmando(ctxt, p, &p.To, int(o.op[z+1]))
+				} else {
+					a = &p.To
+					asmando(ctxt, p, &p.From, int(o.op[z+1]))
+				}
+
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, a)
+				}
+
+			case Zil_rr:
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, &p.To)
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ctxt.Andptr[0] = byte(v)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else {
+					relput4(ctxt, p, &p.From)
+				}
+
+			case Z_rp:
+				ctxt.Rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
+				ctxt.Andptr[0] = byte(op + reg[p.To.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zrp_:
+				ctxt.Rexflag |= regrex[p.From.Reg] & (Rxb | 0x40)
+				ctxt.Andptr[0] = byte(op + reg[p.From.Reg])
+				ctxt.Andptr = ctxt.Andptr[1:]
+
+			case Zclr:
+				ctxt.Rexflag &^= Pw
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				asmand(ctxt, p, &p.To, &p.To)
+
+			case Zcall:
+				if p.To.Sym == nil {
+					ctxt.Diag("call without target")
+					log.Fatalf("bad code")
+				}
+
+				ctxt.Andptr[0] = byte(op)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				r = obj.Addrel(ctxt.Cursym)
+				r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				r.Sym = p.To.Sym
+				r.Add = p.To.Offset
+				r.Type = obj.R_CALL
+				r.Siz = 4
+				put4(ctxt, 0)
+
+				// TODO: jump across functions needs reloc
+			case Zbr,
+				Zjmp,
+				Zloop:
+				if p.To.Sym != nil {
+					if yt.zcase != Zjmp {
+						ctxt.Diag("branch to ATEXT")
+						log.Fatalf("bad code")
+					}
+
+					ctxt.Andptr[0] = byte(o.op[z+1])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					r = obj.Addrel(ctxt.Cursym)
+					r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+					r.Sym = p.To.Sym
+					r.Type = obj.R_PCREL
+					r.Siz = 4
+					put4(ctxt, 0)
+					break
+				}
+
+				// Assumes q is in this function.
+				// TODO: Check in input, preserve in brchain.
+
+				// Fill in backward jump now.
+				q = p.Pcond
+
+				if q == nil {
+					ctxt.Diag("jmp/branch/loop without target")
+					log.Fatalf("bad code")
+				}
+
+				if p.Back&1 != 0 {
+					v = q.Pc - (p.Pc + 2)
+					if v >= -128 {
+						if p.As == AJCXZL {
+							ctxt.Andptr[0] = 0x67
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+						ctxt.Andptr[0] = byte(op)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v)
+						ctxt.Andptr = ctxt.Andptr[1:]
+					} else if yt.zcase == Zloop {
+						ctxt.Diag("loop too far: %v", p)
+					} else {
+						v -= 5 - 2
+						if yt.zcase == Zbr {
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							v--
+						}
+
+						ctxt.Andptr[0] = byte(o.op[z+1])
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 8)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 16)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 24)
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+
+					break
+				}
+
+				// Annotate target; will fill in later.
+				p.Forwd = q.Comefrom
+
+				q.Comefrom = p
+				if p.Back&2 != 0 { // short
+					if p.As == AJCXZL {
+						ctxt.Andptr[0] = 0x67
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+					ctxt.Andptr[0] = byte(op)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+				} else if yt.zcase == Zloop {
+					ctxt.Diag("loop too far: %v", p)
+				} else {
+					if yt.zcase == Zbr {
+						ctxt.Andptr[0] = 0x0f
+						ctxt.Andptr = ctxt.Andptr[1:]
+					}
+					ctxt.Andptr[0] = byte(o.op[z+1])
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+					ctxt.Andptr[0] = 0
+					ctxt.Andptr = ctxt.Andptr[1:]
+				}
+
+				break
+
+			/*
+				v = q->pc - p->pc - 2;
+				if((v >= -128 && v <= 127) || p->pc == -1 || q->pc == -1) {
+					*ctxt->andptr++ = op;
+					*ctxt->andptr++ = v;
+				} else {
+					v -= 5-2;
+					if(yt.zcase == Zbr) {
+						*ctxt->andptr++ = 0x0f;
+						v--;
+					}
+					*ctxt->andptr++ = o->op[z+1];
+					*ctxt->andptr++ = v;
+					*ctxt->andptr++ = v>>8;
+					*ctxt->andptr++ = v>>16;
+					*ctxt->andptr++ = v>>24;
+				}
+			*/
+
+			case Zbyte:
+				v = vaddr(ctxt, p, &p.From, &rel)
+				if rel.Siz != 0 {
+					rel.Siz = uint8(op)
+					r = obj.Addrel(ctxt.Cursym)
+					*r = rel
+					r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
+				}
+
+				ctxt.Andptr[0] = byte(v)
+				ctxt.Andptr = ctxt.Andptr[1:]
+				if op > 1 {
+					ctxt.Andptr[0] = byte(v >> 8)
+					ctxt.Andptr = ctxt.Andptr[1:]
+					if op > 2 {
+						ctxt.Andptr[0] = byte(v >> 16)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						ctxt.Andptr[0] = byte(v >> 24)
+						ctxt.Andptr = ctxt.Andptr[1:]
+						if op > 4 {
+							ctxt.Andptr[0] = byte(v >> 32)
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = byte(v >> 40)
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = byte(v >> 48)
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = byte(v >> 56)
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+					}
+				}
 			}
+
+			return
 		}
+		z += int(yt.zoffset) + xo
 	}
-
-	return
-
-domov:
-	for mo = ymovtab; mo[0].as != 0; mo = mo[1:] {
+	var pp obj.Prog
+	var t []byte
+	for mo := ymovtab; mo[0].as != 0; mo = mo[1:] {
 		if p.As == mo[0].as {
 			if ycover[ft+int(mo[0].ft)] != 0 {
 				if ycover[tt+int(mo[0].tt)] != 0 {
 					t = mo[0].op[:]
-					goto mfound
+					switch mo[0].code {
+					default:
+						ctxt.Diag("asmins: unknown mov %d %v", mo[0].code, p)
+
+					case 0: /* lit */
+						for z = 0; t[z] != E; z++ {
+							ctxt.Andptr[0] = t[z]
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+
+					case 1: /* r,m */
+						ctxt.Andptr[0] = t[0]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						asmando(ctxt, p, &p.To, int(t[1]))
+
+					case 2: /* m,r */
+						ctxt.Andptr[0] = t[0]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						asmando(ctxt, p, &p.From, int(t[1]))
+
+					case 3: /* r,m - 2op */
+						ctxt.Andptr[0] = t[0]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						ctxt.Andptr[0] = t[1]
+						ctxt.Andptr = ctxt.Andptr[1:]
+						asmando(ctxt, p, &p.To, int(t[2]))
+						ctxt.Rexflag |= regrex[p.From.Reg] & (Rxr | 0x40)
+
+					case 4: /* m,r - 2op */
+						ctxt.Andptr[0] = t[0]
+						ctxt.Andptr = ctxt.Andptr[1:]
+
+						ctxt.Andptr[0] = t[1]
+						ctxt.Andptr = ctxt.Andptr[1:]
+						asmando(ctxt, p, &p.From, int(t[2]))
+						ctxt.Rexflag |= regrex[p.To.Reg] & (Rxr | 0x40)
+
+					case 5: /* load full pointer, trash heap */
+						if t[0] != 0 {
+							ctxt.Andptr[0] = t[0]
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+						switch p.To.Index {
+						default:
+							goto bad
+
+						case REG_DS:
+							ctxt.Andptr[0] = 0xc5
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_SS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb2
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_ES:
+							ctxt.Andptr[0] = 0xc4
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_FS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb4
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case REG_GS:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = 0xb5
+							ctxt.Andptr = ctxt.Andptr[1:]
+						}
+
+						asmand(ctxt, p, &p.From, &p.To)
+
+					case 6: /* double shift */
+						if t[0] == Pw {
+							if p.Mode != 64 {
+								ctxt.Diag("asmins: illegal 64: %v", p)
+							}
+							ctxt.Rexflag |= Pw
+							t = t[1:]
+						} else if t[0] == Pe {
+							ctxt.Andptr[0] = Pe
+							ctxt.Andptr = ctxt.Andptr[1:]
+							t = t[1:]
+						}
+
+						switch p.From.Type {
+						default:
+							goto bad
+
+						case obj.TYPE_CONST:
+							ctxt.Andptr[0] = 0x0f
+							ctxt.Andptr = ctxt.Andptr[1:]
+							ctxt.Andptr[0] = t[0]
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmandsz(ctxt, p, &p.To, reg[int(p.From.Index)], regrex[int(p.From.Index)], 0)
+							ctxt.Andptr[0] = byte(p.From.Offset)
+							ctxt.Andptr = ctxt.Andptr[1:]
+
+						case obj.TYPE_REG:
+							switch p.From.Reg {
+							default:
+								goto bad
+
+							case REG_CL,
+								REG_CX:
+								ctxt.Andptr[0] = 0x0f
+								ctxt.Andptr = ctxt.Andptr[1:]
+								ctxt.Andptr[0] = t[1]
+								ctxt.Andptr = ctxt.Andptr[1:]
+								asmandsz(ctxt, p, &p.To, reg[int(p.From.Index)], regrex[int(p.From.Index)], 0)
+							}
+						}
+
+						// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
+					// where you load the TLS base register into a register and then index off that
+					// register to access the actual TLS variables. Systems that allow direct TLS access
+					// are handled in prefixof above and should not be listed here.
+					case 7: /* mov tls, r */
+						switch ctxt.Headtype {
+						default:
+							log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
+
+						case obj.Hplan9:
+							if ctxt.Plan9privates == nil {
+								ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
+							}
+							pp.From = obj.Addr{}
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Name = obj.NAME_EXTERN
+							pp.From.Sym = ctxt.Plan9privates
+							pp.From.Offset = 0
+							pp.From.Index = REG_NONE
+							ctxt.Rexflag |= Pw
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, &p.To)
+
+							// TLS base is 0(FS).
+						case obj.Hsolaris: // TODO(rsc): Delete Hsolaris from list. Should not use this code. See progedit in obj6.c.
+							pp.From = p.From
+
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Name = obj.NAME_NONE
+							pp.From.Reg = REG_NONE
+							pp.From.Offset = 0
+							pp.From.Index = REG_NONE
+							pp.From.Scale = 0
+							ctxt.Rexflag |= Pw
+							ctxt.Andptr[0] = 0x64
+							ctxt.Andptr = ctxt.Andptr[1:] // FS
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, &p.To)
+
+							// Windows TLS base is always 0x28(GS).
+						case obj.Hwindows:
+							pp.From = p.From
+
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Name = obj.NAME_NONE
+							pp.From.Reg = REG_GS
+							pp.From.Offset = 0x28
+							pp.From.Index = REG_NONE
+							pp.From.Scale = 0
+							ctxt.Rexflag |= Pw
+							ctxt.Andptr[0] = 0x65
+							ctxt.Andptr = ctxt.Andptr[1:] // GS
+							ctxt.Andptr[0] = 0x8B
+							ctxt.Andptr = ctxt.Andptr[1:]
+							asmand(ctxt, p, &pp.From, &p.To)
+						}
+					}
+					return
 				}
 			}
 		}
 	}
+	goto bad
 
 bad:
 	if p.Mode != 64 {
@@ -3412,9 +3563,9 @@
 		 * exchange registers and reissue the
 		 * instruction with the operands renamed.
 		 */
-		pp = *p
+		pp := *p
 
-		z = int(p.From.Reg)
+		z := int(p.From.Reg)
 		if p.From.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
 			if isax(&p.To) || p.To.Type == obj.TYPE_NONE {
 				// We certainly don't want to exchange
@@ -3465,186 +3616,6 @@
 
 	ctxt.Diag("doasm: notfound ft=%d tt=%d %v %d %d", p.Ft, p.Tt, p, oclass(ctxt, p, &p.From), oclass(ctxt, p, &p.To))
 	return
-
-mfound:
-	switch mo[0].code {
-	default:
-		ctxt.Diag("asmins: unknown mov %d %v", mo[0].code, p)
-
-	case 0: /* lit */
-		for z = 0; t[z] != E; z++ {
-			ctxt.Andptr[0] = t[z]
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-	case 1: /* r,m */
-		ctxt.Andptr[0] = t[0]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmando(ctxt, p, &p.To, int(t[1]))
-
-	case 2: /* m,r */
-		ctxt.Andptr[0] = t[0]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		asmando(ctxt, p, &p.From, int(t[1]))
-
-	case 3: /* r,m - 2op */
-		ctxt.Andptr[0] = t[0]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = t[1]
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.To, int(t[2]))
-		ctxt.Rexflag |= regrex[p.From.Reg] & (Rxr | 0x40)
-
-	case 4: /* m,r - 2op */
-		ctxt.Andptr[0] = t[0]
-		ctxt.Andptr = ctxt.Andptr[1:]
-
-		ctxt.Andptr[0] = t[1]
-		ctxt.Andptr = ctxt.Andptr[1:]
-		asmando(ctxt, p, &p.From, int(t[2]))
-		ctxt.Rexflag |= regrex[p.To.Reg] & (Rxr | 0x40)
-
-	case 5: /* load full pointer, trash heap */
-		if t[0] != 0 {
-			ctxt.Andptr[0] = t[0]
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-		switch p.To.Index {
-		default:
-			goto bad
-
-		case REG_DS:
-			ctxt.Andptr[0] = 0xc5
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_SS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb2
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_ES:
-			ctxt.Andptr[0] = 0xc4
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_FS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb4
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case REG_GS:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = 0xb5
-			ctxt.Andptr = ctxt.Andptr[1:]
-		}
-
-		asmand(ctxt, p, &p.From, &p.To)
-
-	case 6: /* double shift */
-		if t[0] == Pw {
-			if p.Mode != 64 {
-				ctxt.Diag("asmins: illegal 64: %v", p)
-			}
-			ctxt.Rexflag |= Pw
-			t = t[1:]
-		} else if t[0] == Pe {
-			ctxt.Andptr[0] = Pe
-			ctxt.Andptr = ctxt.Andptr[1:]
-			t = t[1:]
-		}
-
-		switch p.From.Type {
-		default:
-			goto bad
-
-		case obj.TYPE_CONST:
-			ctxt.Andptr[0] = 0x0f
-			ctxt.Andptr = ctxt.Andptr[1:]
-			ctxt.Andptr[0] = t[0]
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmandsz(ctxt, p, &p.To, reg[int(p.From.Index)], regrex[int(p.From.Index)], 0)
-			ctxt.Andptr[0] = byte(p.From.Offset)
-			ctxt.Andptr = ctxt.Andptr[1:]
-
-		case obj.TYPE_REG:
-			switch p.From.Reg {
-			default:
-				goto bad
-
-			case REG_CL,
-				REG_CX:
-				ctxt.Andptr[0] = 0x0f
-				ctxt.Andptr = ctxt.Andptr[1:]
-				ctxt.Andptr[0] = t[1]
-				ctxt.Andptr = ctxt.Andptr[1:]
-				asmandsz(ctxt, p, &p.To, reg[int(p.From.Index)], regrex[int(p.From.Index)], 0)
-			}
-		}
-
-		// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
-	// where you load the TLS base register into a register and then index off that
-	// register to access the actual TLS variables. Systems that allow direct TLS access
-	// are handled in prefixof above and should not be listed here.
-	case 7: /* mov tls, r */
-		switch ctxt.Headtype {
-		default:
-			log.Fatalf("unknown TLS base location for %s", obj.Headstr(ctxt.Headtype))
-
-		case obj.Hplan9:
-			if ctxt.Plan9privates == nil {
-				ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
-			}
-			pp.From = obj.Addr{}
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Name = obj.NAME_EXTERN
-			pp.From.Sym = ctxt.Plan9privates
-			pp.From.Offset = 0
-			pp.From.Index = REG_NONE
-			ctxt.Rexflag |= Pw
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, &p.To)
-
-			// TLS base is 0(FS).
-		case obj.Hsolaris: // TODO(rsc): Delete Hsolaris from list. Should not use this code. See progedit in obj6.c.
-			pp.From = p.From
-
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Name = obj.NAME_NONE
-			pp.From.Reg = REG_NONE
-			pp.From.Offset = 0
-			pp.From.Index = REG_NONE
-			pp.From.Scale = 0
-			ctxt.Rexflag |= Pw
-			ctxt.Andptr[0] = 0x64
-			ctxt.Andptr = ctxt.Andptr[1:] // FS
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, &p.To)
-
-			// Windows TLS base is always 0x28(GS).
-		case obj.Hwindows:
-			pp.From = p.From
-
-			pp.From.Type = obj.TYPE_MEM
-			pp.From.Name = obj.NAME_NONE
-			pp.From.Reg = REG_GS
-			pp.From.Offset = 0x28
-			pp.From.Index = REG_NONE
-			pp.From.Scale = 0
-			ctxt.Rexflag |= Pw
-			ctxt.Andptr[0] = 0x65
-			ctxt.Andptr = ctxt.Andptr[1:] // GS
-			ctxt.Andptr[0] = 0x8B
-			ctxt.Andptr = ctxt.Andptr[1:]
-			asmand(ctxt, p, &pp.From, &p.To)
-		}
-	}
 }
 
 var naclret = []uint8{
@@ -3701,18 +3672,11 @@
 }
 
 func asmins(ctxt *obj.Link, p *obj.Prog) {
-	var i int
-	var n int
-	var np int
-	var c int
-	var and0 []byte
-	var r *obj.Reloc
-
 	ctxt.Andptr = ctxt.And[:]
 	ctxt.Asmode = int(p.Mode)
 
 	if p.As == obj.AUSEFIELD {
-		r = obj.Addrel(ctxt.Cursym)
+		r := obj.Addrel(ctxt.Cursym)
 		r.Off = 0
 		r.Siz = 0
 		r.Sym = p.From.Sym
@@ -3839,7 +3803,7 @@
 	}
 
 	ctxt.Rexflag = 0
-	and0 = ctxt.Andptr
+	and0 := ctxt.Andptr
 	ctxt.Asmode = int(p.Mode)
 	doasm(ctxt, p)
 	if ctxt.Rexflag != 0 {
@@ -3853,7 +3817,9 @@
 		if p.Mode != 64 {
 			ctxt.Diag("asmins: illegal in mode %d: %v", p.Mode, p)
 		}
-		n = -cap(ctxt.Andptr) + cap(and0)
+		n := -cap(ctxt.Andptr) + cap(and0)
+		var c int
+		var np int
 		for np = 0; np < n; np++ {
 			c = int(and0[np])
 			if c != 0xf2 && c != 0xf3 && (c < 0x64 || c > 0x67) && c != 0x2e && c != 0x3e && c != 0x26 {
@@ -3866,8 +3832,9 @@
 		ctxt.Andptr = ctxt.Andptr[1:]
 	}
 
-	n = -cap(ctxt.Andptr) + cap(ctxt.And[:])
-	for i = len(ctxt.Cursym.R) - 1; i >= 0; i-- {
+	n := -cap(ctxt.Andptr) + cap(ctxt.And[:])
+	var r *obj.Reloc
+	for i := len(ctxt.Cursym.R) - 1; i >= 0; i-- {
 		r = &ctxt.Cursym.R[i:][0]
 		if int64(r.Off) < p.Pc {
 			break
diff --git a/src/cmd/internal/obj/x86/list6.go b/src/cmd/internal/obj/x86/list6.go
index 41c69c9..b2a7a7a 100644
--- a/src/cmd/internal/obj/x86/list6.go
+++ b/src/cmd/internal/obj/x86/list6.go
@@ -55,7 +55,6 @@
 
 func Pconv(p *obj.Prog) string {
 	var str string
-	var fp string
 
 	switch p.As {
 	case obj.ADATA:
@@ -84,6 +83,7 @@
 		}
 	}
 
+	var fp string
 	fp += str
 	return fp
 }
diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index 4cb2f45..81e4e0e 100644
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -49,10 +49,6 @@
 }
 
 func progedit(ctxt *obj.Link, p *obj.Prog) {
-	var literal string
-	var s *obj.LSym
-	var q *obj.Prog
-
 	// Thread-local storage references use the TLS pseudo-register.
 	// As a register, TLS refers to the thread-local storage base, and it
 	// can only be loaded into another register:
@@ -121,7 +117,7 @@
 		//	MOVQ off(BX)(TLS*1), BX
 		// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
 		if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 {
-			q = obj.Appendp(ctxt, p)
+			q := obj.Appendp(ctxt, p)
 			q.As = p.As
 			q.From = p.From
 			q.From.Type = obj.TYPE_MEM
@@ -214,12 +210,10 @@
 		ACOMISS,
 		AUCOMISS:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i32 uint32
-			var f32 float32
-			f32 = float32(p.From.U.Dval)
-			i32 = math.Float32bits(f32)
-			literal = fmt.Sprintf("$f32.%08x", i32)
-			s = obj.Linklookup(ctxt, literal, 0)
+			f32 := float32(p.From.U.Dval)
+			i32 := math.Float32bits(f32)
+			literal := fmt.Sprintf("$f32.%08x", i32)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint32(ctxt, s, i32)
@@ -262,10 +256,9 @@
 		ACOMISD,
 		AUCOMISD:
 		if p.From.Type == obj.TYPE_FCONST {
-			var i64 uint64
-			i64 = math.Float64bits(p.From.U.Dval)
-			literal = fmt.Sprintf("$f64.%016x", i64)
-			s = obj.Linklookup(ctxt, literal, 0)
+			i64 := math.Float64bits(p.From.U.Dval)
+			literal := fmt.Sprintf("$f64.%016x", i64)
+			s := obj.Linklookup(ctxt, literal, 0)
 			if s.Type == 0 {
 				s.Type = obj.SRODATA
 				obj.Adduint64(ctxt, s, i64)
@@ -315,17 +308,6 @@
 }
 
 func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
-	var p *obj.Prog
-	var q *obj.Prog
-	var p1 *obj.Prog
-	var p2 *obj.Prog
-	var autoffset int32
-	var deltasp int32
-	var a int
-	var pcsize int
-	var bpsize int
-	var textarg int64
-
 	if ctxt.Tlsg == nil {
 		ctxt.Tlsg = obj.Linklookup(ctxt, "runtime.tlsg", 0)
 	}
@@ -344,12 +326,13 @@
 		return
 	}
 
-	p = cursym.Text
-	autoffset = int32(p.To.Offset)
+	p := cursym.Text
+	autoffset := int32(p.To.Offset)
 	if autoffset < 0 {
 		autoffset = 0
 	}
 
+	var bpsize int
 	if obj.Framepointer_enabled != 0 && autoffset > 0 {
 		// Make room for to save a base pointer.  If autoffset == 0,
 		// this might do something special like a tail jump to
@@ -362,12 +345,12 @@
 		bpsize = 0
 	}
 
-	textarg = int64(p.To.U.Argsize)
+	textarg := int64(p.To.U.Argsize)
 	cursym.Args = int32(textarg)
 	cursym.Locals = int32(p.To.Offset)
 
 	if autoffset < obj.StackSmall && p.From3.Offset&obj.NOSPLIT == 0 {
-		for q = p; q != nil; q = q.Link {
+		for q := p; q != nil; q = q.Link {
 			if q.As == obj.ACALL {
 				goto noleaf
 			}
@@ -380,7 +363,7 @@
 	noleaf:
 	}
 
-	q = nil
+	q := (*obj.Prog)(nil)
 	if p.From3.Offset&obj.NOSPLIT == 0 || (p.From3.Offset&obj.WRAPPER != 0) {
 		p = obj.Appendp(ctxt, p)
 		p = load_g_cx(ctxt, p) // load g into CX
@@ -415,7 +398,7 @@
 	if q != nil {
 		q.Pcond = p
 	}
-	deltasp = autoffset
+	deltasp := autoffset
 
 	if bpsize > 0 {
 		// Save caller's BP
@@ -486,7 +469,7 @@
 		p = obj.Appendp(ctxt, p)
 		p.As = AJEQ
 		p.To.Type = obj.TYPE_BRANCH
-		p1 = p
+		p1 := p
 
 		p = obj.Appendp(ctxt, p)
 		p.As = ALEAQ
@@ -517,7 +500,7 @@
 		p = obj.Appendp(ctxt, p)
 		p.As = AJNE
 		p.To.Type = obj.TYPE_BRANCH
-		p2 = p
+		p2 := p
 
 		p = obj.Appendp(ctxt, p)
 		p.As = AMOVQ
@@ -573,6 +556,8 @@
 		p.As = ASTOSQ
 	}
 
+	var a int
+	var pcsize int
 	for ; p != nil; p = p.Link {
 		pcsize = int(p.Mode) / 8
 		a = int(p.From.Name)
@@ -691,8 +676,6 @@
 // prologue (caller must call appendp first) and in the epilogue.
 // Returns last new instruction.
 func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog {
-	var next *obj.Prog
-
 	p.As = AMOVQ
 	if ctxt.Arch.Ptrsize == 4 {
 		p.As = AMOVL
@@ -703,7 +686,7 @@
 	p.To.Type = obj.TYPE_REG
 	p.To.Reg = REG_CX
 
-	next = p.Link
+	next := p.Link
 	progedit(ctxt, p)
 	for p.Link != next {
 		p = p.Link
@@ -723,17 +706,10 @@
 // On return, *jmpok is the instruction that should jump
 // to the stack frame allocation if no split is needed.
 func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, textarg int32, noctxt bool, jmpok **obj.Prog) *obj.Prog {
-	var q *obj.Prog
-	var q1 *obj.Prog
-	var cmp int
-	var lea int
-	var mov int
-	var sub int
-
-	cmp = ACMPQ
-	lea = ALEAQ
-	mov = AMOVQ
-	sub = ASUBQ
+	cmp := ACMPQ
+	lea := ALEAQ
+	mov := AMOVQ
+	sub := ASUBQ
 
 	if ctxt.Headtype == obj.Hnacl {
 		cmp = ACMPL
@@ -742,7 +718,7 @@
 		sub = ASUBL
 	}
 
-	q1 = nil
+	q1 := (*obj.Prog)(nil)
 	if framesize <= obj.StackSmall {
 		// small stack: SP <= stackguard
 		//	CMPQ SP, stackguard
@@ -845,7 +821,7 @@
 
 	p.As = AJHI
 	p.To.Type = obj.TYPE_BRANCH
-	q = p
+	q := p
 
 	p = obj.Appendp(ctxt, p)
 	p.As = obj.ACALL
@@ -873,13 +849,10 @@
 }
 
 func follow(ctxt *obj.Link, s *obj.LSym) {
-	var firstp *obj.Prog
-	var lastp *obj.Prog
-
 	ctxt.Cursym = s
 
-	firstp = ctxt.NewProg()
-	lastp = firstp
+	firstp := ctxt.NewProg()
+	lastp := firstp
 	xfol(ctxt, s.Text, &lastp)
 	lastp.Link = nil
 	s.Text = firstp.Link