From 8b3670ffc6491ee54245e27f99b2415fbb1287d5 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Fri, 6 Mar 2015 12:02:24 -0800 Subject: [PATCH] cmd/internal/gc: remove namebuf variable namebuf was a global char buffer in the C version of gc, which was useful for providing common storage for constructing symbol and file names. However, now that it's just a global Go string and the string data is dynamically allocated anyway, it doesn't serve any purpose except to force extra write barriers everytime it's assigned to. Also, introduce Lookupf(fmt, args...) as shorthand for Lookup(fmt.Sprintf(fmt, args...)), which was a very common pattern for using namebuf. Passes "go build -toolexec 'toolstash -cmp' -a std". Notably, this CL shrinks 6g's text section by ~15kB: $ size toolstash/6g tool/linux_amd64/6g text data bss dec hex filename 4600805 605968 342988 5549761 54aec1 toolstash/6g 4585547 605968 342956 5534471 547307 tool/linux_amd64/6g Change-Id: I98abb44fc7f43a2e2e48425cc9f215cd0be37442 Reviewed-on: https://go-review.googlesource.com/7080 Reviewed-by: Ian Lance Taylor --- src/cmd/internal/gc/closure.go | 17 +++------ src/cmd/internal/gc/dcl.go | 7 +--- src/cmd/internal/gc/gen.go | 4 +- src/cmd/internal/gc/go.go | 2 - src/cmd/internal/gc/init.go | 16 ++------ src/cmd/internal/gc/inl.go | 9 ++--- src/cmd/internal/gc/lex.go | 67 ++++++++++++++++------------------ src/cmd/internal/gc/obj.go | 15 ++++---- src/cmd/internal/gc/pgen.go | 3 +- src/cmd/internal/gc/sinit.go | 3 +- src/cmd/internal/gc/subr.go | 4 ++ src/cmd/internal/gc/walk.go | 18 +++++---- 12 files changed, 70 insertions(+), 95 deletions(-) diff --git a/src/cmd/internal/gc/closure.go b/src/cmd/internal/gc/closure.go index 3155b69a21e..df895441625 100644 --- a/src/cmd/internal/gc/closure.go +++ b/src/cmd/internal/gc/closure.go @@ -174,8 +174,7 @@ func closurename(n *Node) *Sym { } else { Fatal("closurename called for %v", Nconv(n, obj.FmtShort)) } - namebuf = fmt.Sprintf("%s.%s%d", outer, prefix, gen) - n.Sym = Lookup(namebuf) + n.Sym = Lookupf("%s.%s%d", outer, prefix, gen) return n.Sym } @@ -333,9 +332,7 @@ func transformclosure(xfunc *Node) { // we introduce function param &v *T // and v remains PPARAMREF with &v heapaddr // (accesses will implicitly deref &v). - namebuf = fmt.Sprintf("&%s", v.Sym.Name) - - addr = newname(Lookup(namebuf)) + addr = newname(Lookupf("&%s", v.Sym.Name)) addr.Type = Ptrto(v.Type) addr.Class = PPARAM v.Heapaddr = addr @@ -397,9 +394,7 @@ func transformclosure(xfunc *Node) { } else { // Declare variable holding addresses taken from closure // and initialize in entry prologue. - namebuf = fmt.Sprintf("&%s", v.Sym.Name) - - addr = newname(Lookup(namebuf)) + addr = newname(Lookupf("&%s", v.Sym.Name)) addr.Ntype = Nod(OIND, typenod(v.Type), nil) addr.Class = PAUTO addr.Used = true @@ -557,9 +552,8 @@ func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node { var fld *Node var n *Node for t := getinargx(t0).Type; t != nil; t = t.Down { - namebuf = fmt.Sprintf("a%d", i) + n = newname(Lookupf("a%d", i)) i++ - n = newname(Lookup(namebuf)) n.Class = PPARAM xfunc.Dcl = list(xfunc.Dcl, n) callargs = list(callargs, n) @@ -577,9 +571,8 @@ func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node { l = nil var retargs *NodeList for t := getoutargx(t0).Type; t != nil; t = t.Down { - namebuf = fmt.Sprintf("r%d", i) + n = newname(Lookupf("r%d", i)) i++ - n = newname(Lookup(namebuf)) n.Class = PPARAMOUT xfunc.Dcl = list(xfunc.Dcl, n) retargs = list(retargs, n) diff --git a/src/cmd/internal/gc/dcl.go b/src/cmd/internal/gc/dcl.go index 7194c123a25..fa955ba929e 100644 --- a/src/cmd/internal/gc/dcl.go +++ b/src/cmd/internal/gc/dcl.go @@ -645,10 +645,8 @@ func funcargs(nt *Node) { if n.Left == nil { // Name so that escape analysis can track it. ~r stands for 'result'. - namebuf = fmt.Sprintf("~r%d", gen) + n.Left = newname(Lookupf("~r%d", gen)) gen++ - - n.Left = newname(Lookup(namebuf)) } // TODO: n->left->missing = 1; @@ -667,9 +665,8 @@ func funcargs(nt *Node) { *nn = *n.Left nn.Orig = nn - namebuf = fmt.Sprintf("~b%d", gen) + nn.Sym = Lookupf("~b%d", gen) gen++ - nn.Sym = Lookup(namebuf) n.Left = nn } diff --git a/src/cmd/internal/gc/gen.go b/src/cmd/internal/gc/gen.go index 70c218e667c..3777cc310de 100644 --- a/src/cmd/internal/gc/gen.go +++ b/src/cmd/internal/gc/gen.go @@ -590,10 +590,8 @@ func Tempname(nn *Node, t *Type) { // give each tmp a different name so that there // a chance to registerizer them - namebuf = fmt.Sprintf("autotmp_%.4d", statuniqgen) - + s := Lookupf("autotmp_%.4d", statuniqgen) statuniqgen++ - s := Lookup(namebuf) n := Nod(ONAME, nil, nil) n.Sym = s s.Def = n diff --git a/src/cmd/internal/gc/go.go b/src/cmd/internal/gc/go.go index 348dd833e03..e9412d1ff27 100644 --- a/src/cmd/internal/gc/go.go +++ b/src/cmd/internal/gc/go.go @@ -500,8 +500,6 @@ var safemode int var nolocalimports int -var namebuf string - var lexbuf bytes.Buffer var strbuf bytes.Buffer diff --git a/src/cmd/internal/gc/init.go b/src/cmd/internal/gc/init.go index c57e50b13dc..8aaed8c63c8 100644 --- a/src/cmd/internal/gc/init.go +++ b/src/cmd/internal/gc/init.go @@ -4,8 +4,6 @@ package gc -import "fmt" - // case OADD: // if(n->right->op == OLITERAL) { // v = n->right->vconst; @@ -31,8 +29,7 @@ var renameinit_initgen int func renameinit() *Sym { renameinit_initgen++ - namebuf = fmt.Sprintf("init.%d", renameinit_initgen) - return Lookup(namebuf) + return Lookupf("init.%d", renameinit_initgen) } /* @@ -112,18 +109,14 @@ func fninit(n *NodeList) { var r *NodeList // (1) - namebuf = "initdone·" - - gatevar := newname(Lookup(namebuf)) + gatevar := newname(Lookup("initdone·")) addvar(gatevar, Types[TUINT8], PEXTERN) // (2) Maxarg = 0 - namebuf = "init" - fn := Nod(ODCLFUNC, nil, nil) - initsym := Lookup(namebuf) + initsym := Lookup("init") fn.Nname = newname(initsym) fn.Nname.Defn = fn fn.Nname.Ntype = Nod(OTFUNC, nil, nil) @@ -169,8 +162,7 @@ func fninit(n *NodeList) { // (9) // could check that it is fn of no args/returns for i := 1; ; i++ { - namebuf = fmt.Sprintf("init.%d", i) - s := Lookup(namebuf) + s := Lookupf("init.%d", i) if s.Def == nil { break } diff --git a/src/cmd/internal/gc/inl.go b/src/cmd/internal/gc/inl.go index c266f7d7aa3..cdd709ed770 100644 --- a/src/cmd/internal/gc/inl.go +++ b/src/cmd/internal/gc/inl.go @@ -859,8 +859,7 @@ func inlvar(var_ *Node) *Node { // Synthesize a variable to store the inlined function's results in. func retvar(t *Type, i int) *Node { - namebuf = fmt.Sprintf("~r%d", i) - n := newname(Lookup(namebuf)) + n := newname(Lookupf("~r%d", i)) n.Type = t.Type n.Class = PAUTO n.Used = true @@ -872,8 +871,7 @@ func retvar(t *Type, i int) *Node { // Synthesize a variable to store the inlined function's arguments // when they come from a multiple return call. func argvar(t *Type, i int) *Node { - namebuf = fmt.Sprintf("~arg%d", i) - n := newname(Lookup(namebuf)) + n := newname(Lookupf("~arg%d", i)) n.Type = t.Type n.Class = PAUTO n.Used = true @@ -886,8 +884,7 @@ var newlabel_inl_label int func newlabel_inl() *Node { newlabel_inl_label++ - namebuf = fmt.Sprintf(".inlret%.6d", newlabel_inl_label) - n := newname(Lookup(namebuf)) + n := newname(Lookupf(".inlret%.6d", newlabel_inl_label)) n.Etype = 1 // flag 'safe' for escape analysis (no backjumps) return n } diff --git a/src/cmd/internal/gc/lex.go b/src/cmd/internal/gc/lex.go index 816e67e89a4..03e874929d6 100644 --- a/src/cmd/internal/gc/lex.go +++ b/src/cmd/internal/gc/lex.go @@ -559,25 +559,24 @@ func islocalname(name string) bool { strings.HasPrefix(name, "../") || name == ".." } -func findpkg(name string) bool { +func findpkg(name string) (file string, ok bool) { if islocalname(name) { if safemode != 0 || nolocalimports != 0 { - return false + return "", false } // try .a before .6. important for building libraries: // if there is an array.6 in the array.a library, // want to find all of array.a, not just array.6. - namebuf = fmt.Sprintf("%s.a", name) - - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s.a", name) + if obj.Access(file, 0) >= 0 { + return file, true } - namebuf = fmt.Sprintf("%s.%c", name, Thearch.Thechar) - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s.%c", name, Thearch.Thechar) + if obj.Access(file, 0) >= 0 { + return file, true } - return false + return "", false } // local imports should be canonicalized already. @@ -587,17 +586,17 @@ func findpkg(name string) bool { _ = q if path.Clean(name) != name { Yyerror("non-canonical import path %q (should be %q)", name, q) - return false + return "", false } for p := idirs; p != nil; p = p.link { - namebuf = fmt.Sprintf("%s/%s.a", p.dir, name) - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s/%s.a", p.dir, name) + if obj.Access(file, 0) >= 0 { + return file, true } - namebuf = fmt.Sprintf("%s/%s.%c", p.dir, name, Thearch.Thechar) - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s/%s.%c", p.dir, name, Thearch.Thechar) + if obj.Access(file, 0) >= 0 { + return file, true } } @@ -612,17 +611,17 @@ func findpkg(name string) bool { suffix = "race" } - namebuf = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", goroot, goos, goarch, suffixsep, suffix, name) - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.a", goroot, goos, goarch, suffixsep, suffix, name) + if obj.Access(file, 0) >= 0 { + return file, true } - namebuf = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.%c", goroot, goos, goarch, suffixsep, suffix, name, Thearch.Thechar) - if obj.Access(namebuf, 0) >= 0 { - return true + file = fmt.Sprintf("%s/pkg/%s_%s%s%s/%s.%c", goroot, goos, goarch, suffixsep, suffix, name, Thearch.Thechar) + if obj.Access(file, 0) >= 0 { + return file, true } } - return false + return "", false } func fakeimport() { @@ -698,7 +697,8 @@ func importfile(f *Val, line int) { } } - if !findpkg(path_) { + file, found := findpkg(path_) + if !found { Yyerror("can't find import: %q", f.U.Sval) errorexit() } @@ -708,7 +708,6 @@ func importfile(f *Val, line int) { // If we already saw that package, feed a dummy statement // to the lexer to avoid parsing export data twice. if importpkg.Imported != 0 { - file := namebuf tag := "" if importpkg.Safe { tag = "safe" @@ -723,16 +722,13 @@ func importfile(f *Val, line int) { var err error var imp *obj.Biobuf - imp, err = obj.Bopenr(namebuf) + imp, err = obj.Bopenr(file) if err != nil { Yyerror("can't open import: %q: %v", f.U.Sval, err) errorexit() } - file := namebuf - - n := len(namebuf) - if n > 2 && namebuf[n-2] == '.' && namebuf[n-1] == 'a' { + if strings.HasSuffix(file, ".a") { if !skiptopkgdef(imp) { Yyerror("import %s: not a package file", file) errorexit() @@ -757,7 +753,7 @@ func importfile(f *Val, line int) { // assume files move (get installed) // so don't record the full path. - linehist(file[n-len(path_)-2:], -1, 1) // acts as #pragma lib + linehist(file[len(file)-len(path_)-2:], -1, 1) // acts as #pragma lib /* * position the input right @@ -3162,10 +3158,9 @@ func mkpackage(pkgname string) { p = p[i+1:] } } - namebuf = p - if i := strings.LastIndex(namebuf, "."); i >= 0 { - namebuf = namebuf[:i] + if i := strings.LastIndex(p, "."); i >= 0 { + p = p[:i] } - outfile = fmt.Sprintf("%s.%c", namebuf, Thearch.Thechar) + outfile = fmt.Sprintf("%s.%c", p, Thearch.Thechar) } } diff --git a/src/cmd/internal/gc/obj.go b/src/cmd/internal/gc/obj.go index d59898f2861..077b89b500a 100644 --- a/src/cmd/internal/gc/obj.go +++ b/src/cmd/internal/gc/obj.go @@ -101,8 +101,8 @@ func dumpobj() { obj.Bputc(bout, 0) } obj.Bseek(bout, startobj-ArhdrSize, 0) - namebuf = fmt.Sprintf("_go_.%c", Thearch.Thechar) - formathdr(arhdr[:], namebuf, size) + name := fmt.Sprintf("_go_.%c", Thearch.Thechar) + formathdr(arhdr[:], name, size) obj.Bwrite(bout, arhdr[:]) } @@ -199,22 +199,23 @@ func duintptr(s *Sym, off int, v uint64) int { var stringsym_gen int func stringsym(s string) *Sym { + var symname string var pkg *Pkg if len(s) > 100 { // huge strings are made static to avoid long names stringsym_gen++ - namebuf = fmt.Sprintf(".gostring.%d", stringsym_gen) + symname = fmt.Sprintf(".gostring.%d", stringsym_gen) pkg = localpkg } else { // small strings get named by their contents, // so that multiple modules using the same string // can share it. - namebuf = fmt.Sprintf("%q", s) + symname = fmt.Sprintf("%q", s) pkg = gostringpkg } - sym := Pkglookup(namebuf, pkg) + sym := Pkglookup(symname, pkg) // SymUniq flag indicates that data is generated already if sym.Flags&SymUniq != 0 { @@ -252,8 +253,8 @@ func slicebytes(nam *Node, s string, len int) { var m int slicebytes_gen++ - namebuf = fmt.Sprintf(".gobytes.%d", slicebytes_gen) - sym := Pkglookup(namebuf, localpkg) + symname := fmt.Sprintf(".gobytes.%d", slicebytes_gen) + sym := Pkglookup(symname, localpkg) sym.Def = newname(sym) off := 0 diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go index 208ecb80ff0..06239048e2b 100644 --- a/src/cmd/internal/gc/pgen.go +++ b/src/cmd/internal/gc/pgen.go @@ -18,9 +18,8 @@ var makefuncdatasym_nsym int32 func makefuncdatasym(namefmt string, funcdatakind int64) *Sym { var nod Node - namebuf = fmt.Sprintf(namefmt, makefuncdatasym_nsym) + sym := Lookupf(namefmt, makefuncdatasym_nsym) makefuncdatasym_nsym++ - sym := Lookup(namebuf) pnod := newname(sym) pnod.Class = PEXTERN Nodconst(&nod, Types[TINT32], funcdatakind) diff --git a/src/cmd/internal/gc/sinit.go b/src/cmd/internal/gc/sinit.go index c5e006b160f..2dec7572bde 100644 --- a/src/cmd/internal/gc/sinit.go +++ b/src/cmd/internal/gc/sinit.go @@ -517,9 +517,8 @@ func staticassign(l *Node, r *Node, out **NodeList) bool { * part of the composite literal. */ func staticname(t *Type, ctxt int) *Node { - namebuf = fmt.Sprintf("statictmp_%.4d", statuniqgen) + n := newname(Lookupf("statictmp_%.4d", statuniqgen)) statuniqgen++ - n := newname(Lookup(namebuf)) if ctxt == 0 { n.Readonly = true } diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go index c59b7e6447e..f77d1511fce 100644 --- a/src/cmd/internal/gc/subr.go +++ b/src/cmd/internal/gc/subr.go @@ -281,6 +281,10 @@ func Lookup(name string) *Sym { return localpkg.Lookup(name) } +func Lookupf(format string, a ...interface{}) *Sym { + return Lookup(fmt.Sprintf(format, a...)) +} + func LookupBytes(name []byte) *Sym { return localpkg.LookupBytes(name) } diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go index e88b4c28b09..e4abc282c25 100644 --- a/src/cmd/internal/gc/walk.go +++ b/src/cmd/internal/gc/walk.go @@ -1109,17 +1109,18 @@ func walkexpr(np **Node, init **NodeList) { if Widthreg >= 8 || (et != TUINT64 && et != TINT64) { goto ret } + var fn string if et == TINT64 { - namebuf = "int64" + fn = "int64" } else { - namebuf = "uint64" + fn = "uint64" } if n.Op == ODIV { - namebuf += "div" + fn += "div" } else { - namebuf += "mod" + fn += "mod" } - n = mkcall(namebuf, n.Type, init, conv(n.Left, Types[et]), conv(n.Right, Types[et])) + n = mkcall(fn, n.Type, init, conv(n.Left, Types[et]), conv(n.Right, Types[et])) default: break @@ -2882,13 +2883,14 @@ func addstr(n *Node, init **NodeList) *Node { args = list(args, conv(l.N, Types[TSTRING])) } + var fn string if c <= 5 { // small numbers of strings use direct runtime helpers. // note: orderexpr knows this cutoff too. - namebuf = fmt.Sprintf("concatstring%d", c) + fn = fmt.Sprintf("concatstring%d", c) } else { // large numbers of strings are passed to the runtime as a slice. - namebuf = "concatstrings" + fn = "concatstrings" t := typ(TARRAY) t.Type = Types[TSTRING] @@ -2901,7 +2903,7 @@ func addstr(n *Node, init **NodeList) *Node { slice.Esc = EscNone } - cat := syslook(namebuf, 1) + cat := syslook(fn, 1) r := Nod(OCALL, cat, nil) r.List = args typecheck(&r, Erv)