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/macho.go

905 lines
23 KiB
Go
Raw Normal View History

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
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ld
import (
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
"cmd/internal/sys"
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
"sort"
"strings"
)
type MachoHdr struct {
cpu uint32
subcpu uint32
}
type MachoSect struct {
name string
segname string
addr uint64
size uint64
off uint32
align uint32
reloc uint32
nreloc uint32
flag uint32
res1 uint32
res2 uint32
}
type MachoSeg struct {
name string
vsize uint64
vaddr uint64
fileoffset uint64
filesize uint64
prot1 uint32
prot2 uint32
nsect uint32
msect uint32
sect []MachoSect
flag uint32
}
type MachoLoad struct {
type_ uint32
data []uint32
}
/*
* Total amount of space to reserve at the start of the file
* for Header, PHeaders, and SHeaders.
* May waste some.
*/
const (
INITIAL_MACHO_HEADR = 4 * 1024
)
const (
MACHO_CPU_AMD64 = 1<<24 | 7
MACHO_CPU_386 = 7
MACHO_SUBCPU_X86 = 3
MACHO_CPU_ARM = 12
MACHO_SUBCPU_ARM = 0
MACHO_SUBCPU_ARMV7 = 9
cmd/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04:00
MACHO_CPU_ARM64 = 1<<24 | 12
MACHO_SUBCPU_ARM64_ALL = 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
MACHO32SYMSIZE = 12
MACHO64SYMSIZE = 16
MACHO_X86_64_RELOC_UNSIGNED = 0
MACHO_X86_64_RELOC_SIGNED = 1
MACHO_X86_64_RELOC_BRANCH = 2
MACHO_X86_64_RELOC_GOT_LOAD = 3
MACHO_X86_64_RELOC_GOT = 4
MACHO_X86_64_RELOC_SUBTRACTOR = 5
MACHO_X86_64_RELOC_SIGNED_1 = 6
MACHO_X86_64_RELOC_SIGNED_2 = 7
MACHO_X86_64_RELOC_SIGNED_4 = 8
MACHO_ARM_RELOC_VANILLA = 0
cmd/link: remove absolute address for c-archive on darwin/arm Now it is possible to build a c-archive as PIC on darwin/arm (this is now the default). Then the system linker can link the binary using the archive as PIE. Fixes #12896. Change-Id: Iad84131572422190f5fa036e7d71910dc155f155 Reviewed-on: https://go-review.googlesource.com/22461 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-04-26 15:17:56 -04:00
MACHO_ARM_RELOC_PAIR = 1
MACHO_ARM_RELOC_SECTDIFF = 2
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
MACHO_ARM_RELOC_BR24 = 5
cmd/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04:00
MACHO_ARM64_RELOC_UNSIGNED = 0
MACHO_ARM64_RELOC_BRANCH26 = 2
MACHO_ARM64_RELOC_PAGE21 = 3
MACHO_ARM64_RELOC_PAGEOFF12 = 4
MACHO_ARM64_RELOC_ADDEND = 10
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
MACHO_GENERIC_RELOC_VANILLA = 0
MACHO_FAKE_GOTPCREL = 100
)
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Mach-O file writing
// http://developer.apple.com/mac/library/DOCUMENTATION/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html
var macho64 bool
var machohdr MachoHdr
var load []MachoLoad
var seg [16]MachoSeg
var nseg int
var ndebug int
var nsect int
const (
SymKindLocal = 0 + iota
SymKindExtdef
SymKindUndef
NumSymKind
)
var nkind [NumSymKind]int
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 sortsym []*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
var nsortsym int
// Amount of space left for adding load commands
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
// that refer to dynamic libraries. Because these have
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
// to go in the Mach-O header, we can't just pick a
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
// "big enough" header size. The initial header is
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
// one page, the non-dynamic library stuff takes
// up about 1300 bytes; we overestimate that as 2k.
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 loadBudget int = INITIAL_MACHO_HEADR - 2*1024
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
func Machoinit() {
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
macho64 = SysArch.RegSize == 8
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
}
func getMachoHdr() *MachoHdr {
return &machohdr
}
func newMachoLoad(type_ uint32, ndata uint32) *MachoLoad {
if macho64 && (ndata&1 != 0) {
ndata++
}
load = append(load, MachoLoad{})
l := &load[len(load)-1]
l.type_ = type_
l.data = make([]uint32, ndata)
return l
}
func newMachoSeg(name string, msect int) *MachoSeg {
if nseg >= len(seg) {
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
Exitf("too many segs")
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
s := &seg[nseg]
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
nseg++
s.name = name
s.msect = uint32(msect)
s.sect = make([]MachoSect, msect)
return s
}
func newMachoSect(seg *MachoSeg, name string, segname string) *MachoSect {
if seg.nsect >= seg.msect {
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
Exitf("too many sects in segment %s", seg.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
}
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
s := &seg.sect[seg.nsect]
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
seg.nsect++
s.name = name
s.segname = segname
nsect++
return s
}
// Generic linking code.
var dylib []string
var linkoff int64
func machowrite() int {
cmd/link/internal/ld: move ld.Cpos to coutbuf.Offset This change moves the ld.Cpos function to a method on coutbuf. This is part of a larger change that makes ld.outbuf look more like a bio.Buf in an effort to eventually replace the former with the latter. Change-Id: I506f7131935a2aa903fa302a0fab0c5be50220fd Reviewed-on: https://go-review.googlesource.com/27578 Run-TryBot: Dave Cheney <dave@cheney.net> Reviewed-by: David Crawshaw <crawshaw@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-24 20:27:38 +10:00
o1 := coutbuf.Offset()
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
loadsize := 4 * 4 * ndebug
for i := 0; i < len(load); 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
loadsize += 4 * (len(load[i].data) + 2)
}
if macho64 {
loadsize += 18 * 4 * nseg
loadsize += 20 * 4 * nsect
} else {
loadsize += 14 * 4 * nseg
loadsize += 17 * 4 * nsect
}
if macho64 {
Thearch.Lput(0xfeedfacf)
} else {
Thearch.Lput(0xfeedface)
}
Thearch.Lput(machohdr.cpu)
Thearch.Lput(machohdr.subcpu)
if Linkmode == LinkExternal {
Thearch.Lput(1) /* file type - mach object */
} else {
Thearch.Lput(2) /* file type - mach executable */
}
Thearch.Lput(uint32(len(load)) + uint32(nseg) + uint32(ndebug))
Thearch.Lput(uint32(loadsize))
Thearch.Lput(1) /* flags - no undefines */
if macho64 {
Thearch.Lput(0) /* reserved */
}
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 j int
var s *MachoSeg
var t *MachoSect
for i := 0; i < nseg; 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
s = &seg[i]
if macho64 {
Thearch.Lput(25) /* segment 64 */
Thearch.Lput(72 + 80*s.nsect)
strnput(s.name, 16)
Thearch.Vput(s.vaddr)
Thearch.Vput(s.vsize)
Thearch.Vput(s.fileoffset)
Thearch.Vput(s.filesize)
Thearch.Lput(s.prot1)
Thearch.Lput(s.prot2)
Thearch.Lput(s.nsect)
Thearch.Lput(s.flag)
} else {
Thearch.Lput(1) /* segment 32 */
Thearch.Lput(56 + 68*s.nsect)
strnput(s.name, 16)
Thearch.Lput(uint32(s.vaddr))
Thearch.Lput(uint32(s.vsize))
Thearch.Lput(uint32(s.fileoffset))
Thearch.Lput(uint32(s.filesize))
Thearch.Lput(s.prot1)
Thearch.Lput(s.prot2)
Thearch.Lput(s.nsect)
Thearch.Lput(s.flag)
}
for j = 0; uint32(j) < s.nsect; j++ {
t = &s.sect[j]
if macho64 {
strnput(t.name, 16)
strnput(t.segname, 16)
Thearch.Vput(t.addr)
Thearch.Vput(t.size)
Thearch.Lput(t.off)
Thearch.Lput(t.align)
Thearch.Lput(t.reloc)
Thearch.Lput(t.nreloc)
Thearch.Lput(t.flag)
Thearch.Lput(t.res1) /* reserved */
Thearch.Lput(t.res2) /* reserved */
Thearch.Lput(0) /* reserved */
} else {
strnput(t.name, 16)
strnput(t.segname, 16)
Thearch.Lput(uint32(t.addr))
Thearch.Lput(uint32(t.size))
Thearch.Lput(t.off)
Thearch.Lput(t.align)
Thearch.Lput(t.reloc)
Thearch.Lput(t.nreloc)
Thearch.Lput(t.flag)
Thearch.Lput(t.res1) /* reserved */
Thearch.Lput(t.res2) /* reserved */
}
}
}
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 l *MachoLoad
for i := 0; i < len(load); 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
l = &load[i]
Thearch.Lput(l.type_)
Thearch.Lput(4 * (uint32(len(l.data)) + 2))
for j = 0; j < len(l.data); j++ {
Thearch.Lput(l.data[j])
}
}
cmd/link/internal/ld: move ld.Cpos to coutbuf.Offset This change moves the ld.Cpos function to a method on coutbuf. This is part of a larger change that makes ld.outbuf look more like a bio.Buf in an effort to eventually replace the former with the latter. Change-Id: I506f7131935a2aa903fa302a0fab0c5be50220fd Reviewed-on: https://go-review.googlesource.com/27578 Run-TryBot: Dave Cheney <dave@cheney.net> Reviewed-by: David Crawshaw <crawshaw@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-24 20:27:38 +10:00
return int(coutbuf.Offset() - o1)
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 (ctxt *Link) domacho() {
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
if *FlagD {
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
}
// empirically, string table must begin with " \x00".
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
s := ctxt.Syms.Lookup(".machosymstr", 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/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOSYMSTR
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
s.Attr |= AttrReachable
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
Adduint8(ctxt, s, ' ')
Adduint8(ctxt, s, '\x00')
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 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
s = ctxt.Syms.Lookup(".machosymtab", 0)
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOSYMTAB
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
s.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
if Linkmode != LinkExternal {
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
s := ctxt.Syms.Lookup(".plt", 0) // will be __symbol_stub
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOPLT
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
s.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
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
s = ctxt.Syms.Lookup(".got", 0) // will be __nl_symbol_ptr
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOGOT
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
s.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
s.Align = 4
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
s = ctxt.Syms.Lookup(".linkedit.plt", 0) // indirect table for .plt
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOINDIRECTPLT
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
s.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
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
s = ctxt.Syms.Lookup(".linkedit.got", 0) // indirect table for .got
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
s.Type = SMACHOINDIRECTGOT
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
s.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
}
}
func Machoadddynlib(lib string) {
// Will need to store the library name rounded up
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
// and 24 bytes of header metadata. If not enough
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
// space, grab another page of initial space at the
// beginning of the output file.
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
loadBudget -= (len(lib)+7)/8*8 + 24
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 loadBudget < 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
HEADR += 4096
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
*FlagTextAddr += 4096
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
loadBudget += 4096
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
}
dylib = append(dylib, lib)
}
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 machoshbits(ctxt *Link, mseg *MachoSeg, sect *Section, segname string) {
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
buf := "__" + strings.Replace(sect.Name[1:], ".", "_", -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/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04:00
var msect *MachoSect
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 sect.Rwx&1 == 0 && segname != "__DWARF" && (SysArch.Family == sys.ARM64 ||
cmd/link: plugin support on darwin/amd64 This CL turns some special section marker symbols into real symbols laid out in the sections they mark. This is to deal with the fact that dyld on OS X resolves the section marker symbols in any dlopen-ed Go program to the original section marker symbols in the host program. More details in a comment in cmd/link/internal/ld/data.go. Change-Id: Ie9451cfbf06d0bdcccb9959219c791b829f3f771 Reviewed-on: https://go-review.googlesource.com/29394 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-09-19 14:13:07 -04:00
(SysArch.Family == sys.AMD64 && (Buildmode == BuildmodeCShared || Buildmode == BuildmodeCArchive || Buildmode == BuildmodePlugin)) ||
(SysArch.Family == sys.ARM && (Buildmode == BuildmodeCShared || Buildmode == BuildmodeCArchive || Buildmode == BuildmodePlugin))) {
cmd/link: remove absolute address for c-archive on darwin/arm Now it is possible to build a c-archive as PIC on darwin/arm (this is now the default). Then the system linker can link the binary using the archive as PIE. Fixes #12896. Change-Id: Iad84131572422190f5fa036e7d71910dc155f155 Reviewed-on: https://go-review.googlesource.com/22461 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-04-26 15:17:56 -04:00
// Darwin external linker on arm64 and on amd64 and arm in c-shared/c-archive buildmode
cmd/link/internal/ld, cmd/go: -buildmode=c-shared support for darwin/amd64 All of the heavy-lifting was done by minux@, with his external-linking support for darwin/arm64: golang.org/cl/8781 Change-Id: I7c9fbc19246f418c065c92fb2c13c00026ff0f82 Reviewed-on: https://go-review.googlesource.com/11127 Run-TryBot: Srdjan Petrovic <spetrovic@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-06-16 10:07:45 -07:00
// complains about absolute relocs in __TEXT, so if the section is not
// executable, put it in __DATA segment.
cmd/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04:00
msect = newMachoSect(mseg, buf, "__DATA")
} else {
msect = newMachoSect(mseg, buf, segname)
}
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 sect.Rellen > 0 {
msect.reloc = uint32(sect.Reloff)
msect.nreloc = uint32(sect.Rellen / 8)
}
for 1<<msect.align < sect.Align {
msect.align++
}
msect.addr = sect.Vaddr
msect.size = sect.Length
if sect.Vaddr < sect.Seg.Vaddr+sect.Seg.Filelen {
// data in file
if sect.Length > sect.Seg.Vaddr+sect.Seg.Filelen-sect.Vaddr {
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, "macho cannot represent section %s crossing data and bss", sect.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
}
msect.off = uint32(sect.Seg.Fileoff + sect.Vaddr - sect.Seg.Vaddr)
} else {
// zero fill
msect.off = 0
msect.flag |= 1
}
if sect.Rwx&1 != 0 {
msect.flag |= 0x400 /* has instructions */
}
if sect.Name == ".plt" {
msect.name = "__symbol_stub1"
msect.flag = 0x80000408 /* only instructions, code, symbol stubs */
msect.res1 = 0 //nkind[SymKindLocal];
msect.res2 = 6
}
if sect.Name == ".got" {
msect.name = "__nl_symbol_ptr"
msect.flag = 6 /* section with nonlazy symbol pointers */
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
msect.res1 = uint32(ctxt.Syms.Lookup(".linkedit.plt", 0).Size / 4) /* offset into indirect symbol table */
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/internal/ld: emit macho .init_array section Change-Id: Ie75a01e899e68f4f9643410f5e161152a81b8ba0 Reviewed-on: https://go-review.googlesource.com/8655 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-04-08 15:11:04 -04:00
if sect.Name == ".init_array" {
msect.name = "__mod_init_func"
msect.flag = 9 // S_MOD_INIT_FUNC_POINTERS
}
cmd/link: generate DWARF info using symbols This updates dwarf.go to generate debug information as symbols instead of directly writing to the output file. This should make it easier to move generation of some of the debug info into the compiler. Change-Id: Id2358988bfb689865ab4d68f82716f0676336df4 Reviewed-on: https://go-review.googlesource.com/20679 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-14 09:23:04 -07:00
if segname == "__DWARF" {
msect.flag |= 0x02000000
}
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 Asmbmacho(ctxt *Link) {
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
/* apple MACH */
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
va := *FlagTextAddr - int64(HEADR)
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
mh := getMachoHdr()
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
switch SysArch.Family {
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
default:
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
Exitf("unknown macho architecture: %v", SysArch.Family)
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
case sys.ARM:
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
mh.cpu = MACHO_CPU_ARM
mh.subcpu = MACHO_SUBCPU_ARMV7
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
case sys.AMD64:
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
mh.cpu = MACHO_CPU_AMD64
mh.subcpu = MACHO_SUBCPU_X86
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
case sys.ARM64:
cmd/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04:00
mh.cpu = MACHO_CPU_ARM64
mh.subcpu = MACHO_SUBCPU_ARM64_ALL
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
case sys.I386:
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
mh.cpu = MACHO_CPU_386
mh.subcpu = MACHO_SUBCPU_X86
}
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 ms *MachoSeg
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 Linkmode == LinkExternal {
/* segment for entire file */
ms = newMachoSeg("", 40)
ms.fileoffset = Segtext.Fileoff
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 SysArch.Family == sys.ARM || Buildmode == BuildmodeCArchive {
cmd/link: no dwarf on darwin/arm Partial revert of cl/10284 to get -buildmode=c-archive working for darwin/arm. Manually tested with iostest.bash while builder is offline. Change-Id: I98e4e209765666e320e680e11151fce59e2afde9 Reviewed-on: https://go-review.googlesource.com/11306 Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org>
2015-06-22 19:59:59 -04:00
ms.filesize = Segdata.Fileoff + Segdata.Filelen - Segtext.Fileoff
} else {
ms.filesize = Segdwarf.Fileoff + Segdwarf.Filelen - Segtext.Fileoff
cmd/link: emit a mach-o dwarf segment that dsymutil will accept Right now, at least with Xcode 8.3, we invoke dsymutil and dutifully copy what it produces back into the binary, but it has actually dropped all the DWARF information that we wanted, because it didn't like the look of go.o. Make it like the look of go.o. DWARF is tested in other ways, but typically indirectly and not for cgo programs. Add a direct test, and one that exercises cgo. This detects missing dwarf information in cgo-using binaries on macOS, at least with Xcode 8.3, and possibly earlier versions as well. Fixes #19772. Change-Id: I0082e52c0bc8fc4e289770ec3dc02f39fd61e743 Reviewed-on: https://go-review.googlesource.com/38855 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-03-29 20:50:34 -04:00
ms.vsize = Segdwarf.Vaddr + Segdwarf.Length - Segtext.Vaddr
cmd/link: no dwarf on darwin/arm Partial revert of cl/10284 to get -buildmode=c-archive working for darwin/arm. Manually tested with iostest.bash while builder is offline. Change-Id: I98e4e209765666e320e680e11151fce59e2afde9 Reviewed-on: https://go-review.googlesource.com/11306 Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org>
2015-06-22 19:59:59 -04:00
}
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
}
/* segment for zero page */
if Linkmode != LinkExternal {
ms = newMachoSeg("__PAGEZERO", 0)
ms.vsize = uint64(va)
}
/* text */
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
v := Rnd(int64(uint64(HEADR)+Segtext.Length), int64(*FlagRound))
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 Linkmode != LinkExternal {
ms = newMachoSeg("__TEXT", 20)
ms.vaddr = uint64(va)
ms.vsize = uint64(v)
ms.fileoffset = 0
ms.filesize = uint64(v)
ms.prot1 = 7
ms.prot2 = 5
}
cmd/link: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
for _, sect := range Segtext.Sections {
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
machoshbits(ctxt, ms, sect, "__TEXT")
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
}
/* data */
if Linkmode != LinkExternal {
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
w := int64(Segdata.Length)
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
ms = newMachoSeg("__DATA", 20)
ms.vaddr = uint64(va) + uint64(v)
ms.vsize = uint64(w)
ms.fileoffset = uint64(v)
ms.filesize = Segdata.Filelen
ms.prot1 = 3
ms.prot2 = 3
}
cmd/link: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
for _, sect := range Segdata.Sections {
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
machoshbits(ctxt, ms, sect, "__DATA")
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: generate DWARF info using symbols This updates dwarf.go to generate debug information as symbols instead of directly writing to the output file. This should make it easier to move generation of some of the debug info into the compiler. Change-Id: Id2358988bfb689865ab4d68f82716f0676336df4 Reviewed-on: https://go-review.googlesource.com/20679 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-14 09:23:04 -07:00
/* dwarf */
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
if !*FlagW {
cmd/link: generate DWARF info using symbols This updates dwarf.go to generate debug information as symbols instead of directly writing to the output file. This should make it easier to move generation of some of the debug info into the compiler. Change-Id: Id2358988bfb689865ab4d68f82716f0676336df4 Reviewed-on: https://go-review.googlesource.com/20679 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-14 09:23:04 -07:00
if Linkmode != LinkExternal {
ms = newMachoSeg("__DWARF", 20)
ms.vaddr = Segdwarf.Vaddr
ms.vsize = 0
ms.fileoffset = Segdwarf.Fileoff
ms.filesize = Segdwarf.Filelen
}
cmd/link: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
for _, sect := range Segdwarf.Sections {
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
machoshbits(ctxt, ms, sect, "__DWARF")
cmd/link: generate DWARF info using symbols This updates dwarf.go to generate debug information as symbols instead of directly writing to the output file. This should make it easier to move generation of some of the debug info into the compiler. Change-Id: Id2358988bfb689865ab4d68f82716f0676336df4 Reviewed-on: https://go-review.googlesource.com/20679 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-14 09:23:04 -07:00
}
}
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 Linkmode != LinkExternal {
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
switch SysArch.Family {
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
default:
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
Exitf("unknown macho architecture: %v", SysArch.Family)
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
case sys.ARM:
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
ml := newMachoLoad(5, 17+2) /* unix thread */
ml.data[0] = 1 /* thread type */
ml.data[1] = 17 /* word count */
ml.data[2+15] = uint32(Entryvalue(ctxt)) /* start pc */
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
case sys.AMD64:
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
ml := newMachoLoad(5, 42+2) /* unix thread */
ml.data[0] = 4 /* thread type */
ml.data[1] = 42 /* word count */
ml.data[2+32] = uint32(Entryvalue(ctxt)) /* start pc */
ml.data[2+32+1] = uint32(Entryvalue(ctxt) >> 32)
cmd/internal/obj, cmd/internal/ld, cmd/7l: external linking for darwin/arm64 Change-Id: I3b3f80791a1db4c2b7318f81a115972cd2237f02 Signed-off-by: Shenghou Ma <minux@golang.org> Reviewed-on: https://go-review.googlesource.com/8781 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-10 21:28:09 -04: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
case sys.ARM64:
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
ml := newMachoLoad(5, 68+2) /* unix thread */
ml.data[0] = 6 /* thread type */
ml.data[1] = 68 /* word count */
ml.data[2+64] = uint32(Entryvalue(ctxt)) /* start pc */
ml.data[2+64+1] = uint32(Entryvalue(ctxt) >> 32)
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
case sys.I386:
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
ml := newMachoLoad(5, 16+2) /* unix thread */
ml.data[0] = 1 /* thread type */
ml.data[1] = 16 /* word count */
ml.data[2+10] = uint32(Entryvalue(ctxt)) /* start pc */
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: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
if !*FlagD {
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
// must match domacholink below
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
s1 := ctxt.Syms.Lookup(".machosymtab", 0)
s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
s3 := ctxt.Syms.Lookup(".linkedit.got", 0)
s4 := ctxt.Syms.Lookup(".machosymstr", 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
if Linkmode != LinkExternal {
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
ms := newMachoSeg("__LINKEDIT", 0)
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
ms.vaddr = uint64(va) + uint64(v) + uint64(Rnd(int64(Segdata.Length), int64(*FlagRound)))
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
ms.vsize = uint64(s1.Size) + uint64(s2.Size) + uint64(s3.Size) + uint64(s4.Size)
ms.fileoffset = uint64(linkoff)
ms.filesize = ms.vsize
ms.prot1 = 7
ms.prot2 = 3
}
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
ml := newMachoLoad(2, 4) /* LC_SYMTAB */
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
ml.data[0] = uint32(linkoff) /* symoff */
ml.data[1] = uint32(nsortsym) /* nsyms */
ml.data[2] = uint32(linkoff + s1.Size + s2.Size + s3.Size) /* stroff */
ml.data[3] = uint32(s4.Size) /* strsize */
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
machodysymtab(ctxt)
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 Linkmode != LinkExternal {
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
ml := newMachoLoad(14, 6) /* LC_LOAD_DYLINKER */
ml.data[0] = 12 /* offset to string */
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
stringtouint32(ml.data[1:], "/usr/lib/dyld")
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(dylib); 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
ml = newMachoLoad(12, 4+(uint32(len(dylib[i]))+1+7)/8*2) /* LC_LOAD_DYLIB */
ml.data[0] = 24 /* offset of string from beginning of load */
ml.data[1] = 0 /* time stamp */
ml.data[2] = 0 /* version */
ml.data[3] = 0 /* compatibility version */
stringtouint32(ml.data[4:], dylib[i])
}
}
}
cmd/link: add LC_VERSION_MIN_MACOSX to linkmode=internal OS X binaries This makes lldb willing to debug them. The minimum version is hard-coded at OS X 10.7, because that is the minimum that Go requires. For more control over the version, users can use linkmode=external and pass the relevant flags to the host linker. Fixes #12941. Change-Id: I20027be8aa034d07dd2a3326828f75170afe905f Reviewed-on: https://go-review.googlesource.com/18588 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-01-13 09:59:16 -05:00
if Linkmode == LinkInternal {
// For lldb, must say LC_VERSION_MIN_MACOSX or else
// it won't know that this Mach-O binary is from OS X
all: fix typos and spelling Change-Id: Icd06d99c42b8299fd931c7da821e1f418684d913 Reviewed-on: https://go-review.googlesource.com/19829 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-24 11:55:20 +01:00
// (could be iOS or WatchOS instead).
cmd/link: add LC_VERSION_MIN_MACOSX to linkmode=internal OS X binaries This makes lldb willing to debug them. The minimum version is hard-coded at OS X 10.7, because that is the minimum that Go requires. For more control over the version, users can use linkmode=external and pass the relevant flags to the host linker. Fixes #12941. Change-Id: I20027be8aa034d07dd2a3326828f75170afe905f Reviewed-on: https://go-review.googlesource.com/18588 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-01-13 09:59:16 -05:00
// Go on iOS uses linkmode=external, and linkmode=external
// adds this itself. So we only need this code for linkmode=internal
// and we can assume OS X.
//
// See golang.org/issues/12941.
cmd: remove unused code Generated with honnef.co/go/unused There is a large amount of unused code in cmd/internal/obj/s390x but that can wait til the s390x port is merged. There is some unused code in cmd/internal/unvendor/golang.org/x/arch/arm/armasm but that should be addressed upstream and a new revision imported. Change-Id: I252c0f9ea8c5bb1a0b530a374ef13a0a20ea56aa Reviewed-on: https://go-review.googlesource.com/21782 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Dave Cheney <dave@cheney.net>
2016-04-09 15:04:45 +10:00
const LC_VERSION_MIN_MACOSX = 0x24
cmd/link: add LC_VERSION_MIN_MACOSX to linkmode=internal OS X binaries This makes lldb willing to debug them. The minimum version is hard-coded at OS X 10.7, because that is the minimum that Go requires. For more control over the version, users can use linkmode=external and pass the relevant flags to the host linker. Fixes #12941. Change-Id: I20027be8aa034d07dd2a3326828f75170afe905f Reviewed-on: https://go-review.googlesource.com/18588 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-01-13 09:59:16 -05:00
ml := newMachoLoad(LC_VERSION_MIN_MACOSX, 2)
ml.data[0] = 10<<16 | 7<<8 | 0<<0 // OS X version 10.7.0
ml.data[1] = 10<<16 | 7<<8 | 0<<0 // SDK 10.7.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
a := machowrite()
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 int32(a) > HEADR {
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
Exitf("HEADR too small: %d > %d", a, HEADR)
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: 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 symkind(s *Symbol) int {
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
if s.Type == SDYNIMPORT {
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 SymKindUndef
}
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
if s.Attr.CgoExport() {
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 SymKindExtdef
}
return SymKindLocal
}
cmd/link: remove size and version from genasmsym's argument They are trivially available in the few places they are needed. Change-Id: I6544692e9027076ec9e6e9a295c66457039e55e1 Reviewed-on: https://go-review.googlesource.com/29332 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-16 16:47:28 +12:00
func addsym(ctxt *Link, s *Symbol, name string, type_ SymbolType, addr int64, gotype *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
if s == nil {
return
}
switch type_ {
default:
return
cmd/link: give names and a type to the symbol types used by genasmsym Doing this revealed some dead code. Change-Id: I5202fcc3f73e3dfddfea3ec7b772e16da51195da Reviewed-on: https://go-review.googlesource.com/29331 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-16 16:22:08 +12:00
case DataSym, BSSSym, TextSym:
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
break
}
if sortsym != nil {
sortsym[nsortsym] = s
nkind[symkind(s)]++
}
nsortsym++
}
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
type machoscmp []*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
func (x machoscmp) Len() int {
return len(x)
}
func (x machoscmp) Swap(i, j int) {
x[i], x[j] = x[j], x[i]
}
func (x machoscmp) Less(i, j int) bool {
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
s1 := x[i]
s2 := x[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
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
k1 := symkind(s1)
k2 := symkind(s2)
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 k1 != k2 {
cmd/link/internal/ld: removed some uses of stringsCompare Only one use of stringsCompare is left. Cannot simply be replaced by strings.Compare for bootstrapping reasons I guess. Moving the function away from util.go to the actual destination data.go also would not help much. So I left this one unchanged for readability and convenience. Change-Id: I60d22fec0be8f8c47c80586436f9a550af59194e Reviewed-on: https://go-review.googlesource.com/14953 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2015-09-24 16:01:50 +02:00
return k1 < k2
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: removed some uses of stringsCompare Only one use of stringsCompare is left. Cannot simply be replaced by strings.Compare for bootstrapping reasons I guess. Moving the function away from util.go to the actual destination data.go also would not help much. So I left this one unchanged for readability and convenience. Change-Id: I60d22fec0be8f8c47c80586436f9a550af59194e Reviewed-on: https://go-review.googlesource.com/14953 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2015-09-24 16:01:50 +02:00
return s1.Extname < s2.Extname
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: give names and a type to the symbol types used by genasmsym Doing this revealed some dead code. Change-Id: I5202fcc3f73e3dfddfea3ec7b772e16da51195da Reviewed-on: https://go-review.googlesource.com/29331 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-16 16:22:08 +12:00
func machogenasmsym(ctxt *Link) {
genasmsym(ctxt, addsym)
cmd/link: do not directly embed Symbols in Link Mostly done with sed. Change-Id: Ic8c534a3fdd332b5420d062ee85bb77a30ad1efb Reviewed-on: https://go-review.googlesource.com/29346 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 14:59:39 +12:00
for _, s := range ctxt.Syms.Allsym {
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
if s.Type == SDYNIMPORT || s.Type == SHOSTOBJ {
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
if s.Attr.Reachable() {
cmd/link: remove size and version from genasmsym's argument They are trivially available in the few places they are needed. Change-Id: I6544692e9027076ec9e6e9a295c66457039e55e1 Reviewed-on: https://go-review.googlesource.com/29332 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-16 16:47:28 +12:00
addsym(ctxt, s, "", DataSym, 0, nil)
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 machosymorder(ctxt *Link) {
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
// On Mac OS X Mountain Lion, we must sort exported symbols
// So we sort them here and pre-allocate dynid for them
all: link to https instead of http The one in misc/makerelease/makerelease.go is particularly bad and probably warrants rotating our keys. I didn't update old weekly notes, and reverted some changes involving test code for now, since we're late in the Go 1.5 freeze. Otherwise, the rest are all auto-generated changes, and all manually reviewed. Change-Id: Ia2753576ab5d64826a167d259f48a2f50508792d Reviewed-on: https://go-review.googlesource.com/12048 Reviewed-by: Rob Pike <r@golang.org>
2015-07-10 17:17:11 -06:00
// See https://golang.org/issue/4029
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(dynexp); i++ {
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
dynexp[i].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
}
cmd/link: give names and a type to the symbol types used by genasmsym Doing this revealed some dead code. Change-Id: I5202fcc3f73e3dfddfea3ec7b772e16da51195da Reviewed-on: https://go-review.googlesource.com/29331 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-16 16:22:08 +12:00
machogenasmsym(ctxt)
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
sortsym = make([]*Symbol, nsortsym)
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
nsortsym = 0
cmd/link: give names and a type to the symbol types used by genasmsym Doing this revealed some dead code. Change-Id: I5202fcc3f73e3dfddfea3ec7b772e16da51195da Reviewed-on: https://go-review.googlesource.com/29331 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-16 16:22:08 +12:00
machogenasmsym(ctxt)
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
sort.Sort(machoscmp(sortsym[:nsortsym]))
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 < nsortsym; 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
sortsym[i].Dynid = int32(i)
}
}
cmd/link: limit darwin dynlink symbol exports The pclntable contains pointers to functions. If the function symbol is exported in a plugin, and there is a matching symbol in the host binary, then the pclntable of a plugin ends up pointing at the function in the host module. This doesn't work because the traceback code expects the pointer to be in the same module space as the PC value. So don't export functions that might overlap with the host binary. This way the pointer stays in its module. Updates #18190 Change-Id: Ifb77605b35fb0a1e7edeecfd22b1e335ed4bb392 Reviewed-on: https://go-review.googlesource.com/34196 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-09 12:38:34 -05:00
// machoShouldExport reports whether a symbol needs to be exported.
//
// When dynamically linking, all non-local variables and plugin-exported
// symbols need to be exported.
func machoShouldExport(ctxt *Link, s *Symbol) bool {
if !ctxt.DynlinkingGo() || s.Attr.Local() {
return false
}
if Buildmode == BuildmodePlugin && strings.HasPrefix(s.Extname, *flagPluginPath) {
return true
}
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 strings.HasPrefix(s.Name, "type.") && !strings.HasPrefix(s.Name, "type..") {
// reduce runtime typemap pressure, but do not
// export alg functions (type..*), as these
// appear in pclntable.
return true
}
if strings.HasPrefix(s.Name, "go.link.pkghash") {
return true
}
cmd/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
return s.Type >= SELFSECT // only writable sections
cmd/link: limit darwin dynlink symbol exports The pclntable contains pointers to functions. If the function symbol is exported in a plugin, and there is a matching symbol in the host binary, then the pclntable of a plugin ends up pointing at the function in the host module. This doesn't work because the traceback code expects the pointer to be in the same module space as the PC value. So don't export functions that might overlap with the host binary. This way the pointer stays in its module. Updates #18190 Change-Id: Ifb77605b35fb0a1e7edeecfd22b1e335ed4bb392 Reviewed-on: https://go-review.googlesource.com/34196 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-09 12:38:34 -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 machosymtab(ctxt *Link) {
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
symtab := ctxt.Syms.Lookup(".machosymtab", 0)
symstr := ctxt.Syms.Lookup(".machosymstr", 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/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 < nsortsym; i++ {
cmd/internal/obj, cmd/link: random style cleanups Identified during review of golang.org/cl/22103. Change-Id: I86bab4cc17204df1e45deefdb0d0f9a8f6e17073 Reviewed-on: https://go-review.googlesource.com/22106 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-04-14 19:44:55 -07:00
s := sortsym[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
Adduint32(ctxt, symtab, uint32(symstr.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: limit darwin dynlink symbol exports The pclntable contains pointers to functions. If the function symbol is exported in a plugin, and there is a matching symbol in the host binary, then the pclntable of a plugin ends up pointing at the function in the host module. This doesn't work because the traceback code expects the pointer to be in the same module space as the PC value. So don't export functions that might overlap with the host binary. This way the pointer stays in its module. Updates #18190 Change-Id: Ifb77605b35fb0a1e7edeecfd22b1e335ed4bb392 Reviewed-on: https://go-review.googlesource.com/34196 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-09 12:38:34 -05:00
export := machoShouldExport(ctxt, s)
cmd/link: plugin support on darwin/amd64 This CL turns some special section marker symbols into real symbols laid out in the sections they mark. This is to deal with the fact that dyld on OS X resolves the section marker symbols in any dlopen-ed Go program to the original section marker symbols in the host program. More details in a comment in cmd/link/internal/ld/data.go. Change-Id: Ie9451cfbf06d0bdcccb9959219c791b829f3f771 Reviewed-on: https://go-review.googlesource.com/29394 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-09-19 14:13:07 -04:00
// In normal buildmodes, only add _ to C symbols, as
// Go symbols have dot in the name.
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
//
// Do not export C symbols in plugins, as runtime C
// symbols like crosscall2 are in pclntab and end up
// pointing at the host binary, breaking unwinding.
// See Issue #18190.
cexport := !strings.Contains(s.Extname, ".") && (Buildmode != BuildmodePlugin || onlycsymbol(s))
if cexport || export {
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
Adduint8(ctxt, symstr, '_')
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
}
// replace "·" as ".", because DTrace cannot handle it.
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
Addstring(symstr, strings.Replace(s.Extname, "·", ".", -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/internal/objabi, cmd/link: move linker-only symkind values into linker Many (most!) of the values of objapi.SymKind are used only in the linker, so this creates a separate cmd/link/internal/ld.SymKind type, removes most values from SymKind and maps one to the other when reading object files in the linker. Two of the remaining objapi.SymKind values are only checked for, never set and so will never be actually found but I wanted to keep this to the most mechanical change possible. Change-Id: I4bbc5aed6713cab3e8de732e6e288eb77be0474c Reviewed-on: https://go-review.googlesource.com/40985 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-19 15:15:35 +12:00
if s.Type == SDYNIMPORT || s.Type == SHOSTOBJ {
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
Adduint8(ctxt, symtab, 0x01) // type N_EXT, external symbol
Adduint8(ctxt, symtab, 0) // no section
Adduint16(ctxt, symtab, 0) // desc
adduintxx(ctxt, symtab, 0, SysArch.PtrSize) // no 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
} else {
cmd/link: limit darwin dynlink symbol exports The pclntable contains pointers to functions. If the function symbol is exported in a plugin, and there is a matching symbol in the host binary, then the pclntable of a plugin ends up pointing at the function in the host module. This doesn't work because the traceback code expects the pointer to be in the same module space as the PC value. So don't export functions that might overlap with the host binary. This way the pointer stays in its module. Updates #18190 Change-Id: Ifb77605b35fb0a1e7edeecfd22b1e335ed4bb392 Reviewed-on: https://go-review.googlesource.com/34196 Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-12-09 12:38:34 -05:00
if s.Attr.CgoExport() || export {
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
Adduint8(ctxt, symtab, 0x0f)
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 {
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
Adduint8(ctxt, symtab, 0x0e)
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/internal/obj, cmd/link: random style cleanups Identified during review of golang.org/cl/22103. Change-Id: I86bab4cc17204df1e45deefdb0d0f9a8f6e17073 Reviewed-on: https://go-review.googlesource.com/22106 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-04-14 19:44:55 -07:00
o := 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
for o.Outer != nil {
o = o.Outer
}
if o.Sect == nil {
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(s, "missing section for symbol")
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
Adduint8(ctxt, symtab, 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
} else {
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
Adduint8(ctxt, symtab, uint8(o.Sect.Extnum))
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
Adduint16(ctxt, symtab, 0) // desc
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
adduintxx(ctxt, symtab, uint64(Symaddr(s)), 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/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 machodysymtab(ctxt *Link) {
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
ml := newMachoLoad(11, 18) /* LC_DYSYMTAB */
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
n := 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
ml.data[0] = uint32(n) /* ilocalsym */
ml.data[1] = uint32(nkind[SymKindLocal]) /* nlocalsym */
n += nkind[SymKindLocal]
ml.data[2] = uint32(n) /* iextdefsym */
ml.data[3] = uint32(nkind[SymKindExtdef]) /* nextdefsym */
n += nkind[SymKindExtdef]
ml.data[4] = uint32(n) /* iundefsym */
ml.data[5] = uint32(nkind[SymKindUndef]) /* nundefsym */
ml.data[6] = 0 /* tocoffset */
ml.data[7] = 0 /* ntoc */
ml.data[8] = 0 /* modtaboff */
ml.data[9] = 0 /* nmodtab */
ml.data[10] = 0 /* extrefsymoff */
ml.data[11] = 0 /* nextrefsyms */
// must match domacholink below
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
s1 := ctxt.Syms.Lookup(".machosymtab", 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: 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
s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
s3 := ctxt.Syms.Lookup(".linkedit.got", 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
ml.data[12] = uint32(linkoff + s1.Size) /* indirectsymoff */
ml.data[13] = uint32((s2.Size + s3.Size) / 4) /* nindirectsyms */
ml.data[14] = 0 /* extreloff */
ml.data[15] = 0 /* nextrel */
ml.data[16] = 0 /* locreloff */
ml.data[17] = 0 /* nlocrel */
}
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 Domacholink(ctxt *Link) int64 {
machosymtab(ctxt)
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
// write data that will be linkedit section
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
s1 := ctxt.Syms.Lookup(".machosymtab", 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: 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
s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
s3 := ctxt.Syms.Lookup(".linkedit.got", 0)
s4 := ctxt.Syms.Lookup(".machosymstr", 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
// Force the linkedit section to end on a 16-byte
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
// boundary. This allows pure (non-cgo) Go binaries
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
// to be code signed correctly.
//
// Apple's codesign_allocate (a helper utility for
// the codesign utility) can do this fine itself if
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
// it is run on a dynamic Mach-O binary. However,
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
// when it is run on a pure (non-cgo) Go binary, where
// the linkedit section is mostly empty, it fails to
// account for the extra padding that it itself adds
// when adding the LC_CODE_SIGNATURE load command
// (which must be aligned on a 16-byte boundary).
//
// By forcing the linkedit section to end on a 16-byte
// boundary, codesign_allocate will not need to apply
// any alignment padding itself, working around the
// issue.
for s4.Size%16 != 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
Adduint8(ctxt, s4, 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/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
size := int(s1.Size + s2.Size + s3.Size + s4.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
if size > 0 {
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
linkoff = Rnd(int64(uint64(HEADR)+Segtext.Length), int64(*FlagRound)) + Rnd(int64(Segdata.Filelen), int64(*FlagRound)) + Rnd(int64(Segdwarf.Filelen), int64(*FlagRound))
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
Cseek(linkoff)
Cwrite(s1.P[:s1.Size])
Cwrite(s2.P[:s2.Size])
Cwrite(s3.P[:s3.Size])
Cwrite(s4.P[:s4.Size])
}
cmd/link: turn some globals into flag pointer variables This moves many of the flag globals into main and assigns them to their flag.String/Int64/... directly. Updates #16818 Change-Id: Ibbff44a273bbc5cb7228e43f147900ee8848517f Reviewed-on: https://go-review.googlesource.com/27473 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-08-21 18:34:24 -04:00
return Rnd(int64(size), int64(*FlagRound))
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 machorelocsect(ctxt *Link, sect *Section, syms []*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
// If main section has no bits, nothing to relocate.
if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
return
}
cmd/link/internal/ld: move ld.Cpos to coutbuf.Offset This change moves the ld.Cpos function to a method on coutbuf. This is part of a larger change that makes ld.outbuf look more like a bio.Buf in an effort to eventually replace the former with the latter. Change-Id: I506f7131935a2aa903fa302a0fab0c5be50220fd Reviewed-on: https://go-review.googlesource.com/27578 Run-TryBot: Dave Cheney <dave@cheney.net> Reviewed-by: David Crawshaw <crawshaw@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-24 20:27:38 +10:00
sect.Reloff = uint64(coutbuf.Offset())
cmd/link: process data symbols with slices First (and largest single) step to switching cmd/link from linked lists of symbols to slices. Sort sections independently and concurrently. This reduces jujud link times on linux/amd64 by ~4%. Updates #15374 Change-Id: I452bc8f33081039468636502fe3c1cc8d6ed9efa Reviewed-on: https://go-review.googlesource.com/22205 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-18 14:50:14 -04:00
for i, s := range syms {
if !s.Attr.Reachable() {
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: process data symbols with slices First (and largest single) step to switching cmd/link from linked lists of symbols to slices. Sort sections independently and concurrently. This reduces jujud link times on linux/amd64 by ~4%. Updates #15374 Change-Id: I452bc8f33081039468636502fe3c1cc8d6ed9efa Reviewed-on: https://go-review.googlesource.com/22205 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-18 14:50:14 -04:00
if uint64(s.Value) >= sect.Vaddr {
syms = syms[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
break
}
}
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
eaddr := int32(sect.Vaddr + sect.Length)
cmd/link: process data symbols with slices First (and largest single) step to switching cmd/link from linked lists of symbols to slices. Sort sections independently and concurrently. This reduces jujud link times on linux/amd64 by ~4%. Updates #15374 Change-Id: I452bc8f33081039468636502fe3c1cc8d6ed9efa Reviewed-on: https://go-review.googlesource.com/22205 Reviewed-by: Michael Hudson-Doyle <michael.hudson@canonical.com>
2016-04-18 14:50:14 -04:00
for _, sym := range syms {
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
if !sym.Attr.Reachable() {
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
}
if sym.Value >= int64(eaddr) {
break
}
cmd/link: move declarations into loops (Split out from CL 22205.) Change-Id: Id32698f48ce02b55c15b6f2842215e0ffdbf425b Reviewed-on: https://go-review.googlesource.com/22298 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-04-20 10:36:27 -04:00
for ri := 0; ri < len(sym.R); ri++ {
r := &sym.R[ri]
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 r.Done != 0 {
continue
}
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
if r.Xsym == nil {
Errorf(sym, "missing xsym in relocation")
continue
}
if !r.Xsym.Attr.Reachable() {
Errorf(sym, "unreachable reloc %v target %v", r.Type, r.Xsym.Name)
}
if Thearch.Machoreloc1(sym, r, int64(uint64(sym.Value+int64(r.Off))-sect.Vaddr)) < 0 {
Errorf(sym, "unsupported obj reloc %v/%d to %s", r.Type, r.Siz, r.Sym.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
}
}
}
cmd/link/internal/ld: move ld.Cpos to coutbuf.Offset This change moves the ld.Cpos function to a method on coutbuf. This is part of a larger change that makes ld.outbuf look more like a bio.Buf in an effort to eventually replace the former with the latter. Change-Id: I506f7131935a2aa903fa302a0fab0c5be50220fd Reviewed-on: https://go-review.googlesource.com/27578 Run-TryBot: Dave Cheney <dave@cheney.net> Reviewed-by: David Crawshaw <crawshaw@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-24 20:27:38 +10:00
sect.Rellen = uint64(coutbuf.Offset()) - sect.Reloff
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 Machoemitreloc(ctxt *Link) {
cmd/link/internal/ld: move ld.Cpos to coutbuf.Offset This change moves the ld.Cpos function to a method on coutbuf. This is part of a larger change that makes ld.outbuf look more like a bio.Buf in an effort to eventually replace the former with the latter. Change-Id: I506f7131935a2aa903fa302a0fab0c5be50220fd Reviewed-on: https://go-review.googlesource.com/27578 Run-TryBot: Dave Cheney <dave@cheney.net> Reviewed-by: David Crawshaw <crawshaw@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-24 20:27:38 +10:00
for coutbuf.Offset()&7 != 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
Cput(0)
}
cmd/link: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
machorelocsect(ctxt, Segtext.Sections[0], ctxt.Textp)
for _, sect := range Segtext.Sections[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
machorelocsect(ctxt, sect, datap)
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: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
for _, sect := range Segdata.Sections {
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
machorelocsect(ctxt, sect, datap)
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: replace Segment's linked list of Sections with a slice Just noticed this in passing. Change-Id: I58fa828ef58598209ed4cbe4abc6f9f02ffc4844 Reviewed-on: https://go-review.googlesource.com/40896 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-04-18 21:52:06 +12:00
for _, sect := range Segdwarf.Sections {
cmd/link: remove Symbol.Next Bye bye one more class of linked list manipulation! Change-Id: I2412b224c847dd640f9253125d30cd5f911ce00c Reviewed-on: https://go-review.googlesource.com/27414 Run-TryBot: Michael Hudson-Doyle <michael.hudson@canonical.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Michael Matloob <matloob@golang.org>
2016-04-22 10:31:14 +12:00
machorelocsect(ctxt, sect, dwarfp)
cmd/link: generate DWARF info using symbols This updates dwarf.go to generate debug information as symbols instead of directly writing to the output file. This should make it easier to move generation of some of the debug info into the compiler. Change-Id: Id2358988bfb689865ab4d68f82716f0676336df4 Reviewed-on: https://go-review.googlesource.com/20679 Reviewed-by: David Crawshaw <crawshaw@golang.org> Run-TryBot: David Crawshaw <crawshaw@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-03-14 09:23:04 -07:00
}
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