diff --git a/src/cmd/5g/cgen.go b/src/cmd/5g/cgen.go index 638c5a677c1..d9d4892cbf5 100644 --- a/src/cmd/5g/cgen.go +++ b/src/cmd/5g/cgen.go @@ -25,15 +25,8 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) - goto ret + return } } @@ -90,7 +83,7 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { regfree(&n1) } - goto ret + return } // if both are not addressable, use a temporary. @@ -179,16 +172,16 @@ func cgen(n *gc.Node, res *gc.Node) { } 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 @@ func cgen(n *gc.Node, res *gc.Node) { n2 := *n n2.Left = &n1 cgen(&n2, res) - goto ret + return } } @@ -223,8 +216,34 @@ func cgen(n *gc.Node, res *gc.Node) { } } + 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ norm: 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 @@ flt2: // binary gmove(&f1, res) regfree(&f0) regfree(&f1) - goto ret - -ret: + return } /* @@ -666,7 +659,6 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { gins(arm.AMOVW, &n1, &n2) gmove(&n2, res) regfree(&n2) - goto ret + return } if n.Addable != 0 { @@ -694,10 +686,10 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { regfree(&n3) } } - -ret: } /* @@ -1195,25 +1185,23 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { bgen(n.Right, true_, likely, to) } - goto ret + return case gc.OEQ, gc.ONE, @@ -1256,7 +1244,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { gc.OGE: nr = n.Right if nr == nil || nr.Type == nil { - goto ret + return } fallthrough @@ -1264,14 +1252,14 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { regfree(&n2) } - goto ret - -ret: + return } /* diff --git a/src/cmd/5g/ggen.go b/src/cmd/5g/ggen.go index 8b7010f7728..2879805ef07 100644 --- a/src/cmd/5g/ggen.go +++ b/src/cmd/5g/ggen.go @@ -329,7 +329,7 @@ func cgen_call(n *gc.Node, proc int) { nod.Type = t ginscall(&nod, proc) regfree(&nod) - goto ret + return } // call pointer @@ -340,15 +340,13 @@ func cgen_call(n *gc.Node, proc int) { 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 ce0d5e8094c..424e164ed9c 100644 --- a/src/cmd/5g/gsubr.go +++ b/src/cmd/5g/gsubr.go @@ -331,10 +331,8 @@ func gmove(f *gc.Node, t *gc.Node) { // 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 @@ func gmove(f *gc.Node, t *gc.Node) { 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 @@ hard: // 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 @@ trunc64: 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 @@ func sudoaddable(as int, n *gc.Node, a *obj.Addr, w *int) bool { *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 @@ func sudoaddable(as int, n *gc.Node, a *obj.Addr, w *int) bool { 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 e28ec024d87..280cfb7fdcc 100644 --- a/src/cmd/5g/peep.go +++ b/src/cmd/5g/peep.go @@ -257,9 +257,8 @@ func subprop(r0 *gc.Flow) bool { 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 @@ func subprop(r0 *gc.Flow) bool { 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 @@ func subprop(r0 *gc.Flow) bool { } 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 909f682c982..0cebb6b6e75 100644 --- a/src/cmd/5l/asm.go +++ b/src/cmd/5l/asm.go @@ -38,17 +38,14 @@ import ( 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 adddynrela(rel *ld.LSym, s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 elfreloc1(r *ld.Reloc, sectoff int64) int { } 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 elfsetupplt() { 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 machoreloc1(r *ld.Reloc, sectoff int64) int { } 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 archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { } 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 addpltreloc(ctxt *ld.Link, plt *ld.LSym, got *ld.LSym, sym *ld.LSym, typ in } 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 @@ func addpltsym(ctxt *ld.Link, s *ld.LSym) { 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 addpltsym(ctxt *ld.Link, s *ld.LSym) { } 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 addgotsyminternal(ctxt *ld.Link, s *ld.LSym) { } 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 addgotsym(ctxt *ld.Link, s *ld.LSym) { } 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 adddynsym(ctxt *ld.Link, s *ld.LSym) { } 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 adddynlib(lib string) { } 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 98ebbc23ccc..7eb3b0e1e61 100644 --- a/src/cmd/5l/obj.go +++ b/src/cmd/5l/obj.go @@ -81,8 +81,6 @@ func linkarchinit() { } 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 @@ func archinit() { } // 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 cb16039dff4..05bc55b7ff7 100644 --- a/src/cmd/6g/cgen.go +++ b/src/cmd/6g/cgen.go @@ -29,13 +29,8 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { } else { gc.Cgen_slice(n, res) } - goto ret + return case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { @@ -71,7 +66,7 @@ func cgen(n *gc.Node, res *gc.Node) { } else { gc.Cgen_eface(n, res) } - goto ret + return } if n.Ullman >= gc.UINF { @@ -83,7 +78,7 @@ func cgen(n *gc.Node, res *gc.Node) { gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) - goto ret + return } } @@ -92,7 +87,7 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { cgen(&n1, res) regfree(&n1) - goto ret + return } var f int @@ -118,7 +113,7 @@ func cgen(n *gc.Node, res *gc.Node) { if gc.Complexop(n, res) { gc.Complexgen(n, res) - goto ret + return } f = 1 // gen thru register @@ -151,7 +146,7 @@ func cgen(n *gc.Node, res *gc.Node) { fmt.Printf("%v [ignore previous line]\n", p1) } sudoclean() - goto ret + return } } @@ -160,7 +155,7 @@ func cgen(n *gc.Node, res *gc.Node) { igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) - goto ret + return } // update addressability for string, slice @@ -184,16 +179,16 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { n2 := *n n2.Left = &n1 cgen(&n2, res) - goto ret + return } } @@ -224,10 +219,11 @@ func cgen(n *gc.Node, res *gc.Node) { } sudoclean() - goto ret + return } } + var a int switch n.Op { default: gc.Dump("cgen", n) @@ -252,11 +248,11 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { gmove(&n2, res) regfree(&n2) regfree(&n1) - goto ret + return } } @@ -517,7 +521,7 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ sbop: // symmetric binary } 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 @@ abop: // asymmetric binary 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 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { gins(x86.ALEAQ, &n1, &n2) gmove(&n2, res) regfree(&n2) - goto ret + return } if n.Addable != 0 { @@ -903,10 +897,10 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res) } } - -ret: } /* @@ -1108,27 +1100,21 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { } } + var nl *gc.Node switch n.Op { default: goto def @@ -1146,7 +1133,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { a = x86.AJEQ } gc.Patch(gc.Gbranch(a, n.Type, likely), to) - goto ret + return case gc.OANDAND, gc.OOROR: @@ -1178,7 +1165,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { bgen(n.Right, true_, likely, to) } - goto ret + return case gc.OEQ, gc.ONE, @@ -1188,7 +1175,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { gc.OGE: nr = n.Right if nr == nil || nr.Type == nil { - goto ret + return } fallthrough @@ -1196,14 +1183,14 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 d0c43d6db90..c278f02d32a 100644 --- a/src/cmd/6g/ggen.go +++ b/src/cmd/6g/ggen.go @@ -786,14 +786,6 @@ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { * 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 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { } gmove(&n1, res) regfree(&n1) - goto ret + return } if nl.Ullman >= gc.UINF { @@ -830,24 +822,27 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { 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 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { cx.Type = tcount + var n2 gc.Node if gc.Samereg(&cx, res) { regalloc(&n2, nl.Type, nil) } else { @@ -900,8 +896,6 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { regfree(&n1) regfree(&n2) - -ret: } /* diff --git a/src/cmd/6g/gsubr.go b/src/cmd/6g/gsubr.go index 4a1edf777a6..807b6b21b41 100644 --- a/src/cmd/6g/gsubr.go +++ b/src/cmd/6g/gsubr.go @@ -1349,12 +1349,6 @@ func sudoaddable(as int, n *gc.Node, a *obj.Addr) bool { *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 @@ func sudoaddable(as int, n *gc.Node, a *obj.Addr) bool { 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 ed582d7befd..f81be87aab3 100644 --- a/src/cmd/6g/peep.go +++ b/src/cmd/6g/peep.go @@ -563,8 +563,7 @@ func subprop(r0 *gc.Flow) bool { } 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 @@ func subprop(r0 *gc.Flow) bool { } 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 @@ func subprop(r0 *gc.Flow) bool { 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 72e9dbf26dc..22776b94307 100644 --- a/src/cmd/6l/asm.go +++ b/src/cmd/6l/asm.go @@ -44,17 +44,14 @@ func PADDR(x uint32) uint32 { 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 adddynrela(rela *ld.LSym, s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { // 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 adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 elfreloc1(r *ld.Reloc, sectoff int64) int { 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 archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { } 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 @@ func addpltsym(s *ld.LSym) { 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 @@ func addpltsym(s *ld.LSym) { // 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 addpltsym(s *ld.LSym) { } 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 addgotsym(s *ld.LSym) { } 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 adddynsym(ctxt *ld.Link, s *ld.LSym) { } 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 adddynlib(lib string) { } 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 ba8953a403c..1be092822d1 100644 --- a/src/cmd/8g/cgen.go +++ b/src/cmd/8g/cgen.go @@ -254,8 +254,15 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ abop: // asymmetric binary } 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 0755f0e1b7b..f0b9e490e05 100644 --- a/src/cmd/8g/cgen64.go +++ b/src/cmd/8g/cgen64.go @@ -199,7 +199,7 @@ func cgen64(n *gc.Node, res *gc.Node) { gins(i386.AMOVL, ncon(0), &lo2) gins(i386.AMOVL, ncon(0), &hi2) splitclean() - goto out + return } if v >= 32 { @@ -215,7 +215,7 @@ func cgen64(n *gc.Node, res *gc.Node) { gins(i386.AMOVL, ncon(0), &lo2) splitclean() splitclean() - goto out + return } // general shift @@ -296,7 +296,7 @@ func cgen64(n *gc.Node, res *gc.Node) { } splitclean() - goto out + return } if v >= 32 { @@ -316,7 +316,7 @@ func cgen64(n *gc.Node, res *gc.Node) { } splitclean() splitclean() - goto out + return } // general shift @@ -482,7 +482,7 @@ func cgen64(n *gc.Node, res *gc.Node) { splitclean() splitclean() - goto out + return } gins(i386.AMOVL, &lo1, &ax) @@ -500,8 +500,6 @@ func cgen64(n *gc.Node, res *gc.Node) { 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 ca2a79fb792..7aba85e41d7 100644 --- a/src/cmd/8g/ggen.go +++ b/src/cmd/8g/ggen.go @@ -934,7 +934,27 @@ func cgen_float387(n *gc.Node, res *gc.Node) { 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 @@ func cgen_float387(n *gc.Node, res *gc.Node) { } 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 @@ func bgen_float(n *gc.Node, true_ int, likely int, to *obj.Prog) { 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 @@ x87: 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 841f4dc66c9..ec007790d40 100644 --- a/src/cmd/8g/gsubr.go +++ b/src/cmd/8g/gsubr.go @@ -403,7 +403,48 @@ func foptoas(op int, t *gc.Type, flg int) int { 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 @@ func foptoas(op int, t *gc.Type, flg int) int { 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 @@ func gmove(f *gc.Node, t *gc.Node) { 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 @@ hard: 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 8aa6e94c61c..deb34050578 100644 --- a/src/cmd/8g/peep.go +++ b/src/cmd/8g/peep.go @@ -371,8 +371,7 @@ func subprop(r0 *gc.Flow) bool { 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 @@ func subprop(r0 *gc.Flow) bool { } 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 @@ func subprop(r0 *gc.Flow) bool { } 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 295c62ebf7e..d040c03326d 100644 --- a/src/cmd/8l/asm.go +++ b/src/cmd/8l/asm.go @@ -38,17 +38,14 @@ import ( 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 adddynrela(rela *ld.LSym, s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { // 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 adddynrel(s *ld.LSym, r *ld.Reloc) { } 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 elfreloc1(r *ld.Reloc, sectoff int64) int { 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 archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { } 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 elfsetupplt() { } 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 @@ func addpltsym(ctxt *ld.Link, s *ld.LSym) { 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 @@ func addpltsym(ctxt *ld.Link, s *ld.LSym) { } 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 addpltsym(ctxt *ld.Link, s *ld.LSym) { } 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 addgotsym(ctxt *ld.Link, s *ld.LSym) { } 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 adddynsym(ctxt *ld.Link, s *ld.LSym) { } 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 adddynlib(lib string) { } 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 74accf28e02..61a93da877e 100644 --- a/src/cmd/9g/cgen.go +++ b/src/cmd/9g/cgen.go @@ -26,13 +26,8 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { } else { gc.Cgen_slice(n, res) } - goto ret + return case gc.OEFACE: if res.Op != gc.ONAME || res.Addable == 0 { @@ -68,7 +63,7 @@ func cgen(n *gc.Node, res *gc.Node) { } else { gc.Cgen_eface(n, res) } - goto ret + return } if n.Ullman >= gc.UINF { @@ -80,7 +75,7 @@ func cgen(n *gc.Node, res *gc.Node) { gc.Tempname(&n1, n.Type) cgen(n, &n1) cgen(&n1, res) - goto ret + return } } @@ -89,7 +84,7 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { cgen(&n1, res) regfree(&n1) - goto ret + return } var f int @@ -115,7 +110,7 @@ func cgen(n *gc.Node, res *gc.Node) { if gc.Complexop(n, res) { gc.Complexgen(n, res) - goto ret + return } f = 1 // gen thru register @@ -148,7 +143,7 @@ func cgen(n *gc.Node, res *gc.Node) { fmt.Printf("%v [ignore previous line]\n", p1) } sudoclean() - goto ret + return } } @@ -157,7 +152,7 @@ func cgen(n *gc.Node, res *gc.Node) { igen(res, &n1, nil) cgen(n, &n1) regfree(&n1) - goto ret + return } // update addressability for string, slice @@ -181,7 +176,7 @@ func cgen(n *gc.Node, res *gc.Node) { if gc.Complexop(n, res) { gc.Complexgen(n, res) - goto ret + return } // if both are addressable, move @@ -196,11 +191,11 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { n2 := *n n2.Left = &n1 cgen(&n2, res) - goto ret + return } } @@ -231,7 +226,7 @@ func cgen(n *gc.Node, res *gc.Node) { } sudoclean() - goto ret + return } } @@ -239,6 +234,7 @@ func cgen(n *gc.Node, res *gc.Node) { // 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ func cgen(n *gc.Node, res *gc.Node) { gmove(&n2, res) regfree(&n2) regfree(&n1) - goto ret + return } } @@ -523,7 +527,7 @@ func cgen(n *gc.Node, res *gc.Node) { 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 @@ sbop: // symmetric binary } 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 @@ abop: // asymmetric binary 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 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { gins(ppc64.AMOVD, &n3, &n2) gmove(&n2, res) regfree(&n2) - goto ret + return } if n.Addable != 0 { @@ -918,10 +912,10 @@ func agen(n *gc.Node, res *gc.Node) { 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 @@ func agen(n *gc.Node, res *gc.Node) { ginsadd(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res) } } - -ret: } /* @@ -1126,24 +1118,21 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { } } + var nl *gc.Node switch n.Op { default: var n1 gc.Node @@ -1166,14 +1156,14 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { } 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { bgen(n.Right, true_, likely, to) } - goto ret + return case gc.OEQ, gc.ONE, @@ -1201,7 +1191,7 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { gc.OGE: nr = n.Right if nr == nil || nr.Type == nil { - goto ret + return } fallthrough @@ -1209,14 +1199,14 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { 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 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) { regfree(&n2) } - goto ret - -ret: + return } /* diff --git a/src/cmd/9g/ggen.go b/src/cmd/9g/ggen.go index 2a3dbcbfb38..bd227710898 100644 --- a/src/cmd/9g/ggen.go +++ b/src/cmd/9g/ggen.go @@ -572,10 +572,7 @@ func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) { 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 @@ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) { * 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 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { } gmove(&n1, res) regfree(&n1) - goto ret + return } if nl.Ullman >= gc.UINF { @@ -683,15 +675,18 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { // 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 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) { regfree(&n1) regfree(&n2) - -ret: } func clearfat(nl *gc.Node) { @@ -759,9 +752,8 @@ func clearfat(nl *gc.Node) { 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 @@ func clearfat(nl *gc.Node) { // 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 @@ func clearfat(nl *gc.Node) { // 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 @@ func clearfat(nl *gc.Node) { 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 f7c0a958199..ecb8fb5d926 100644 --- a/src/cmd/9g/peep.go +++ b/src/cmd/9g/peep.go @@ -407,9 +407,8 @@ func subprop(r0 *gc.Flow) bool { 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 @@ func subprop(r0 *gc.Flow) bool { 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 @@ func subprop(r0 *gc.Flow) bool { } 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 176de6f845c..f0f5b56f619 100644 --- a/src/cmd/9l/asm.go +++ b/src/cmd/9l/asm.go @@ -39,17 +39,14 @@ import ( 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 @@ func gentext() { // 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 @@ func gencallstub(abicase int, stub *ld.LSym, targ *ld.LSym) { 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 adddynrela(rel *ld.LSym, s *ld.LSym, r *ld.Reloc) { } 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 @@ func adddynrel(s *ld.LSym, r *ld.Reloc) { // 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 elfreloc1(r *ld.Reloc, sectoff int64) int { } 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 symtoc(s *ld.LSym) int64 { } 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 @@ func archreloc(r *ld.Reloc, s *ld.LSym, val *int64) int { // 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 @@ func archreloc(r *ld.Reloc, s *ld.LSym, val *int64) int { 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 archreloc(r *ld.Reloc, s *ld.LSym, val *int64) int { } 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 @@ func archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { 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 @@ func archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { 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 @@ func archrelocvariant(r *ld.Reloc, s *ld.LSym, t int64) int64 { 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 @@ func addpltsym(ctxt *ld.Link, s *ld.LSym) { 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 @@ func addpltsym(ctxt *ld.Link, s *ld.LSym) { // 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 @@ func ensureglinkresolver() *ld.LSym { 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 @@ func ensureglinkresolver() *ld.LSym { // 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 ensureglinkresolver() *ld.LSym { } 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 @@ func adddynsym(ctxt *ld.Link, s *ld.LSym) { 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 adddynsym(ctxt *ld.Link, s *ld.LSym) { } 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 adddynlib(lib string) { } 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 @@ func asmb() { 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 @@ func asmb() { 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 @@ func asmb() { 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 71c6b1a23c2..151a8a59269 100644 --- a/src/cmd/internal/asm/asm.go +++ b/src/cmd/internal/asm/asm.go @@ -163,11 +163,9 @@ func usage() { } 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 Main() { } func assemble(file string) int { - var i int - if outfile == "" { outfile = strings.TrimSuffix(filepath.Base(file), ".s") + "." + string(Thechar) } @@ -235,6 +231,7 @@ func assemble(file string) int { 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 14a82f82282..7943cba0396 100644 --- a/src/cmd/internal/asm/lexbody.go +++ b/src/cmd/internal/asm/lexbody.go @@ -45,61 +45,50 @@ import ( * 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 errorexit() { } func pushio() { - var i *Io - - i = iostack + i := iostack if i == nil { Yyerror("botch in pushio") errorexit() @@ -129,10 +116,9 @@ func pushio() { } 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 newio() { } 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 Settext(s *obj.LSym) { } 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 @@ type Yylval struct { } 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 @@ l1: 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 @@ aloop: 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 @@ ncu: } func getc() int { - var c int - - c = peekc + c := peekc if c != IGN { peekc = IGN if c == '\n' { @@ -571,11 +546,10 @@ func unget(c int) { } 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 pinit(f string) { } func filbuf() int { - var i *Io var n int loop: - i = iostack + i := iostack if i == nil { return EOF } @@ -705,11 +678,10 @@ func prfile(l int32) { } 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 337692a08ae..c488ea1e568 100644 --- a/src/cmd/internal/asm/macbody.go +++ b/src/cmd/internal/asm/macbody.go @@ -43,14 +43,11 @@ const ( ) 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 getnsn() int32 { } 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 getsym() *Sym { } 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 getcom() int { 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 @@ var mactab = []struct { } 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 domacro() { } func macund() { - var s *Sym - - s = getsym() + s := getsym() macend() if s == nil { Yyerror("syntax in #undef") @@ -226,8 +212,6 @@ const ( ) func macdef() { - var s *Sym - var a *Sym var args [NARG]string var n int var i int @@ -236,7 +220,7 @@ func macdef() { var ischr int var base bytes.Buffer - s = getsym() + s := getsym() if s == nil { goto bad } @@ -251,6 +235,8 @@ func macdef() { c = getnsc() if c != ')' { unget(c) + var a *Sym + var c int for { a = getsymdots(&dots) if a == nil { @@ -316,7 +302,6 @@ func macdef() { ischr = 0 } } else { - if c == '"' || c == '\'' { base.WriteByte(byte(c)) ischr = c @@ -417,20 +402,12 @@ bad: 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 @@ func macexpand(s *Sym) []byte { 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 @@ bad: } 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 @@ func macinc() { 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 @@ bad: } 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 @@ bad: } 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 @@ func macprag() { } 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 43c8809fecf..4730d7d0eed 100644 --- a/src/cmd/internal/gc/const.go +++ b/src/cmd/internal/gc/const.go @@ -582,7 +582,96 @@ func evconst(n *Node) { 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 @@ func evconst(n *Node) { 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 c07ba346335..02b6c791556 100644 --- a/src/cmd/internal/gc/cplx.go +++ b/src/cmd/internal/gc/cplx.go @@ -255,10 +255,12 @@ func Complexop(n *Node, res *Node) bool { } 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 @@ maybe: 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 4e5f0116c1c..c03222b913f 100644 --- a/src/cmd/internal/gc/lex.go +++ b/src/cmd/internal/gc/lex.go @@ -844,7 +844,6 @@ type Loophack struct { 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 @@ func _yylex(yylval *yySymType) int32 { prevlineno = lineno l0: - c = getc() + c := getc() if yy_isspace(c) { if c == '\n' && curio.nlsemi != 0 { ungetc(c) @@ -887,7 +886,82 @@ l0: } 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 @@ talph: 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 more(pp *string) bool { */ 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 @@ func getlinepragma() int { 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 @@ func getlinepragma() int { } if n <= 0 { - goto out + return c } // try to avoid allocating file name over and over @@ -1587,76 +1640,12 @@ func getlinepragma() int { 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 @@ func pragcgo(text string) { 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 @@ func pragcgo(text string) { } if !more(&q) { pragcgobuf += fmt.Sprintf("%s %v\n", verb, plan9quote(local)) - goto out + return } remote = getimpsym(&q) @@ -1737,11 +1724,11 @@ func pragcgo(text string) { 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 @@ func pragcgo(text string) { } if !more(&q) { pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v\n", plan9quote(local)) - goto out + return } remote = getimpsym(&q) @@ -1763,7 +1750,7 @@ func pragcgo(text string) { } 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 @@ func pragcgo(text string) { 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 @@ func pragcgo(text string) { 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 @@ func escchar(e int, escflg *int, val *int64) bool { u := 0 c = int(getr()) - var l int64 var i int switch c { case 'x': @@ -2010,7 +1990,24 @@ func escchar(e int, escflg *int, val *int64) bool { '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 @@ func escchar(e int, escflg *int, val *int64) bool { return false hex: - l = 0 + l := int64(0) for ; i > 0; i-- { c = getc() if c >= '0' && c <= '9' { @@ -2067,26 +2064,6 @@ hex: l = utf8.RuneError } - *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 } diff --git a/src/cmd/internal/gc/mparith1.go b/src/cmd/internal/gc/mparith1.go index 104992f6496..d728d6ab51d 100644 --- a/src/cmd/internal/gc/mparith1.go +++ b/src/cmd/internal/gc/mparith1.go @@ -451,7 +451,6 @@ bad: // func mpatofix(a *Mpint, as string) { var c int - var s0 string s := as f := 0 @@ -471,7 +470,43 @@ func mpatofix(a *Mpint, as string) { 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 @@ func mpatofix(a *Mpint, as string) { 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 c9c9230bd5b..7e129134461 100644 --- a/src/cmd/internal/gc/mparith2.go +++ b/src/cmd/internal/gc/mparith2.go @@ -187,12 +187,44 @@ func mpaddfixfix(a *Mpint, b *Mpint, quiet int) { } 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 @@ func mpaddfixfix(a *Mpint, b *Mpint, quiet int) { } 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 86e7ea0235c..e6211e1ebf7 100644 --- a/src/cmd/internal/gc/plive.go +++ b/src/cmd/internal/gc/plive.go @@ -657,7 +657,7 @@ Next: 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 @@ Next: } } } - -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 5f9586bd413..e051c255e2a 100644 --- a/src/cmd/internal/gc/reg.go +++ b/src/cmd/internal/gc/reg.go @@ -185,32 +185,22 @@ func overlap_reg(o1 int64, w1 int, o2 int64, w2 int) bool { } 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 @@ func mkvar(f *Flow, a *obj.Addr) Bits { setaddrs(bit) a.Type = obj.TYPE_ADDR Ostats.Naddr++ - goto none + return zbits memcase: fallthrough @@ -243,7 +233,7 @@ func mkvar(f *Flow, a *obj.Addr) Bits { */ switch a.Name { default: - goto none + return zbits case obj.NAME_EXTERN, obj.NAME_STATIC, @@ -253,25 +243,27 @@ func mkvar(f *Flow, a *obj.Addr) Bits { } } + 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 @@ func mkvar(f *Flow, a *obj.Addr) Bits { switch et { case 0, TFUNC: - goto none + return zbits } if nvar >= NVAR { @@ -319,10 +311,10 @@ func mkvar(f *Flow, a *obj.Addr) Bits { } } - goto none + return zbits } - i = nvar + i := nvar nvar++ v = &var_[i:][0] v.id = i @@ -341,7 +333,7 @@ func mkvar(f *Flow, a *obj.Addr) Bits { 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 @@ func mkvar(f *Flow, a *obj.Addr) Bits { 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 ca8db418619..4cb2dd66ab9 100644 --- a/src/cmd/internal/gc/sinit.go +++ b/src/cmd/internal/gc/sinit.go @@ -533,21 +533,18 @@ func isliteral(n *Node) bool { 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 anylit(ctxt int, n *Node, var_ *Node, init **NodeList) { } 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 getlit(lit *Node) int { func stataddr(nam *Node, n *Node) bool { if n == nil { - goto no + return false } switch n.Op { @@ -1281,7 +1278,6 @@ func stataddr(nam *Node, n *Node) bool { return true } -no: return false } @@ -1420,7 +1416,6 @@ func gen_as_init(n *Node) bool { var nr *Node var nl *Node var nam Node - var nod1 Node if n.Dodata == 0 { goto no @@ -1436,7 +1431,7 @@ func gen_as_init(n *Node) bool { if nam.Class != PEXTERN { goto no } - goto yes + return true } if nr.Type == nil || !Eqtype(nl.Type, nr.Type) { @@ -1466,7 +1461,33 @@ func gen_as_init(n *Node) bool { 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 @@ func gen_as_init(n *Node) bool { 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 1c59e595215..c8eb1d6c5ad 100644 --- a/src/cmd/internal/gc/subr.go +++ b/src/cmd/internal/gc/subr.go @@ -1014,14 +1014,14 @@ func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) bool { 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 @@ func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) bool { 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 assignconv(n *Node, t *Type, context string) *Node { } 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 @@ func Structfirst(s *Iter, nn **Type) *Type { t = n.Type if t == nil { - goto rnil + return nil } if t.Etype != TFIELD { @@ -1775,7 +1767,6 @@ func Structfirst(s *Iter, nn **Type) *Type { bad: Fatal("structfirst: not struct %v", Tconv(n, 0)) -rnil: return nil } @@ -1783,21 +1774,17 @@ func structnext(s *Iter) *Type { 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 @@ out: // 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 + } + + 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 + } } -ret: return n } @@ -3301,18 +3281,15 @@ func structcount(t *Type) int { * 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 @@ func powtwo(n *Node) int { } if Issigned[n.Type.Etype] == 0 { - goto no + return -1 } v = -v @@ -3333,7 +3310,6 @@ func powtwo(n *Node) int { b = b << 1 } -no: return -1 } @@ -3592,22 +3568,19 @@ func pathtoprefix(s string) string { 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 1468d5fb45a..cb0111e961b 100644 --- a/src/cmd/internal/gc/typecheck.go +++ b/src/cmd/internal/gc/typecheck.go @@ -1805,7 +1805,25 @@ reswitch: 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 @@ arith: 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 7f0a33f2a70..6faed493b44 100644 --- a/src/cmd/internal/gc/unsafe.go +++ b/src/cmd/internal/gc/unsafe.go @@ -14,31 +14,28 @@ import "cmd/internal/obj" * 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 @@ func unsafenmagic(nn *Node) *Node { goto yes } -no: return nil bad: diff --git a/src/cmd/internal/gc/util.go b/src/cmd/internal/gc/util.go index df68d500582..c3f7db2e98a 100644 --- a/src/cmd/internal/gc/util.go +++ b/src/cmd/internal/gc/util.go @@ -39,17 +39,14 @@ func isdigit(c int) bool { 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 c57bdd6b867..4667494b0f5 100644 --- a/src/cmd/internal/gc/walk.go +++ b/src/cmd/internal/gc/walk.go @@ -3653,7 +3653,23 @@ func walkrotate(np **Node) { 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 @@ func walkrotate(np **Node) { // 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 @@ func walkdiv(np **Node, init **NodeList) { 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 @@ func walkdiv(np **Node, init **NodeList) { 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 381030dd421..369d3a41f20 100644 --- a/src/cmd/internal/ld/data.go +++ b/src/cmd/internal/ld/data.go @@ -81,9 +81,7 @@ func setuintxx(ctxt *Link, s *LSym, off int64, v uint64, wid int64) int64 { } 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 setuint32(ctxt *Link, s *LSym, r int64, v uint32) int64 { } 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 Addaddrplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 { } 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 Addaddr(ctxt *Link, s *LSym, t *LSym) int64 { } 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 @@ func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 { 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 setaddr(ctxt *Link, s *LSym, off int64, t *LSym) int64 { } 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 addsize(ctxt *Link, s *LSym, t *LSym) int64 { } 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 listsubp(s *LSym) **LSym { } 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 @@ func listsort(l *LSym, cmp func(*LSym, *LSym) int, nextp func(*LSym) **LSym) *LS l2 = *nextp(l2) } - le = l + le := l for { if l1 == nil { @@ -332,14 +312,13 @@ func relocsym(s *LSym) { 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 relocsym(s *LSym) { } 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 @@ func dynrelocsym(s *LSym) { 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 dynrelocsym(s *LSym) { } 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 @@ func dynreloc() { } 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 dynreloc() { 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 @@ func blk(start *LSym, addr int64, size int64) { } } - 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 blk(start *LSym, addr int64, size int64) { } 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 @@ func Codeblk(addr int64, size int64) { return } + var sym *LSym for sym = Ctxt.Textp; sym != nil; sym = sym.Next { if !sym.Reachable { continue @@ -771,7 +738,9 @@ func Codeblk(addr int64, size int64) { } } - 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 Codeblk(addr int64, size int64) { } 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 @@ func Datblk(addr int64, size int64) { 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 addstrdata1(arg string) { } 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 addstrdata(name string, value string) { } 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 Addstring(s *LSym, str string) int64 { } 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 dosymtype() { } 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 @@ func aligndatsize(datsize int64, s *LSym) int64 { // 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 @@ func proggenemit(g *ProgGen, v uint8) { // 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 @@ func proggendata(g *ProgGen, d uint8) { // 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 @@ func proggenfini(g *ProgGen, size int64) { // 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 @@ func proggenaddsym(g *ProgGen, s *LSym) { 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 @@ func proggenaddsym(g *ProgGen, s *LSym) { 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 @@ func proggenaddsym(g *ProgGen, s *LSym) { // 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 proggenaddsym(g *ProgGen, s *LSym) { } 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 growdatsize(datsizep *int64, s *LSym) { } 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 @@ func dodata() { } } - 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 @@ func dodata() { 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 @@ func dodata() { } /* 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 @@ func dodata() { /* .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 @@ func dodata() { /* 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 @@ func dodata() { 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 @@ func dodata() { 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 @@ func dodata() { } 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 @@ func dodata() { * 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 @@ func dodata() { } /* 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 @@ func dodata() { // 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 @@ func textaddress() { // 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 @@ func textaddress() { // 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 @@ func address() { 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 @@ func address() { 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 @@ func address() { 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 @@ func address() { 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 c7b1a2f1691..74fa4b5f7c4 100644 --- a/src/cmd/internal/ld/decodesym.go +++ b/src/cmd/internal/ld/decodesym.go @@ -11,9 +11,7 @@ import "cmd/internal/obj" // ../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(s *LSym, off int32) *Reloc { } 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_gcprog(s *LSym) *LSym { } 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_funcoutcount(s *LSym) int { } 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_funcintype(s *LSym, i int) *LSym { } 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 @@ func structfieldsize() int { // 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 490795c7823..4d3715bd479 100644 --- a/src/cmd/internal/ld/dwarf.go +++ b/src/cmd/internal/ld/dwarf.go @@ -102,9 +102,8 @@ func addrput(addr int64) { 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 uleb128enc(v uint64, dst []byte) int { 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 @@ var abbrevs = [DW_NABRV]struct { } 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 @@ const ( ) 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 dwtypes DWDie 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 @@ func newattr(die *DWDie, attr uint16, cls int, value int64, data interface{}) *D // 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 @@ func getattr(die *DWDie, attr uint16) *DWAttr { // 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 @@ func newdie(parent *DWDie, abbrev int, name string) *DWDie { 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 mkindex(die *DWDie) { } 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 @@ notfound: } 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 find_or_diag(die *DWDie, name string) *DWDie { } 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 @@ func newrefattr(die *DWDie, attr uint16, ref *DWDie) *DWAttr { 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 @@ func putattr(abbrev int, form int, cls int, value int64, data interface{}) { 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 @@ func putattr(abbrev int, form int, cls int, value int64, data interface{}) { 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 @@ func putattr(abbrev int, form int, cls int, value int64, data interface{}) { 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 @@ func putattr(abbrev int, form int, cls int, value int64, data interface{}) { 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 @@ func putattr(abbrev int, form int, cls int, value int64, data interface{}) { // 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 putdie(die *DWDie) { } 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 reverselist(list **DWDie) { } 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 reversetree(list **DWDie) { 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 @@ func newabslocexprattr(die *DWDie, addr int64, sym *LSym) { // 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 lookup_or_diag(n string) *LSym { } 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 @@ func dotypedef(parent *DWDie, name string, def *DWDie) { // 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, "") } @@ -1124,9 +1081,9 @@ func defgotype(gotype *LSym) *DWDie { return find_or_diag(&dwtypes, "") } - 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { 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 @@ func defgotype(gotype *LSym) *DWDie { // 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 @@ func copychildren(dst *DWDie, src *DWDie) { // 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 substitutetype(structdie *DWDie, field string, dwtype *DWDie) { } 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 synthesizestringtypes(die *DWDie) { } 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 synthesizeslicetypes(die *DWDie) { 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 @@ const ( ) 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 synthesizemaptypes(die *DWDie) { } 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 @@ func synthesizechantypes(die *DWDie) { // 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 @@ func defdwsymb(sym *LSym, s string, t int, v int64, size int64, ver int, gotype return } - dv = nil + dv := (*DWDie)(nil) + var dt *DWDie switch t { default: return @@ -1625,9 +1567,7 @@ func defdwsymb(sym *LSym, s string, t int, v int64, size int64, ver int, gotype } 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 @@ func movetomodule(parent *DWDie) { // 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 putpclcdelta(delta_pc int64, delta_lc int64) { 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 newcfaoffsetattr(die *DWDie, offs int32) { } 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 @@ func mkvarname(name string, da int) string { // 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 @@ func flushunit(dwinfo *DWDie, pc int64, pcsym *LSym, unitstart int64, header_len 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 flushunit(dwinfo *DWDie, pc int64, pcsym *LSym, unitstart int64, header_len } 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 @@ func writelines() { 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 @@ func writelines() { 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 putpccfadelta(deltapc int64, cfa int64) { } 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 @@ func writeframes() { 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 @@ func writeframes() { 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 @@ const ( ) 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 @@ func writeinfo() { } 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 @@ func writeinfo() { * 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 ispubtype(die *DWDie) bool { } 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 @@ func writepub(ispub func(*DWDie) bool) int64 { * 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 writearanges() int64 { } func writegdbscript() int64 { - var sectionstart int64 - - sectionstart = Cpos() + sectionstart := Cpos() if gdbscript != "" { Cput(1) // magic 1 byte? @@ -2264,12 +2169,10 @@ func align(size int64) { 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 writedwarfreloc(s *LSym) int64 { * */ func Dwarfemitdebugsections() { - var infoe int64 - var die *DWDie - if Debug['w'] != 0 { // disable dwarf return } @@ -2320,7 +2220,7 @@ func Dwarfemitdebugsections() { 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 @@ func Dwarfemitdebugsections() { infoo = Cpos() writeinfo() - infoe = Cpos() + infoe := Cpos() pubnameso = infoe pubtypeso = infoe arangeso = infoe @@ -2510,9 +2410,7 @@ func dwarfaddelfsectionsyms() { } 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 dwarfaddelfrelocheader(elfstr int, shdata *ElfShdr, off int64, size int64) } 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 @@ func dwarfaddelfheaders() { if linesympos > 0 { putelfsymshndx(linesympos, sh.shnum) } - shline = sh + shline := sh sh = newElfShdr(elfstrdbg[ElfStrDebugFrame]) sh.type_ = SHT_PROGBITS @@ -2568,7 +2460,7 @@ func dwarfaddelfheaders() { if framesympos > 0 { putelfsymshndx(framesympos, sh.shnum) } - shframe = sh + shframe := sh sh = newElfShdr(elfstrdbg[ElfStrDebugInfo]) sh.type_ = SHT_PROGBITS @@ -2578,10 +2470,10 @@ func dwarfaddelfheaders() { 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 @@ func dwarfaddelfheaders() { } 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 @@ func dwarfaddelfheaders() { } 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 @@ func dwarfaddelfheaders() { * 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 @@ func dwarfaddmachoheaders() { 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 @@ func dwarfaddmachoheaders() { 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 @@ func dwarfaddmachoheaders() { } 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 @@ func dwarfaddmachoheaders() { } 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 @@ func dwarfaddmachoheaders() { // 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 f6d1043c10e..be66fab4da5 100644 --- a/src/cmd/internal/ld/elf.go +++ b/src/cmd/internal/ld/elf.go @@ -804,13 +804,11 @@ func elf64phdr(e *ElfPhdr) { } 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 elf32shdr(e *ElfShdr) { } 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 elfsetstring(s string, off int) { } 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 newElfPhdr() *ElfPhdr { } 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 getElfEhdr() *ElfEhdr { } 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 elf64writehdr() uint32 { } 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 elfwritedynentsymsize(s *LSym, tag int, t *LSym) { } 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 elfinterp(sh *ElfShdr, startva uint64, resoff uint64, p string) int { } 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 elfwriteinterp() int { } 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 elfnote(sh *ElfShdr, startva uint64, resoff uint64, sz int) int { } 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 @@ const ( 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 @@ const ( 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 elfwriteopenbsdsig() int { } 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 @@ func addbuildinfo(val string) { 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 @@ const ( 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 @@ type Elflib struct { 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 @@ func addelflib(list **Elflib, file string, vers string) *Elfaux { *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 @@ func elfdynhash() { 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 @@ func elfdynhash() { // 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 @@ func elfdynhash() { } 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 elfdynhash() { } 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 elfphload(seg *Segment) *ElfPhdr { } 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 elfshbits(sect *Section) *ElfShdr { } 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 @@ func elfshreloc(sect *Section) *ElfShdr { return nil } + var prefix string + var typ int if Thearch.Thechar == '6' || Thearch.Thechar == '9' { prefix = ".rela" typ = SHT_RELA @@ -1562,8 +1498,8 @@ func elfshreloc(sect *Section) *ElfShdr { 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 elfshreloc(sect *Section) *ElfShdr { } 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 @@ func elfrelocsect(sect *Section, first *LSym) { } sect.Reloff = uint64(Cpos()) + var sym *LSym for sym = first; sym != nil; sym = sym.Next { if !sym.Reachable { continue @@ -1602,7 +1534,9 @@ func elfrelocsect(sect *Section, first *LSym) { } } - 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 elfrelocsect(sect *Section, first *LSym) { } 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 @@ func doelf() { 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 @@ func doelf() { if s.Size == 0 { Addstring(s, "") } - dynstr = s + dynstr := s /* relocation table */ if Thearch.Thechar == '6' || Thearch.Thechar == '9' { @@ -1804,7 +1732,7 @@ func doelf() { /* 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 @@ func doelf() { // 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 phsh(ph *ElfPhdr, sh *ElfShdr) { } 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { * 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 @@ func Asmbelf(symo int64) { if Debug['d'] == 0 { /* interpreter */ - sh = elfshname(".interp") + sh := elfshname(".interp") sh.type_ = SHT_PROGBITS sh.flags = SHF_ALLOC @@ -2035,7 +1950,7 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { } 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 @@ func Asmbelf(symo int64) { /* 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { } 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 @@ func Asmbelf(symo int64) { // 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 @@ func Asmbelf(symo int64) { 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 @@ func Asmbelf(symo int64) { // 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 @@ func Asmbelf(symo int64) { } 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 @@ func Asmbelf(symo int64) { } elfobj: - sh = elfshname(".shstrtab") + sh := elfshname(".shstrtab") sh.type_ = SHT_STRTAB sh.addralign = 1 shsym(sh, Linklookup(Ctxt, ".shstrtab", 0)) @@ -2265,29 +2180,29 @@ elfobj: 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 @@ elfobj: // 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 @@ elfobj: } 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 @@ elfobj: } 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 cd85c8b96e7..f529cea9a7d 100644 --- a/src/cmd/internal/ld/go.go +++ b/src/cmd/internal/ld/go.go @@ -54,11 +54,8 @@ var ihash [NIHASH]*Import 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 hashstr(name string) int { } 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 ilookup(name string) *Import { } 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 @@ func ldpkg(f *Biobuf, pkg string, length int64, filename string, whence int) { 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 @@ func ldpkg(f *Biobuf, pkg string, length int64, filename string, whence int) { } 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 @@ func ldpkg(f *Biobuf, pkg string, length int64, filename string, whence int) { 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 ldpkg(f *Biobuf, pkg string, length int64, filename string, whence int) { } 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 loadpkgdata(file string, pkg string, data string) { } 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 @@ loop: 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 @@ loop: 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 @@ loop: 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 @@ loop: } 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 @@ useline: 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 @@ func loadcgo(file string, pkg string, p string) { 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 mark(s *LSym) { 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 @@ var markextra = []string{ } 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 @@ func deadcode() { 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 @@ func deadcode() { } // 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 @@ func deadcode() { if tracksym == "" { return } - s = Linklookup(Ctxt, tracksym, 0) + s := Linklookup(Ctxt, tracksym, 0) if !s.Reachable { return } @@ -749,12 +726,11 @@ func deadcode() { } 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 doweak() { } 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 phash [1024]*Pkg 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 getpkg(path_ string) *Pkg { } 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 @@ func cycle(p *Pkg) *Pkg { } 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 cycle(p *Pkg) *Pkg { } 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 99f2fab947d..3397dd288e6 100644 --- a/src/cmd/internal/ld/ld.go +++ b/src/cmd/internal/ld/ld.go @@ -86,10 +86,7 @@ func addlib(ctxt *Link, src string, obj string, pathname string) { * 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 @@ func addlibpath(ctxt *Link, srcref string, objref string, file string, pkg strin } 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 c50e9951683..372dc182d29 100644 --- a/src/cmd/internal/ld/ldelf.go +++ b/src/cmd/internal/ld/ldelf.go @@ -285,39 +285,35 @@ func valuecmp(a *LSym, b *LSym) int { } 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { // 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { // 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 @@ func ldelf(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ bad: } 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 elfmap(elfobj *ElfObj, sect *ElfSect) (err error) { } 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 @@ func readelfsym(elfobj *ElfObj, i int, sym *ElfSym, needSym int) (err error) { 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) Swap(i, j int) { } 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 e762318b1e2..58f065a3065 100644 --- a/src/cmd/internal/ld/ldmacho.go +++ b/src/cmd/internal/ld/ldmacho.go @@ -172,13 +172,8 @@ const ( ) 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 @@ func unpackcmd(p []byte, m *LdMachoObj, c *LdMachoCmd, type_ uint, sz uint) int 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 @@ func unpackcmd(p []byte, m *LdMachoObj, c *LdMachoCmd, type_ uint, sz uint) int 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 unpackcmd(p []byte, m *LdMachoObj, c *LdMachoCmd, type_ uint, sz uint) int } 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 macholoadrel(m *LdMachoObj, sect *LdMachoSect) int { } 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 macholoadsym(m *LdMachoObj, symtab *LdMachoSymtab) int { 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { var name string Ctxt.Version++ - base = Boffset(f) + base := Boffset(f) if Bread(f, hdr[:]) != len(hdr) { goto bad } @@ -475,6 +452,7 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { } if is64 { + var tmp [4]uint8 Bread(f, tmp[:4]) // skip reserved word in header } @@ -524,7 +502,7 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { // 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { // 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { rp = &r[rpi] rel = §.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 @@ func ldmacho(f *Biobuf, pkg string, length int64, pn string) { // 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 247e8292ade..0daf88780a8 100644 --- a/src/cmd/internal/ld/ldpe.go +++ b/src/cmd/internal/ld/ldpe.go @@ -127,36 +127,31 @@ type PeObj struct { } 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { } // 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 @@ func ldpe(f *Biobuf, pkg string, length int64, pn string) { // 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 issect(s *PeSym) bool { } 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 @@ func readpesym(peobj *PeObj, i int, y **PeSym) (err error) { 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 bc58ffff6f8..030ddbf67ab 100644 --- a/src/cmd/internal/ld/lib.go +++ b/src/cmd/internal/ld/lib.go @@ -294,16 +294,13 @@ func mayberemoveoutfile() { } 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 Errorexit() { 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 loadinternal(name string) { } 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 @@ func loadlib() { 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 @@ func loadlib() { } // 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 @@ func loadlib() { // 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 @@ func loadlib() { 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 @@ func loadlib() { } } - 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 @@ func loadlib() { 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 nextar(bp *Biobuf, off int64, a *ArHdr) int64 { } 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 @@ func objfile(file string, pkg string) { } 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 @@ func objfile(file string, pkg string) { 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 @@ func objfile(file string, pkg string) { } /* 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 @@ var internalpkg = []string{ } 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 @@ func ldhostobj(ld func(*Biobuf, string, int64, string), f *Biobuf, pkg string, l } 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 ldhostobj(ld func(*Biobuf, string, int64, string), f *Biobuf, pkg string, l } 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 rmtemp() { } func hostlinksetup() { - var p string - if Linkmode != LinkExternal { return } @@ -769,7 +748,7 @@ func hostlinksetup() { // 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 @@ func hostlinksetup() { 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 @@ func hostlink() { if extld == "" { extld = "gcc" } + var argv []string argv = append(argv, extld) switch Thearch.Thechar { case '8': @@ -851,7 +823,12 @@ func hostlink() { // 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 @@ func hostlink() { 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 @@ func hostlink() { } 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 hostlink() { } 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 @@ func ldobj(f *Biobuf, pkg string, length int64, pn string, file string, whence i } /* 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 @@ eof: } func zerosig(sp string) { - var s *LSym - - s = Linklookup(Ctxt, sp, 0) + s := Linklookup(Ctxt, sp, 0) s.Sig = 0 } @@ -1097,44 +1064,40 @@ func pathtoprefix(s string) string { 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 += "" 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 callsize() int { func dostkcheck() { var ch Chain - var s *LSym morestack = Linklookup(Ctxt, "runtime.morestack", 0) newstack = Linklookup(Ctxt, "runtime.newstack", 0) @@ -1215,7 +1177,7 @@ func dostkcheck() { // 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 @@ func dostkcheck() { } } - 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 dostkcheck() { } 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 @@ func stkcheck(up *Chain, depth int) int { 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 stkprint(ch *Chain, limit int) { func Yconv(s *LSym) string { var fp string - var fmt_ string - var i int - var str string - if s == nil { fp += fmt.Sprintf("") } 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 @@ func Yconv(s *LSym) string { } 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 usage() { } 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 doversion() { } 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 @@ func genasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) { 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 @@ func genasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) { } } - 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 Symaddr(s *LSym) int64 { } 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 datoff(addr int64) int64 { } 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 Entryvalue() int64 { } 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 undefsym(s *LSym) { } 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 undef() { } 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 Diag(format string, args ...interface{}) { } func checkgo() { - var s *LSym - var r *Reloc - var i int - var changed int - if Debug['C'] == 0 { return } @@ -1691,6 +1625,10 @@ func checkgo() { // 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 @@ func checkgo() { // 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 checkgo() { } 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 6349642b93e..9fe63f3f77f 100644 --- a/src/cmd/internal/ld/macho.go +++ b/src/cmd/internal/ld/macho.go @@ -156,14 +156,12 @@ func newMachoLoad(type_ uint32, ndata uint32) *MachoLoad { } 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 newMachoSeg(name string, msect int) *MachoSeg { } 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 ndylib int 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 @@ func machowrite() int { 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 @@ func machowrite() int { } } - 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 machowrite() int { } 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 @@ func domacho() { 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 Machoadddynlib(lib string) { } 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 machoshbits(mseg *MachoSeg, sect *Section, segname string) { } 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 @@ func Asmbmacho() { mh.subcpu = MACHO_SUBCPU_X86 } - ms = nil + ms := (*MachoSeg)(nil) if Linkmode == LinkExternal { /* segment for entire file */ ms = newMachoSeg("", 40) @@ -462,7 +439,7 @@ func Asmbmacho() { } /* 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 @@ func Asmbmacho() { 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 @@ func Asmbmacho() { 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 @@ func Asmbmacho() { 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 @@ func Asmbmacho() { } 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 @@ func Asmbmacho() { 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 @@ func Asmbmacho() { 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 @@ func Asmbmacho() { dwarfaddmachoheaders() } - a = machowrite() + a := machowrite() if int32(a) > HEADR { Diag("HEADR too small: %d > %d", a, HEADR) } @@ -624,16 +596,11 @@ func (x machoscmp) Swap(i, j int) { } 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 (x machoscmp) Less(i, j int) bool { } 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 machogenasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) { } 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 @@ func machosymorder() { 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 machosymtab() { } 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 @@ func machodysymtab() { 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 machodysymtab() { } 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 @@ func Domacholink() int64 { 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 Domacholink() int64 { } 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 @@ func machorelocsect(sect *Section, first *LSym) { } } - 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 machorelocsect(sect *Section, first *LSym) { } 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 98b7ba6c891..003c1063fcb 100644 --- a/src/cmd/internal/ld/objfile.go +++ b/src/cmd/internal/ld/objfile.go @@ -17,23 +17,19 @@ var startmagic string = "\x00\x00go13ld" 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 @@ func ldobjfile(ctxt *Link, f *Biobuf, pkg string, length int64, pn string) { 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 @@ overwrite: 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 @@ overwrite: 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 @@ overwrite: } 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 @@ overwrite: 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 @@ overwrite: 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 @@ overwrite: 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 @@ func rddata(f *Biobuf, pp *[]byte) { 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 @@ func rdsym(ctxt *Link, f *Biobuf, pkg string) *LSym { 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 29006649223..e8ef252a196 100644 --- a/src/cmd/internal/ld/pcln.go +++ b/src/cmd/internal/ld/pcln.go @@ -40,13 +40,9 @@ import ( // 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 getvarint(pp *[]byte) uint32 { } func pciternext(it *Pciter) { - var v uint32 - var dv int32 - it.pc = it.nextpc if it.done != 0 { return @@ -73,7 +66,7 @@ func pciternext(it *Pciter) { } // value delta - v = getvarint(&it.p) + v := getvarint(&it.p) if v == 0 && it.start == 0 { it.done = 1 @@ -81,7 +74,7 @@ func pciternext(it *Pciter) { } 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 @@ func pciterinit(ctxt *Link, it *Pciter, d *Pcdata) { // 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 @@ func addvarint(d *Pcdata, val uint32) { } 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 addvarint(d *Pcdata, val uint32) { } 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 addpctab(ftab *LSym, off int32, d *Pcdata) int32 { } 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 @@ func renumberfiles(ctxt *Link, files []*LSym, d *Pcdata) { } } - 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 @@ func container(s *LSym) int { 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 @@ func pclntab() { // 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 @@ func pclntab() { 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 @@ func pclntab() { 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 @@ const ( // 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 @@ func findfunctab() { } // 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 c2ef49fbeaa..30fe400bb3f 100644 --- a/src/cmd/internal/ld/pe.go +++ b/src/cmd/internal/ld/pe.go @@ -371,14 +371,12 @@ var coffsym []COFFSym 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 strput(s string) { } 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 @@ func initdynimport() *Dll { 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 initdynimport() *Dll { } 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 @@ func addimports(datsect *IMAGE_SECTION_HEADER) { } // 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 @@ func addimports(datsect *IMAGE_SECTION_HEADER) { // 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 @@ func addimports(datsect *IMAGE_SECTION_HEADER) { // 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) Swap(i, j int) { } 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 initdynexport() { } 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 @@ func addexports() { 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 @@ func addexports() { 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 @@ func strtbladd(name string) int { * */ 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 @@ func addpesym(s *LSym, name string, type_ int, addr int64, size int64, ver int, } 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 addpesym(s *LSym, name string, type_ int, addr int64, size int64, ver int, } 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 @@ func addpesymtable() { 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 @@ func addpesymtable() { // 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 setpersrc(sym *LSym) { } 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 addpersrc() { } func Asmbpe() { - var t *IMAGE_SECTION_HEADER - var d *IMAGE_SECTION_HEADER - switch Thearch.Thechar { default: Diag("unknown PE architecture") @@ -936,12 +891,12 @@ func Asmbpe() { 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 7e275a698b0..cbaa364a899 100644 --- a/src/cmd/internal/ld/sym.go +++ b/src/cmd/internal/ld/sym.go @@ -63,21 +63,18 @@ var headers = []struct { } 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 @@ func linknew(arch *LinkArch) *Link { // 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 linknew(arch *LinkArch) *Link { } 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 @@ func Linkrlookup(ctxt *Link, name string, v int) *LSym { 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 Headstr(v int) string { } 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 997300c5cbb..79c1bf6026c 100644 --- a/src/cmd/internal/ld/symtab.go +++ b/src/cmd/internal/ld/symtab.go @@ -37,9 +37,6 @@ import "strings" 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 @@ func putelfstr(s string) int { // 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 numelfsym int = 1 // 0 is reserved 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 @@ func putelfsym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ *L type_ = STT_OBJECT } - xo = x + xo := x for xo.Outer != nil { xo = xo.Outer } @@ -126,7 +119,7 @@ func putelfsym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ *L // 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 @@ func putelfsym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ *L 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 putelfsectionsym(s *LSym, shndx int) { } 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 putelfsymshndx(sympos int64, shndx int) { } 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 @@ func Asmelfsym() { 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 @@ func Asmelfsym() { 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 Asmelfsym() { } 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 @@ func putplan9sym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ '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 @@ func putplan9sym(x *LSym, s string, t int, addr int64, size int64, ver int, go_ 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 Vputl(v uint64) { } 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 @@ func symtab() { 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 @@ func symtab() { 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 @@ func symtab() { // 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 9a56f094664..8c37cab088b 100644 --- a/src/cmd/internal/ld/util.go +++ b/src/cmd/internal/ld/util.go @@ -26,17 +26,14 @@ func cstring(x []byte) string { 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 f82b737b5af..064cbe26f1d 100644 --- a/src/cmd/internal/obj/arm/asm5.go +++ b/src/cmd/internal/obj/arm/asm5.go @@ -304,13 +304,7 @@ func casesz(ctxt *obj.Link, p *obj.Prog) int32 { // 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 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3 // 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 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3 } 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 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3 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 asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3 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 @@ func span5(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func span5(ctxt *obj.Link, cursym *obj.LSym) { * 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 @@ func span5(ctxt *obj.Link, cursym *obj.LSym) { 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 checkpool(ctxt *obj.Link, p *obj.Prog, sz int) bool { } 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 @@ func flushpool(ctxt *obj.Link, p *obj.Prog, skip int, force int) bool { } 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 flushpool(ctxt *obj.Link, p *obj.Prog, skip int, force int) bool { } 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 @@ func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) { } 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 @@ func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) { 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 @@ func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) { ctxt.Elitrl = q } - q = ctxt.NewProg() + q := ctxt.NewProg() *q = t q.Pc = int64(pool.size) @@ -975,9 +965,7 @@ func regoff(ctxt *obj.Link, a *obj.Addr) int32 { } 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 immhalf(v int32) bool { } 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { case obj.NAME_EXTERN, obj.NAME_STATIC: - s = a.Sym + s := a.Sym if s == nil { break } @@ -1188,9 +1173,7 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { } 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 prasm(p *obj.Prog) { } 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 @@ func oplook(ctxt *obj.Link, p *obj.Prog) *Optab { } 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 @@ func oplook(ctxt *obj.Link, p *obj.Prog) *Optab { 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) Swap(i, j int) { } 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 (x ocmp) Less(i, j int) bool { } 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 @@ func buildop(ctxt *obj.Link) { } 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 buildop(ctxt *obj.Link) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { case 9: /* sll R,[R],R -> mov (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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 mov(ctxt *obj.Link, p *obj.Prog) uint32 { } 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 opbra(ctxt *obj.Link, a int, sc int) uint32 { } 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 olr(ctxt *obj.Link, v int32, b int, r int, sc int) uint32 { } 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 olhr(ctxt *obj.Link, v int32, b int, r int, sc int) uint32 { } 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 osr(ctxt *obj.Link, a int, r int, v int32, b int, sc int) uint32 { } 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 olhrr(ctxt *obj.Link, i int, b int, r int, sc int) uint32 { } 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 ofsr(ctxt *obj.Link, a int, r int, v int32, b int, sc int, p *obj.Prog) uin } 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 @@ func omvl(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, dr int) uint32 { 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 chipzero5(ctxt *obj.Link, e float64) int { } 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 @@ func chipfloat5(ctxt *obj.Link, e float64) int { //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 70280f3876c..60caedebc1f 100644 --- a/src/cmd/internal/obj/arm/list5.go +++ b/src/cmd/internal/obj/arm/list5.go @@ -61,16 +61,9 @@ var extra = []string{ 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 @@ func Pconv(p *obj.Prog) string { 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 @@ func Pconv(p *obj.Prog) string { 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 @@ func RAconv(a *obj.Addr) string { 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<= 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 9c1baca0384..0b7e1f7d906 100644 --- a/src/cmd/internal/obj/arm/obj5.go +++ b/src/cmd/internal/obj/arm/obj5.go @@ -41,9 +41,6 @@ import ( 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ const ( ) 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 linkcase(casep *obj.Prog) { } 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { // 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { * 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 isfloatreg(a *obj.Addr) bool { } 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 initdiv(ctxt *obj.Link) { } 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 428458614a2..112e839c160 100644 --- a/src/cmd/internal/obj/i386/asm8.go +++ b/src/cmd/internal/obj/i386/asm8.go @@ -1132,16 +1132,6 @@ func naclpad(ctxt *obj.Link, s *obj.LSym, c int32, pad int32) int32 { } 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 @@ func span8(ctxt *obj.Link, s *obj.LSym) { 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 @@ func span8(ctxt *obj.Link, s *obj.LSym) { } } - 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 @@ func span8(ctxt *obj.Link, s *obj.LSym) { } } - 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 @@ func span8(ctxt *obj.Link, s *obj.LSym) { 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 @@ func span8(ctxt *obj.Link, s *obj.LSym) { 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 @@ func instinit() { 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 @@ func instinit() { 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 prefixof(ctxt *obj.Link, a *obj.Addr) int { } 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 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int { 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 put4(ctxt *obj.Link, v int32) { } 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 relput4(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) { } 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 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 { 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 vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 { } 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 @@ func asmand(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int) { } 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 @@ func asmand(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int) { 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 @@ var ymovtab = []uint8{ // 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 mediaop(ctxt *obj.Link, o *Optab, op int, osize int, z int) int { } 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 @@ func doasm(ctxt *obj.Link, p *obj.Prog) { 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 @@ bad: 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 @@ bad: 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 @@ bad: 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 @@ var naclret = []uint8{ } 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 3aef35b7fca..f843006bdbf 100644 --- a/src/cmd/internal/obj/i386/list8.go +++ b/src/cmd/internal/obj/i386/list8.go @@ -43,7 +43,6 @@ var bigP *obj.Prog func Pconv(p *obj.Prog) string { var str string - var fp string switch p.As { case obj.ADATA: @@ -72,6 +71,7 @@ func Pconv(p *obj.Prog) string { } } + 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 88adba045ed..63cb7f26424 100644 --- a/src/cmd/internal/obj/i386/obj8.go +++ b/src/cmd/internal/obj/i386/obj8.go @@ -51,10 +51,6 @@ func canuselocaltls(ctxt *obj.Link) bool { } 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { // 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 progedit(ctxt *obj.Link, p *obj.Prog) { } 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { // 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 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog { 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 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog { // 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 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok 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 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok q1.Pcond = p } - q1 = nil + q1 := (*obj.Prog)(nil) if framesize <= obj.StackSmall { // small stack: SP <= stackguard @@ -651,7 +632,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok 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 stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool, jmpok } 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 e66522999c0..16d1626727d 100644 --- a/src/cmd/internal/obj/ppc64/asm9.go +++ b/src/cmd/internal/obj/ppc64/asm9.go @@ -407,18 +407,7 @@ var oprange [ALAST]Oprang 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 @@ func span9(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func span9(ctxt *obj.Link, cursym *obj.LSym) { * 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 @@ func span9(ctxt *obj.Link, cursym *obj.LSym) { 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 isuint32(v uint64) bool { } 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 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int { case obj.NAME_EXTERN, obj.NAME_STATIC: - s = a.Sym + s := a.Sym if s == nil { break } @@ -720,18 +713,7 @@ func prasm(p *obj.Prog) { } 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 @@ func oplook(ctxt *obj.Link, p *obj.Prog) *Optab { } 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) Swap(i, j int) { } 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 (x ocmp) Less(i, j int) bool { } 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 @@ func buildop(ctxt *obj.Link) { 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 @@ func oclass(a *obj.Addr) int { // 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 @@ func addaddrreloc(ctxt *obj.Link, s *obj.LSym, o1 *uint32, o2 *uint32) { * 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 @@ func getmask(m []byte, v uint32) bool { return false } - for i = 0; i < 32; i++ { + for i := 0; i < 32; i++ { if v&(1<> 16) + v := int32(d >> 16) if isuint32(uint64(d)) { return LOP_IRR(OP_ORIS, uint32(r), REGZERO, uint32(v)) } @@ -1506,24 +1475,11 @@ func high16adjusted(d int32) uint16 { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { //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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { /*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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { //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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { } 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { /* 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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { //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 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) { //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 21a864255ba..6c62fad7a31 100644 --- a/src/cmd/internal/obj/ppc64/list9.go +++ b/src/cmd/internal/obj/ppc64/list9.go @@ -54,14 +54,9 @@ const ( 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 @@ func Pconv(p *obj.Prog) string { } 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 Rconv(r int) string { } 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 a507449eae4..f858bb30178 100644 --- a/src/cmd/internal/obj/ppc64/obj9.go +++ b/src/cmd/internal/obj/ppc64/obj9.go @@ -37,9 +37,6 @@ import ( ) 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { // 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 progedit(ctxt *obj.Link, p *obj.Prog) { } 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { } 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { } } - 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 preprocess(ctxt *obj.Link, cursym *obj.LSym) { } */ 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 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool) *obj. 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 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool) *obj. // 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 stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt bool) *obj. } 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 d22a3396ce7..80ef0bf64cb 100644 --- a/src/cmd/internal/obj/sym.go +++ b/src/cmd/internal/obj/sym.go @@ -123,8 +123,6 @@ func Headstr(v int) string { } func Linknew(arch *LinkArch) *Link { - var buf string - linksetexp() ctxt := new(Link) @@ -137,6 +135,7 @@ func Linknew(arch *LinkArch) *Link { 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 5af037f90f4..cb7d524c639 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -1492,16 +1492,6 @@ func spadjop(ctxt *obj.Link, p *obj.Prog, l int, q int) int { } 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 @@ func span6(ctxt *obj.Link, s *obj.LSym) { 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 @@ func span6(ctxt *obj.Link, s *obj.LSym) { } } - 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 @@ func span6(ctxt *obj.Link, s *obj.LSym) { } } - 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 @@ func span6(ctxt *obj.Link, s *obj.LSym) { 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 @@ func span6(ctxt *obj.Link, s *obj.LSym) { 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 span6(ctxt *obj.Link, s *obj.LSym) { 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 @@ func instinit() { 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 @@ func instinit() { 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 prefixof(ctxt *obj.Link, a *obj.Addr) int { } 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 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int { 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 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int { 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 put4(ctxt *obj.Link, v int32) { } 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 @@ relput8(Prog *p, Addr *a) } */ 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 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 { 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 vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 { } 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 @@ func asmandsz(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int) } 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 @@ func asmandsz(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int) 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 mediaop(ctxt *obj.Link, o *Optab, op int, osize int, z int) int { } 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 @@ func doasm(ctxt *obj.Link, p *obj.Prog) { 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 @@ bad: * 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 @@ bad: 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 nacltrunc(ctxt *obj.Link, reg int) { } 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 @@ func asmins(ctxt *obj.Link, p *obj.Prog) { } 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 @@ func asmins(ctxt *obj.Link, p *obj.Prog) { 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 @@ func asmins(ctxt *obj.Link, p *obj.Prog) { 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 41c69c901c4..b2a7a7a24ae 100644 --- a/src/cmd/internal/obj/x86/list6.go +++ b/src/cmd/internal/obj/x86/list6.go @@ -55,7 +55,6 @@ var bigP *obj.Prog func Pconv(p *obj.Prog) string { var str string - var fp string switch p.As { case obj.ADATA: @@ -84,6 +83,7 @@ func Pconv(p *obj.Prog) string { } } + 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 4cb2f45a584..81e4e0eeb59 100644 --- a/src/cmd/internal/obj/x86/obj6.go +++ b/src/cmd/internal/obj/x86/obj6.go @@ -49,10 +49,6 @@ func canuselocaltls(ctxt *obj.Link) bool { } 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { // 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 nacladdr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) { } 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { if q != nil { q.Pcond = p } - deltasp = autoffset + deltasp := autoffset if bpsize > 0 { // Save caller's BP @@ -486,7 +469,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) { 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 @@ func indir_cx(ctxt *obj.Link, a *obj.Addr) { // 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 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog { 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 @@ func load_g_cx(ctxt *obj.Link, p *obj.Prog) *obj.Prog { // 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 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, textarg int32, noc sub = ASUBL } - q1 = nil + q1 := (*obj.Prog)(nil) if framesize <= obj.StackSmall { // small stack: SP <= stackguard // CMPQ SP, stackguard @@ -845,7 +821,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, textarg int32, noc 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 stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, textarg int32, noc } 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