Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
go/src/cmd/link/internal/ld/pcln.go

524 lines
13 KiB
Go
Raw Normal View History

all: make copyright headers consistent with one space after period This is a subset of https://golang.org/cl/20022 with only the copyright header lines, so the next CL will be smaller and more reviewable. Go policy has been single space after periods in comments for some time. The copyright header template at: https://golang.org/doc/contribute.html#copyright also uses a single space. Make them all consistent. Change-Id: Icc26c6b8495c3820da6b171ca96a74701b4a01b0 Reviewed-on: https://go-review.googlesource.com/20111 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-01 22:57:46 +00:00
// Copyright 2013 The Go Authors. All rights reserved.
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ld
import (
"cmd/internal/obj"
"log"
cmd/link: use current GOROOT for source file paths for standard library This CL changes the source file information in the standard library's .a files to say "$GOROOT/src/runtime/chan.go" (with a literal "$GOROOT") instead of spelling out the actual directory. The linker then substitutes the actual $GOROOT (or $GOROOT_FINAL) as appropriate. If people download a binary distribution to an alternate location, following the instructions at https://golang.org/doc/install#install, the code before this CL would end up with source paths pointing to /usr/local/go no matter where the actual sources were. Now the source paths for built binaries will point to the actual sources (hopefully). The source line information in distributed binaries is not affected: those will still say /usr/local/go. But binaries people build themselves (their own programs, not the go distribution programs) will be correct. Fixing this path also fixes the lookup of the runtime-gdb.py file. Fixes #5533. Change-Id: I03729baae3fbd8cd636e016275ee5ad2606e4663 Reviewed-on: https://go-review.googlesource.com/18200 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-12-29 10:16:40 -05:00
"os"
"path/filepath"
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
)
// iteration over encoded pcdata tables.
func getvarint(pp *[]byte) uint32 {
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
v := uint32(0)
p := *pp
for shift := 0; ; shift += 7 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
v |= uint32(p[0]&0x7F) << uint(shift)
tmp4 := p
p = p[1:]
if tmp4[0]&0x80 == 0 {
break
}
}
*pp = p
return v
}
func pciternext(it *Pciter) {
it.pc = it.nextpc
if it.done != 0 {
return
}
if -cap(it.p) >= -cap(it.d.P[len(it.d.P):]) {
it.done = 1
return
}
// value delta
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
v := getvarint(&it.p)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if v == 0 && it.start == 0 {
it.done = 1
return
}
it.start = 0
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
dv := int32(v>>1) ^ (int32(v<<31) >> 31)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
it.value += dv
// pc delta
v = getvarint(&it.p)
it.nextpc = it.pc + v*it.pcscale
}
func pciterinit(ctxt *Link, it *Pciter, d *Pcdata) {
it.d = *d
it.p = it.d.P
it.pc = 0
it.nextpc = 0
it.value = -1
it.start = 1
it.done = 0
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
it.pcscale = uint32(ctxt.Arch.MinLC)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
pciternext(it)
}
func addvarint(d *Pcdata, val uint32) {
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
n := int32(0)
for v := val; v >= 0x80; v >>= 7 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
n++
}
n++
old := len(d.P)
for cap(d.P) < len(d.P)+int(n) {
d.P = append(d.P[:cap(d.P)], 0)
}
d.P = d.P[:old+int(n)]
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
p := d.P[old:]
var v uint32
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
for v = val; v >= 0x80; v >>= 7 {
p[0] = byte(v | 0x80)
p = p[1:]
}
p[0] = byte(v)
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
func addpctab(ctxt *Link, ftab *Symbol, off int32, d *Pcdata) int32 {
cmd/link: record missing pcdata tables correctly The old code was recording the current table output offset, so the table from the next function would be used instead of the runtime realizing that there was no table at all. Add debug constant in runtime to check this for every function at startup. It's too expensive to do that by default, but we can do the last five functions. The end of the table is usually where the C symbols end up, so that's where the problems typically are. Fixes #10747. Fixes #11396. Change-Id: I13592e78017969fc22979fa902e19e1b151d41b1 Reviewed-on: https://go-review.googlesource.com/11657 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Russ Cox <rsc@golang.org>
2015-06-28 22:26:35 -04:00
var start int32
if len(d.P) > 0 {
start = int32(len(ftab.P))
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Addbytes(ftab, d.P)
cmd/link: record missing pcdata tables correctly The old code was recording the current table output offset, so the table from the next function would be used instead of the runtime realizing that there was no table at all. Add debug constant in runtime to check this for every function at startup. It's too expensive to do that by default, but we can do the last five functions. The end of the table is usually where the C symbols end up, so that's where the problems typically are. Fixes #10747. Fixes #11396. Change-Id: I13592e78017969fc22979fa902e19e1b151d41b1 Reviewed-on: https://go-review.googlesource.com/11657 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Russ Cox <rsc@golang.org>
2015-06-28 22:26:35 -04:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
return int32(setuint32(ctxt, ftab, int64(off), uint32(start)))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
func ftabaddstring(ctxt *Link, ftab *Symbol, s string) int32 {
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
n := int32(len(s)) + 1
start := int32(len(ftab.P))
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Symgrow(ftab, int64(start)+int64(n)+1)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
copy(ftab.P[start:], s)
return start
}
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
// numberfile assigns a file number to the file if it hasn't been assigned already.
func numberfile(ctxt *Link, file *Symbol) {
if file.Type != obj.SFILEPATH {
ctxt.Filesyms = append(ctxt.Filesyms, file)
file.Value = int64(len(ctxt.Filesyms))
file.Type = obj.SFILEPATH
cmd/internal/obj: avoid duplicate file name symbols The meaning of Version=1 was overloaded: it was reserved for file name symbols (to avoid conflicts with non-file name symbols), but was also used to mean "give me a fresh version number for this symbol." With the new inlining tree, the same file name symbol can appear in multiple entries, but each one would become a distinct symbol with its own version number. Now, we avoid duplicating symbols by using Version=0 for file name symbols and we avoid conflicts with other symbols by prefixing the symbol name with "gofile..". Change-Id: I8d0374053b8cdb6a9ca7fb71871b69b4dd369a9c Reviewed-on: https://go-review.googlesource.com/37234 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> Reviewed-by: Russ Cox <rsc@golang.org>
2017-02-17 16:20:52 -05:00
path := file.Name[len(obj.FileSymPrefix):]
file.Name = expandGoroot(path)
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
}
}
cmd/link/internal: rename LSym to Symbol, and add a doc comment. I'd also like to document some of its fields, but I don't know what they are. Change-Id: I87d341e255f785d351a8a73e645be668e02b2689 Reviewed-on: https://go-review.googlesource.com/27399 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-08-19 11:35:54 -04:00
func renumberfiles(ctxt *Link, files []*Symbol, d *Pcdata) {
var f *Symbol
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// Give files numbers.
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
for i := 0; i < len(files); i++ {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
f = files[i]
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
numberfile(ctxt, f)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
newval := int32(-1)
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev 796d0f2 on C->Go conversions. This replaces various awkward := initializations with plain var declarations. Checked bit-for-bit compatibility with toolstash + buildall. Change-Id: I601101d8177894adb9b0e3fb55dfe0ed4f544716 Reviewed-on: https://go-review.googlesource.com/6517 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2015-03-02 14:22:05 -05:00
var out Pcdata
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
var it Pciter
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
for pciterinit(ctxt, &it, d); it.done == 0; pciternext(&it) {
// value delta
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
oldval := it.value
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
var val int32
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if oldval == -1 {
val = -1
} else {
if oldval < 0 || oldval >= int32(len(files)) {
log.Fatalf("bad pcdata %d", oldval)
}
val = int32(files[oldval].Value)
}
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
dv := val - newval
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
newval = val
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
v := (uint32(dv) << 1) ^ uint32(dv>>31)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
addvarint(&out, v)
// pc delta
addvarint(&out, (it.nextpc-it.pc)/it.pcscale)
}
// terminating value delta
addvarint(&out, 0)
*d = out
}
cmd/link: do not export plugin C symbols Explicitly filter any C-only cgo functions out of pclntable, which allows them to be duplicated with the host binary. Updates #18190. Change-Id: I50d8706777a6133b3e95f696bc0bc586b84faa9e Reviewed-on: https://go-review.googlesource.com/34199 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-10 13:30:13 -05:00
// onlycsymbol reports whether this is a cgo symbol provided by the
// runtime and only used from C code.
func onlycsymbol(s *Symbol) bool {
switch s.Name {
case "_cgo_topofstack", "_cgo_panic", "crosscall2":
return true
}
return false
}
cmd/link/internal: rename LSym to Symbol, and add a doc comment. I'd also like to document some of its fields, but I don't know what they are. Change-Id: I87d341e255f785d351a8a73e645be668e02b2689 Reviewed-on: https://go-review.googlesource.com/27399 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-08-19 11:35:54 -04:00
func container(s *Symbol) int {
cmd/link: do not export plugin C symbols Explicitly filter any C-only cgo functions out of pclntable, which allows them to be duplicated with the host binary. Updates #18190. Change-Id: I50d8706777a6133b3e95f696bc0bc586b84faa9e Reviewed-on: https://go-review.googlesource.com/34199 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-10 13:30:13 -05:00
if s == nil {
return 0
}
cmd/link: only exclude C-only symbols on darwin C-only symbols are excluded from pclntab because of a quirk of darwin, where functions are referred to by an exported symbol so dynamic relocations de-duplicate to the host binary module and break unwinding. This doesn't happen on ELF systems because the linker always refers to unexported module-local symbols, so we don't need this condition. And the current logic for excluding some functions breaks the module verification code in moduledataverify1. So disable this for plugins on linux. (In 1.9, it will probably be necessary to introduce a module-local symbol reference system on darwin to fix a different bug, so all of this onlycsymbol code made be short-lived.) With this CL, the tests in CL 35116 pass. Change-Id: I517d7ca4427241fa0a91276c462827efb9383be9 Reviewed-on: https://go-review.googlesource.com/35190 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2017-01-12 17:35:53 -05:00
if Buildmode == BuildmodePlugin && Headtype == obj.Hdarwin && onlycsymbol(s) {
cmd/link: do not export plugin C symbols Explicitly filter any C-only cgo functions out of pclntable, which allows them to be duplicated with the host binary. Updates #18190. Change-Id: I50d8706777a6133b3e95f696bc0bc586b84faa9e Reviewed-on: https://go-review.googlesource.com/34199 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-10 13:30:13 -05:00
return 1
}
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// We want to generate func table entries only for the "lowest level" symbols,
// not containers of subsymbols.
cmd/link: do not export plugin C symbols Explicitly filter any C-only cgo functions out of pclntable, which allows them to be duplicated with the host binary. Updates #18190. Change-Id: I50d8706777a6133b3e95f696bc0bc586b84faa9e Reviewed-on: https://go-review.googlesource.com/34199 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-10 13:30:13 -05:00
if s.Type&obj.SCONTAINER != 0 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
return 1
}
return 0
}
// pclntab initializes the pclntab symbol with
// runtime function and file name information.
cmd/link/internal/ld: camelCase a buch of snake_case names I've also unexported a few symbols that weren't used outside the package. Updates #16818 Change-Id: I39d9d87b3eec30b88b4a17c1333cfbbfa6b3518f Reviewed-on: https://go-review.googlesource.com/27468 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-22 10:33:13 -04:00
var pclntabZpcln FuncInfo
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
runtime, cmd/internal/ld: rename themoduledata to firstmoduledata 'themoduledata' doesn't really make sense now we support multiple moduledata objects. Change-Id: I8263045d8f62a42cb523502b37289b0fba054f62 Reviewed-on: https://go-review.googlesource.com/8521 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2015-04-07 12:55:02 +12:00
// These variables are used to initialize runtime.firstmoduledata, see symtab.go:symtab.
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
var pclntabNfunc int32
var pclntabFiletabOffset int32
var pclntabPclntabOffset int32
cmd/link/internal: rename LSym to Symbol, and add a doc comment. I'd also like to document some of its fields, but I don't know what they are. Change-Id: I87d341e255f785d351a8a73e645be668e02b2689 Reviewed-on: https://go-review.googlesource.com/27399 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-08-19 11:35:54 -04:00
var pclntabFirstFunc *Symbol
var pclntabLastFunc *Symbol
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
func (ctxt *Link) pclntab() {
cmd/link/internal/ld: camelCase a buch of snake_case names I've also unexported a few symbols that weren't used outside the package. Updates #16818 Change-Id: I39d9d87b3eec30b88b4a17c1333cfbbfa6b3518f Reviewed-on: https://go-review.googlesource.com/27468 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-22 10:33:13 -04:00
funcdataBytes := int64(0)
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same Done with two eg templates: package p import ( "cmd/link/internal/ld" ) func before(ctxt *ld.Link, name string, v int) *ld.Symbol { return ld.Linklookup(ctxt, name, v) } func after(ctxt *ld.Link, name string, v int) *ld.Symbol { return ctxt.Syms.Lookup(name, v) } package p import ( "cmd/link/internal/ld" ) func before(ctxt *ld.Link, name string, v int) *ld.Symbol { return ld.Linkrlookup(ctxt, name, v) } func after(ctxt *ld.Link, name string, v int) *ld.Symbol { return ctxt.Syms.ROLookup(name, v) } Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1 Reviewed-on: https://go-review.googlesource.com/29343 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
ftab := ctxt.Syms.Lookup("runtime.pclntab", 0)
cmd/internal/ld: prefer constants from cmd/internal/obj The majority of this CL was prepared via scripted invocations of `gofmt -w -r "$SYM -> obj.$SYM" cmd/internal/ld/*.go` and `gofmt -w -r "ld.$SYM -> obj.$SYM" cmd/?l/*.go`. Because of issue #7417, that was followed by repeatedly running an AWK script to identify lines that differed other than whitespace changes or "ld." or "obj." prefixes and manually restoring comments. Finally, the redundant constants from cmd/internal/ld/link.go were removed, and "goimports -w" was used to cleanup import lines. Passes rsc.io/toolstash/buildall, even when modified to also build cmd. Fixes #10055. Change-Id: Icd5dbe819a3b6520ce883748e60017dc8e9a2e85 Reviewed-on: https://go-review.googlesource.com/9112 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-04-19 19:33:58 -07:00
ftab.Type = obj.SPCLNTAB
cmd/link: pack LSym boolean attributes No performance improvement, but possibly more readable. Linking juju: tip: real 0m5.470s user 0m6.131s this: real 0m5.392s user 0m6.087s Change-Id: I578e94fbe6c11b19d79034c33b3db31d9689d439 Reviewed-on: https://go-review.googlesource.com/20108 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: David Crawshaw <crawshaw@golang.org>
2016-03-02 07:59:49 -05:00
ftab.Attr |= AttrReachable
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// See golang.org/s/go12symtab for the format. Briefly:
// 8-byte header
// nfunc [thearch.ptrsize bytes]
// 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]
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
nfunc := int32(0)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link/internal/ld: exclude only real container symbols from symtab It looks like the test for whether symbols contain subsymbols is wrong. In particular, symbols in C libraries are mistakenly considered container symbols. Fix the test so only symbols which actually have a subsymbol are excluded from the symtab. When linking cgo programs the list of containers is small, something like: container _/home/khr/sandbox/symtab/misc/cgo/test(.text)<74> container _/home/khr/sandbox/symtab/misc/cgo/test/issue8828(.text)<75> container _/home/khr/sandbox/symtab/misc/cgo/test/issue9026(.text)<76> container runtime/cgo(.text)<77> I'm not sure this is the right fix. In particular I can't reproduce the original problem. Anyone have a repro they can try and see if this fix works? Fixes #10747 Fixes #11396 Change-Id: Id8b016389d33348b4a791fdcba0f9db8ae71ebf3 Reviewed-on: https://go-review.googlesource.com/11652 Reviewed-by: Russ Cox <rsc@golang.org>
2015-06-27 12:57:06 -07:00
// Find container symbols, mark them with SCONTAINER
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for _, s := range ctxt.Textp {
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
if s.Outer != nil {
s.Outer.Type |= obj.SCONTAINER
cmd/link/internal/ld: exclude only real container symbols from symtab It looks like the test for whether symbols contain subsymbols is wrong. In particular, symbols in C libraries are mistakenly considered container symbols. Fix the test so only symbols which actually have a subsymbol are excluded from the symtab. When linking cgo programs the list of containers is small, something like: container _/home/khr/sandbox/symtab/misc/cgo/test(.text)<74> container _/home/khr/sandbox/symtab/misc/cgo/test/issue8828(.text)<75> container _/home/khr/sandbox/symtab/misc/cgo/test/issue9026(.text)<76> container runtime/cgo(.text)<77> I'm not sure this is the right fix. In particular I can't reproduce the original problem. Anyone have a repro they can try and see if this fix works? Fixes #10747 Fixes #11396 Change-Id: Id8b016389d33348b4a791fdcba0f9db8ae71ebf3 Reviewed-on: https://go-review.googlesource.com/11652 Reviewed-by: Russ Cox <rsc@golang.org>
2015-06-27 12:57:06 -07:00
}
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for _, s := range ctxt.Textp {
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
if container(s) == 0 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
nfunc++
}
}
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
pclntabNfunc = nfunc
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Symgrow(ftab, 8+int64(SysArch.PtrSize)+int64(nfunc)*2*int64(SysArch.PtrSize)+int64(SysArch.PtrSize)+4)
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuint32(ctxt, ftab, 0, 0xfffffffb)
setuint8(ctxt, ftab, 6, uint8(SysArch.MinLC))
setuint8(ctxt, ftab, 7, uint8(SysArch.PtrSize))
setuintxx(ctxt, ftab, 8, uint64(nfunc), int64(SysArch.PtrSize))
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
pclntabPclntabOffset = int32(8 + SysArch.PtrSize)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
funcnameoff := make(map[string]int32)
nameToOffset := func(name string) int32 {
nameoff, ok := funcnameoff[name]
if !ok {
nameoff = ftabaddstring(ctxt, ftab, name)
funcnameoff[name] = nameoff
}
return nameoff
}
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
nfunc = 0
cmd/link/internal: rename LSym to Symbol, and add a doc comment. I'd also like to document some of its fields, but I don't know what they are. Change-Id: I87d341e255f785d351a8a73e645be668e02b2689 Reviewed-on: https://go-review.googlesource.com/27399 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-08-19 11:35:54 -04:00
var last *Symbol
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
for _, s := range ctxt.Textp {
last = s
if container(s) != 0 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
continue
}
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
pcln := s.FuncInfo
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if pcln == nil {
cmd/link/internal/ld: camelCase a buch of snake_case names I've also unexported a few symbols that weren't used outside the package. Updates #16818 Change-Id: I39d9d87b3eec30b88b4a17c1333cfbbfa6b3518f Reviewed-on: https://go-review.googlesource.com/27468 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-22 10:33:13 -04:00
pcln = &pclntabZpcln
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
if pclntabFirstFunc == nil {
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
pclntabFirstFunc = s
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
}
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
if len(pcln.InlTree) > 0 {
if len(pcln.Pcdata) <= obj.PCDATA_InlTreeIndex {
// Create inlining pcdata table.
pcdata := make([]Pcdata, obj.PCDATA_InlTreeIndex+1)
copy(pcdata, pcln.Pcdata)
pcln.Pcdata = pcdata
}
if len(pcln.Funcdataoff) <= obj.FUNCDATA_InlTree {
// Create inline tree funcdata.
funcdata := make([]*Symbol, obj.FUNCDATA_InlTree+1)
funcdataoff := make([]int64, obj.FUNCDATA_InlTree+1)
copy(funcdata, pcln.Funcdata)
copy(funcdataoff, pcln.Funcdataoff)
pcln.Funcdata = funcdata
pcln.Funcdataoff = funcdataoff
}
}
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
funcstart := int32(len(ftab.P))
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
funcstart += int32(-len(ftab.P)) & (int32(SysArch.PtrSize) - 1)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
setaddr(ctxt, ftab, 8+int64(SysArch.PtrSize)+int64(nfunc)*2*int64(SysArch.PtrSize), s)
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuintxx(ctxt, ftab, 8+int64(SysArch.PtrSize)+int64(nfunc)*2*int64(SysArch.PtrSize)+int64(SysArch.PtrSize), uint64(funcstart), int64(SysArch.PtrSize))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
runtime: cross-reference _func type better It takes me several minutes every time I want to find where the linker writes out the _func structures. Add some comments to make this easier. Change-Id: Ic75ce2786ca4b25726babe3c4fe9cd30c85c34e2 Reviewed-on: https://go-review.googlesource.com/34390 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-14 13:24:21 -05:00
// Write runtime._func. Keep in sync with ../../../../runtime/runtime2.go:/_func
// and package debug/gosym.
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// fixed size of struct, checked below
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
off := funcstart
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
end := funcstart + int32(SysArch.PtrSize) + 3*4 + 5*4 + int32(len(pcln.Pcdata))*4 + int32(len(pcln.Funcdata))*int32(SysArch.PtrSize)
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
if len(pcln.Funcdata) > 0 && (end&int32(SysArch.PtrSize-1) != 0) {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
end += 4
}
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Symgrow(ftab, int64(end))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// entry uintptr
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
off = int32(setaddr(ctxt, ftab, int64(off), s))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// name int32
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
nameoff := nameToOffset(s.Name)
off = int32(setuint32(ctxt, ftab, int64(off), uint32(nameoff)))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// args int32
// TODO: Move into funcinfo.
cmd/link: move function only lsym fields to pcln struct name old secs new secs delta LinkCmdGo 0.53 ± 9% 0.53 ±10% -1.30% (p=0.022 n=100+99) name old MaxRSS new MaxRSS delta LinkCmdGo 151k ± 4% 142k ± 6% -5.92% (p=0.000 n=98+100) Change-Id: Ic30e63a948f8e626b3396f458a0163f7234810c1 Reviewed-on: https://go-review.googlesource.com/21920 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-04-11 22:19:34 +03:00
args := uint32(0)
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
if s.FuncInfo != nil {
args = uint32(s.FuncInfo.Args)
cmd/link: move function only lsym fields to pcln struct name old secs new secs delta LinkCmdGo 0.53 ± 9% 0.53 ±10% -1.30% (p=0.022 n=100+99) name old MaxRSS new MaxRSS delta LinkCmdGo 151k ± 4% 142k ± 6% -5.92% (p=0.000 n=98+100) Change-Id: Ic30e63a948f8e626b3396f458a0163f7234810c1 Reviewed-on: https://go-review.googlesource.com/21920 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-04-11 22:19:34 +03:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
off = int32(setuint32(ctxt, ftab, int64(off), args))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// frame int32
runtime: poison pcln.frame value Nothing uses it, nothing should start using it. Stop leaving plausible-looking values there. It would be nice to remove entirely, but that would require a new version number for the object file format, in order not to break external readers like debug/gosym. It's easier to leave and poison. I came across an old mail thread suggesting we start using it to speed up tracebacks. I want to make sure that doesn't happen. (The values there were never quite right, and the number is fundamentally PC-specific anyway.) Change-Id: Iaf38e8a6b523cbae30b69c28497c4588ef397519 Reviewed-on: https://go-review.googlesource.com/6890 Reviewed-by: Minux Ma <minux@golang.org>
2015-03-04 16:50:59 -05:00
// This has been removed (it was never set quite correctly anyway).
// Nothing should use it.
// Leave an obviously incorrect value.
// TODO: Remove entirely.
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
off = int32(setuint32(ctxt, ftab, int64(off), 0x1234567))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link/internal/ld: camelCase a buch of snake_case names I've also unexported a few symbols that weren't used outside the package. Updates #16818 Change-Id: I39d9d87b3eec30b88b4a17c1333cfbbfa6b3518f Reviewed-on: https://go-review.googlesource.com/27468 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-22 10:33:13 -04:00
if pcln != &pclntabZpcln {
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
renumberfiles(ctxt, pcln.File, &pcln.Pcfile)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if false {
// Sanity check the new numbering
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
var it Pciter
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for pciterinit(ctxt, &it, &pcln.Pcfile); it.done == 0; pciternext(&it) {
if it.value < 1 || it.value > int32(len(ctxt.Filesyms)) {
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
Errorf(s, "bad file number in pcfile: %d not in range [1, %d]\n", it.value, len(ctxt.Filesyms))
cmd/internal/ld: replace Diag;Errorexit with Exitf I have left the Diag calls in place where I believe Ctxt.Cursym != nil which means this CL is not the improvement I had hoped for. However it is now safe to call Exitf whereever you are in the linker, which makes it easier to reason about some code. Change-Id: I8261e761ca9719f7d216e2747314adfe464e3337 Reviewed-on: https://go-review.googlesource.com/8668 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2015-04-09 07:37:17 -04:00
errorexit()
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
}
}
}
cmd/compile,link: generate PC-value tables with inlining information In order to generate accurate tracebacks, the runtime needs to know the inlined call stack for a given PC. This creates two tables per function for this purpose. The first table is the inlining tree (stored in the function's funcdata), which has a node containing the file, line, and function name for every inlined call. The second table is a PC-value table that maps each PC to a node in the inlining tree (or -1 if the PC is not the result of inlining). To give the appearance that inlining hasn't happened, the runtime also needs the original source position information of inlined AST nodes. Previously the compiler plastered over the line numbers of inlined AST nodes with the line number of the call. This meant that the PC-line table mapped each PC to line number of the outermost call in its inlined call stack, with no way to access the innermost line number. Now the compiler retains line numbers of inlined AST nodes and writes the innermost source position information to the PC-line and PC-file tables. Some tools and tests expect to see outermost line numbers, so we provide the OutermostLine function for displaying line info. To keep track of the inlined call stack for an AST node, we extend the src.PosBase type with an index into a global inlining tree. Every time the compiler inlines a call, it creates a node in the global inlining tree for the call, and writes its index to the PosBase of every inlined AST node. The parent of this node is the inlining tree index of the call. -1 signifies no parent. For each function, the compiler creates a local inlining tree and a PC-value table mapping each PC to an index in the local tree. These are written to an object file, which is read by the linker. The linker re-encodes these tables compactly by deduplicating function names and file names. This change increases the size of binaries by 4-5%. For example, this is how the go1 benchmark binary is impacted by this change: section old bytes new bytes delta .text 3.49M ± 0% 3.49M ± 0% +0.06% .rodata 1.12M ± 0% 1.21M ± 0% +8.21% .gopclntab 1.50M ± 0% 1.68M ± 0% +11.89% .debug_line 338k ± 0% 435k ± 0% +28.78% Total 9.21M ± 0% 9.58M ± 0% +4.01% Updates #19348. Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3 Reviewed-on: https://go-review.googlesource.com/37231 Run-TryBot: David Lazar <lazard@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-02-17 12:28:05 -05:00
if len(pcln.InlTree) > 0 {
inlTreeSym := ctxt.Syms.Lookup("inltree."+s.Name, 0)
inlTreeSym.Type = obj.SRODATA
inlTreeSym.Attr |= AttrReachable | AttrDuplicateOK
for i, call := range pcln.InlTree {
// Usually, call.File is already numbered since the file
// shows up in the Pcfile table. However, two inlined calls
// might overlap exactly so that only the innermost file
// appears in the Pcfile table. In that case, this assigns
// the outer file a number.
numberfile(ctxt, call.File)
nameoff := nameToOffset(call.Func.Name)
setuint32(ctxt, inlTreeSym, int64(i*16+0), uint32(call.Parent))
setuint32(ctxt, inlTreeSym, int64(i*16+4), uint32(call.File.Value))
setuint32(ctxt, inlTreeSym, int64(i*16+8), uint32(call.Line))
setuint32(ctxt, inlTreeSym, int64(i*16+12), uint32(nameoff))
}
pcln.Funcdata[obj.FUNCDATA_InlTree] = inlTreeSym
pcln.Pcdata[obj.PCDATA_InlTreeIndex] = pcln.Pcinline
}
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// pcdata
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
off = addpctab(ctxt, ftab, off, &pcln.Pcsp)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
off = addpctab(ctxt, ftab, off, &pcln.Pcfile)
off = addpctab(ctxt, ftab, off, &pcln.Pcline)
off = int32(setuint32(ctxt, ftab, int64(off), uint32(len(pcln.Pcdata))))
off = int32(setuint32(ctxt, ftab, int64(off), uint32(len(pcln.Funcdata))))
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
for i := 0; i < len(pcln.Pcdata); i++ {
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
off = addpctab(ctxt, ftab, off, &pcln.Pcdata[i])
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
// funcdata, must be pointer-aligned and we're only int32-aligned.
// Missing funcdata will be 0 (nil pointer).
cmd/link: Clean up Pcln struct Removes unnecessary fields from Pcln. Change-Id: I175049ca749b510eedaf65162355bc4d7a93315e Reviewed-on: https://go-review.googlesource.com/21041 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-03-23 14:02:36 +02:00
if len(pcln.Funcdata) > 0 {
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
if off&int32(SysArch.PtrSize-1) != 0 {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
off += 4
}
cmd/link: move pcln declarations into loops (Split out from CL 22243.) Change-Id: Idac1748c8db2b2ed0484e4afadb105c471c6ce34 Reviewed-on: https://go-review.googlesource.com/22321 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 14:22:20 -04:00
for i := 0; i < len(pcln.Funcdata); i++ {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if pcln.Funcdata[i] == nil {
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuintxx(ctxt, ftab, int64(off)+int64(SysArch.PtrSize)*int64(i), uint64(pcln.Funcdataoff[i]), int64(SysArch.PtrSize))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
} else {
// TODO: Dedup.
cmd/link/internal/ld: camelCase a buch of snake_case names I've also unexported a few symbols that weren't used outside the package. Updates #16818 Change-Id: I39d9d87b3eec30b88b4a17c1333cfbbfa6b3518f Reviewed-on: https://go-review.googlesource.com/27468 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-22 10:33:13 -04:00
funcdataBytes += pcln.Funcdata[i].Size
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setaddrplus(ctxt, ftab, int64(off)+int64(SysArch.PtrSize)*int64(i), pcln.Funcdata[i], pcln.Funcdataoff[i])
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
}
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
off += int32(len(pcln.Funcdata)) * int32(SysArch.PtrSize)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
if off != end {
cmd/link: remove Cursym Change-Id: I58253a6cd2d77a9319c0783afb0d92cd5a88a7f7 Reviewed-on: https://go-review.googlesource.com/29370 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-09-17 10:01:17 -04:00
Errorf(s, "bad math in functab: funcstart=%d off=%d but end=%d (npcdata=%d nfuncdata=%d ptrsize=%d)", funcstart, off, end, len(pcln.Pcdata), len(pcln.Funcdata), SysArch.PtrSize)
cmd/internal/ld: replace Diag;Errorexit with Exitf I have left the Diag calls in place where I believe Ctxt.Cursym != nil which means this CL is not the improvement I had hoped for. However it is now safe to call Exitf whereever you are in the linker, which makes it easier to reason about some code. Change-Id: I8261e761ca9719f7d216e2747314adfe464e3337 Reviewed-on: https://go-review.googlesource.com/8668 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2015-04-09 07:37:17 -04:00
errorexit()
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
nfunc++
}
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
pclntabLastFunc = last
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// Final entry of table is just end pc.
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setaddrplus(ctxt, ftab, 8+int64(SysArch.PtrSize)+int64(nfunc)*2*int64(SysArch.PtrSize), last, last.Size)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// Start file table.
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
start := int32(len(ftab.P))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd: add new common architecture representation Information about CPU architectures (e.g., name, family, byte ordering, pointer and register size) is currently redundantly scattered around the source tree. Instead consolidate the basic information into a single new package cmd/internal/sys. Also, introduce new sys.I386, sys.AMD64, etc. names for the constants '8', '6', etc. and replace most uses of the latter. The notable exceptions are a couple of error messages that still refer to the old char-based toolchain names and function reltype in cmd/link. Passes toolstash/buildall. Change-Id: I8a6f0cbd49577ec1672a98addebc45f767e36461 Reviewed-on: https://go-review.googlesource.com/21623 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-06 12:01:40 -07:00
start += int32(-len(ftab.P)) & (int32(SysArch.PtrSize) - 1)
runtime, cmd/internal/ld: initialize themoduledata slices directly This CL is quite conservative in some ways. It continues to define symbols that have no real purpose (e.g. epclntab). These could be deleted if there is no concern that external tools might look for them. It would also now be possible to make some changes to the pcln data but I get the impression that would definitely require some thought and discussion. Change-Id: Ib33cde07e4ec38ecc1d6c319a10138c9347933a3 Reviewed-on: https://go-review.googlesource.com/7616 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-16 11:53:08 +13:00
pclntabFiletabOffset = start
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuint32(ctxt, ftab, 8+int64(SysArch.PtrSize)+int64(nfunc)*2*int64(SysArch.PtrSize)+int64(SysArch.PtrSize), uint32(start))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Symgrow(ftab, int64(start)+(int64(len(ctxt.Filesyms))+1)*4)
cmd/link: fix number-of-files entry in gopclntab According to golang.org/s/go12symtab, for N files, it should put N+1 there. Fixes #17132. Change-Id: I0c84136855c6436be72b9d3c407bf10d4c81a099 Reviewed-on: https://go-review.googlesource.com/29275 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-09-15 19:52:40 -04:00
setuint32(ctxt, ftab, int64(start), uint32(len(ctxt.Filesyms)+1))
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for i := len(ctxt.Filesyms) - 1; i >= 0; i-- {
s := ctxt.Filesyms[i]
setuint32(ctxt, ftab, int64(start)+s.Value*4, uint32(ftabaddstring(ctxt, ftab, s.Name)))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
ftab.Size = int64(len(ftab.P))
cmd/link: use standard library flag package where possible The obj library's flag functions are (mostly) light wrappers around the standard library flag package. Use the flag package directly where possible. Most uses of the 'count'-type flags (except for -v) only check against 0, so they can safely be replaced by bools. Only -v and the flagfns haven't been replaced. Debug has been turned into a slice of bools rather than ints. There was a copy of the -v verbosity in ctxt.Debugvlog, so don't use Debug['v'] and just use ctxt.Debugvlog. Updates #16818 Change-Id: Icf6473a4823c9d35513bbd0c34ea02d5676d782a Reviewed-on: https://go-review.googlesource.com/27471 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-08-21 18:25:28 -04:00
if ctxt.Debugvlog != 0 {
cmd/link/internal, cmd/internal/obj: introduce ctxt.Logf Replace the various calls to Fprintf(ctxt.Bso, ...) with a helper, ctxt.Logf. This also addresses the various inconsistent flushing of ctxt.Bso. Because we have two Link structures, add Link.Logf in both places. Change-Id: I23093f9b9b3bf33089a0ffd7f815f92dcd1a1fa1 Reviewed-on: https://go-review.googlesource.com/27730 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-25 12:32:42 +10:00
ctxt.Logf("%5.2f pclntab=%d bytes, funcdata total %d bytes\n", obj.Cputime(), ftab.Size, funcdataBytes)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
}
cmd/link: use current GOROOT for source file paths for standard library This CL changes the source file information in the standard library's .a files to say "$GOROOT/src/runtime/chan.go" (with a literal "$GOROOT") instead of spelling out the actual directory. The linker then substitutes the actual $GOROOT (or $GOROOT_FINAL) as appropriate. If people download a binary distribution to an alternate location, following the instructions at https://golang.org/doc/install#install, the code before this CL would end up with source paths pointing to /usr/local/go no matter where the actual sources were. Now the source paths for built binaries will point to the actual sources (hopefully). The source line information in distributed binaries is not affected: those will still say /usr/local/go. But binaries people build themselves (their own programs, not the go distribution programs) will be correct. Fixing this path also fixes the lookup of the runtime-gdb.py file. Fixes #5533. Change-Id: I03729baae3fbd8cd636e016275ee5ad2606e4663 Reviewed-on: https://go-review.googlesource.com/18200 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-12-29 10:16:40 -05:00
func expandGoroot(s string) string {
const n = len("$GOROOT")
if len(s) >= n+1 && s[:n] == "$GOROOT" && (s[n] == '/' || s[n] == '\\') {
cmd: use obj.GOOS, obj.GOARCH, etc As cmd/internal/obj is coordinating the definition of GOOS, GOARCH, etc across the compiler and linker, turn its functions into globals and use them everywhere. Change-Id: I5db5addda3c6b6435c37fd5581c7c3d9a561f492 Reviewed-on: https://go-review.googlesource.com/28854 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-09-09 08:13:16 -04:00
root := obj.GOROOT
cmd/link: use current GOROOT for source file paths for standard library This CL changes the source file information in the standard library's .a files to say "$GOROOT/src/runtime/chan.go" (with a literal "$GOROOT") instead of spelling out the actual directory. The linker then substitutes the actual $GOROOT (or $GOROOT_FINAL) as appropriate. If people download a binary distribution to an alternate location, following the instructions at https://golang.org/doc/install#install, the code before this CL would end up with source paths pointing to /usr/local/go no matter where the actual sources were. Now the source paths for built binaries will point to the actual sources (hopefully). The source line information in distributed binaries is not affected: those will still say /usr/local/go. But binaries people build themselves (their own programs, not the go distribution programs) will be correct. Fixing this path also fixes the lookup of the runtime-gdb.py file. Fixes #5533. Change-Id: I03729baae3fbd8cd636e016275ee5ad2606e4663 Reviewed-on: https://go-review.googlesource.com/18200 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-12-29 10:16:40 -05:00
if final := os.Getenv("GOROOT_FINAL"); final != "" {
root = final
}
return filepath.ToSlash(filepath.Join(root, s[n:]))
}
return s
}
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
const (
BUCKETSIZE = 256 * MINFUNC
SUBBUCKETS = 16
SUBBUCKETSIZE = BUCKETSIZE / SUBBUCKETS
NOIDX = 0x7fffffff
)
// findfunctab generates a lookup table to quickly find the containing
all: single space after period. The tree's pretty inconsistent about single space vs double space after a period in documentation. Make it consistently a single space, per earlier decisions. This means contributors won't be confused by misleading precedence. This CL doesn't use go/doc to parse. It only addresses // comments. It was generated with: $ perl -i -npe 's,^(\s*// .+[a-z]\.) +([A-Z]),$1 $2,' $(git grep -l -E '^\s*//(.+\.) +([A-Z])') $ go test go/doc -update Change-Id: Iccdb99c37c797ef1f804a94b22ba5ee4b500c4f7 Reviewed-on: https://go-review.googlesource.com/20022 Reviewed-by: Rob Pike <r@golang.org> Reviewed-by: Dave Day <djd@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-01 23:21:55 +00:00
// function for a pc. See src/runtime/symtab.go:findfunc for details.
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
func (ctxt *Link) findfunctab() {
cmd/link: use ctxt.{Lookup,ROLookup} in favour of function versions of same Done with two eg templates: package p import ( "cmd/link/internal/ld" ) func before(ctxt *ld.Link, name string, v int) *ld.Symbol { return ld.Linklookup(ctxt, name, v) } func after(ctxt *ld.Link, name string, v int) *ld.Symbol { return ctxt.Syms.Lookup(name, v) } package p import ( "cmd/link/internal/ld" ) func before(ctxt *ld.Link, name string, v int) *ld.Symbol { return ld.Linkrlookup(ctxt, name, v) } func after(ctxt *ld.Link, name string, v int) *ld.Symbol { return ctxt.Syms.ROLookup(name, v) } Change-Id: I00647dbf62294557bd24c29ad1f108fc786335f1 Reviewed-on: https://go-review.googlesource.com/29343 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:06:08 +12:00
t := ctxt.Syms.Lookup("runtime.findfunctab", 0)
cmd/internal/ld: prefer constants from cmd/internal/obj The majority of this CL was prepared via scripted invocations of `gofmt -w -r "$SYM -> obj.$SYM" cmd/internal/ld/*.go` and `gofmt -w -r "ld.$SYM -> obj.$SYM" cmd/?l/*.go`. Because of issue #7417, that was followed by repeatedly running an AWK script to identify lines that differed other than whitespace changes or "ld." or "obj." prefixes and manually restoring comments. Finally, the redundant constants from cmd/internal/ld/link.go were removed, and "goimports -w" was used to cleanup import lines. Passes rsc.io/toolstash/buildall, even when modified to also build cmd. Fixes #10055. Change-Id: Icd5dbe819a3b6520ce883748e60017dc8e9a2e85 Reviewed-on: https://go-review.googlesource.com/9112 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-04-19 19:33:58 -07:00
t.Type = obj.SRODATA
cmd/link: pack LSym boolean attributes No performance improvement, but possibly more readable. Linking juju: tip: real 0m5.470s user 0m6.131s this: real 0m5.392s user 0m6.087s Change-Id: I578e94fbe6c11b19d79034c33b3db31d9689d439 Reviewed-on: https://go-review.googlesource.com/20108 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: David Crawshaw <crawshaw@golang.org>
2016-03-02 07:59:49 -05:00
t.Attr |= AttrReachable
t.Attr |= AttrLocal
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// find min and max address
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
min := ctxt.Textp[0].Value
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
max := int64(0)
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for _, s := range ctxt.Textp {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
max = s.Value + s.Size
}
// for each subbucket, compute the minimum of all symbol indexes
// that map to that subbucket.
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
n := int32((max - min + SUBBUCKETSIZE - 1) / SUBBUCKETSIZE)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
indexes := make([]int32, n)
for i := int32(0); i < n; i++ {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
indexes[i] = NOIDX
}
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
idx := int32(0)
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for i, s := range ctxt.Textp {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if container(s) != 0 {
continue
}
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
p := s.Value
cmd/link/internal: rename LSym to Symbol, and add a doc comment. I'd also like to document some of its fields, but I don't know what they are. Change-Id: I87d341e255f785d351a8a73e645be668e02b2689 Reviewed-on: https://go-review.googlesource.com/27399 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-08-19 11:35:54 -04:00
var e *Symbol
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
i++
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
if i < len(ctxt.Textp) {
e = ctxt.Textp[i]
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
for container(e) != 0 && i < len(ctxt.Textp) {
e = ctxt.Textp[i]
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
i++
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
q := max
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if e != nil {
q = e.Value
}
//print("%d: [%lld %lld] %s\n", idx, p, q, s->name);
for ; p < q; p += SUBBUCKETSIZE {
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
i = int((p - min) / SUBBUCKETSIZE)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if indexes[i] > idx {
indexes[i] = idx
}
}
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
i = int((q - 1 - min) / SUBBUCKETSIZE)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if indexes[i] > idx {
indexes[i] = idx
}
idx++
}
// allocate table
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
nbuckets := int32((max - min + BUCKETSIZE - 1) / BUCKETSIZE)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
cmd/link: remove now-unused ctxt arguments from a few functions Specifically Addstring, Addbytes and Symgrow. Change-Id: Ia74093bfcf9f360bf223accbc8feef54a7f059c9 Reviewed-on: https://go-review.googlesource.com/29348 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-09-20 15:31:26 +12:00
Symgrow(t, 4*int64(nbuckets)+int64(n))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
// fill in table
cmd/5g etc: mechanical cleanup Run rsc.io/grind rev a26569f on C->Go conversions. The new change in grind is the inlining of goto targets. If code says 'goto x' and the block starting at label x is unreachable except through that goto and the code can be moved to where the goto is without changing the meaning of its variable names, grind does that move. Simlarly, a goto to a plain return statement turns into that return statement (even if there are other paths to the return statement). Combined, these remove many long-distance gotos, which in turn makes it possible to reduce the scope of more variable declarations. (Because gotos can't jump across declarations, the gotos were keeping the declarations from moving.) Checked bit-for-bit compatibility with toolstash + buildall. Reduces compiler runtime in html/template by about 12%. Change-Id: Id727c0bd7763a61aa22f3daa00aeb8fccbc057a3 Reviewed-on: https://go-review.googlesource.com/6472 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-03-02 12:35:15 -05:00
for i := int32(0); i < nbuckets; i++ {
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
base := indexes[i*SUBBUCKETS]
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
if base == NOIDX {
cmd/link: replace ld.Link.Diag with ld.Errorf Instead of using ctxt.Cursym, Errorf takes an explicit *Symbol parameter. This removes most uses of Cursym and means the *Link context object is needed in fewer parts of the linker. All transformations done manually, as wiring Cursym is tricky. Change-Id: Ief88b00b73904224675c0035684c3a84c19249d7 Reviewed-on: https://go-review.googlesource.com/29369 Reviewed-by: Ian Lance Taylor <iant@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-09-17 09:39:33 -04:00
Errorf(nil, "hole in findfunctab")
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuint32(ctxt, t, int64(i)*(4+SUBBUCKETS), uint32(base))
cmd/link: convert textp into a slice Updates #15374 Change-Id: I3ea715735862fe9550b88d7a29def6cb9d4419a6 Reviewed-on: https://go-review.googlesource.com/22243 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-19 14:02:21 -04:00
for j := int32(0); j < SUBBUCKETS && i*SUBBUCKETS+j < n; j++ {
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
idx = indexes[i*SUBBUCKETS+j]
if idx == NOIDX {
cmd/link: replace ld.Link.Diag with ld.Errorf Instead of using ctxt.Cursym, Errorf takes an explicit *Symbol parameter. This removes most uses of Cursym and means the *Link context object is needed in fewer parts of the linker. All transformations done manually, as wiring Cursym is tricky. Change-Id: Ief88b00b73904224675c0035684c3a84c19249d7 Reviewed-on: https://go-review.googlesource.com/29369 Reviewed-by: Ian Lance Taylor <iant@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-09-17 09:39:33 -04:00
Errorf(nil, "hole in findfunctab")
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
if idx-base >= 256 {
cmd/link: replace ld.Link.Diag with ld.Errorf Instead of using ctxt.Cursym, Errorf takes an explicit *Symbol parameter. This removes most uses of Cursym and means the *Link context object is needed in fewer parts of the linker. All transformations done manually, as wiring Cursym is tricky. Change-Id: Ief88b00b73904224675c0035684c3a84c19249d7 Reviewed-on: https://go-review.googlesource.com/29369 Reviewed-by: Ian Lance Taylor <iant@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-09-17 09:39:33 -04:00
Errorf(nil, "too many functions in a findfunc bucket! %d/%d %d %d", i, nbuckets, j, idx-base)
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
cmd/link/internal: thread *ld.Link through calls Ctxt is a global defined in cmd/link/internal/ld of type *ld.Link. Start threading a *ld.Link through function calls instead of relying on the global variable. Ctxt is still used as a global by the architecture-specific packages, but I plan to fix that in a subsequent CL. Change-Id: I77a3a58bd396fafd959fa1d8b1c83008a9f5a7fb Reviewed-on: https://go-review.googlesource.com/27408 Run-TryBot: Michael Matloob <matloob@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-08-19 22:40:38 -04:00
setuint8(ctxt, t, int64(i)*(4+SUBBUCKETS)+4+int64(j), uint8(idx-base))
cmd/new5l etc: convert from C to Go Using rsc.io/c2go rev fc8cbfa's run.ld script. Change-Id: I4d4d14fce96f8ce7a934bf8b9701b84fa9cf772d Reviewed-on: https://go-review.googlesource.com/6335 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 22:57:28 -05:00
}
}
}
Reference in a new issue Copy permalink