aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/ld/elf.c
AgeCommit message (Collapse)Author
2015-03-01cmd/5l etc: replace C code with Go codeRuss Cox
mv cmd/new5l cmd/5l and so on. Minimal changes to cmd/dist and cmd/go to keep things building. More can be deleted in followup CLs. Change-Id: I1449eca7654ce2580d1f413a56dc4a75f3d4618b Reviewed-on: https://go-review.googlesource.com/6361 Reviewed-by: Rob Pike <r@golang.org>
2015-03-01cmd/ld: clean for c2goRuss Cox
Change-Id: Iaab2be9a1919f2fa9dbc61a5b7fbf99bcd0712a9 Reviewed-on: https://go-review.googlesource.com/6332 Reviewed-by: Rob Pike <r@golang.org> Reviewed-by: Minux Ma <minux@golang.org>
2015-02-13cmd/ld: set alignment for the .rel.plt section on 32-bit architecturesShenghou Ma
Fixes #9802. Change-Id: I22c52a37bdb23a14cc4615c9519431bb14ca81ca Reviewed-on: https://go-review.googlesource.com/4170 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-02-13cmd/ld: make cmd/ld a real libraryRuss Cox
Make cmd/ld a real library invoked by the individual linkers. There are no reverse symbol references anymore (symbols referred to in cmd/ld but defined in cmd/5l etc). This means that in principle we could do an automatic conversion of these to Go, as a stopgap until cmd/link is done or as a replacement for cmd/link. Change-Id: I4a94570257a3a7acc31601bfe0fad9dea0aea054 Reviewed-on: https://go-review.googlesource.com/4649 Reviewed-by: Rob Pike <r@golang.org>
2015-01-07cmd/9l: support internal linkingAustin Clements
This implements the ELF relocations and dynamic linking tables necessary to support internal linking on ppc64. It also marks ppc64le ELF files as ABI v2; failing to do this doesn't seem to confuse the loader, but it does confuse libbfd (and hence gdb, objdump, etc). Change-Id: I559dddf89b39052e1b6288a4dd5e72693b5355e4 Reviewed-on: https://go-review.googlesource.com/2006 Reviewed-by: Russ Cox <rsc@golang.org>
2014-12-18cmd/ld: add fallthrough commentAustin Clements
Change-Id: Ia6739c164575751a63cc0d4d41d1f6887fbbaee3 Reviewed-on: https://go-review.googlesource.com/1803 Reviewed-by: Minux Ma <minux@golang.org>
2014-12-18cmd/ld: set ELF ABI version for ppc64xAustin Clements
On ppc64, there are three ELF ABI versions an ELF file can request. Previously, we used 0, which means "unspecified". On our test machines, this meant to use the default (v1 for big endian and v2 for little endian), but apparently some systems can pick the wrong ABI if neither is requested. Leaving this as 0 also confuses libbfd, which confuses gdb, objdump, etc. Fix these problems by specifying ABI v1 for big endian and v2 for little endian. Change-Id: I4d3d5478f37f11baab3681a07daff3da55802322 Reviewed-on: https://go-review.googlesource.com/1800 Reviewed-by: Minux Ma <minux@golang.org>
2014-08-07[dev.power64] cmd/ld: update for power64Shenghou Ma
LGTM=rsc R=rsc, iant CC=golang-codereviews https://golang.org/cl/121380043
2014-07-03cmd/go, cmd/ld, runtime, os/user: TLS emulation for androidDavid Crawshaw
Based on cl/69170045 by Elias Naur. There are currently several schemes for acquiring a TLS slot to save the g register. None of them appear to work for android. The closest are linux and darwin. Linux uses a linker TLS relocation. This is not supported by the android linker. Darwin uses a fixed offset, and calls pthread_key_create until it gets the slot it wants. As the runtime loads late in the android process lifecycle, after an arbitrary number of other libraries, we cannot rely on any particular slot being available. So we call pthread_key_create, take the first slot we are given, and put it in runtime.tlsg, which we turn into a regular variable in cmd/ld. Makes android/arm cgo binaries work. LGTM=minux R=elias.naur, minux, dave, josharian CC=golang-codereviews https://golang.org/cl/106380043
2014-05-21cmd/ld: correctly compute note size on NetBSD.Benny Siegert
Patch from http://gnats.NetBSD.org/48811. LGTM=iant R=golang-codereviews, minux.ma, iant CC=golang-codereviews, tk https://golang.org/cl/94670047
2014-04-21runtime, cmd/ld, cmd/5l, run.bash: enable external linking on FreeBSD/ARM.Shenghou Ma
Update #7331 LGTM=dave, iant R=golang-codereviews, dave, gobot, iant CC=golang-codereviews https://golang.org/cl/89520043
2014-03-05cmd/ld: don't include padding length in size of the note sectionShenghou Ma
Recently NetBSD starts to enforce this, and refuses to execute the program if n is larger than the sum of entry sizes. Before: $ readelf -n ../bin/go.old Notes at offset 0x00000bd0 with length 0x00000019: Owner Data size Description NetBSD 0x00000004 NT_VERSION (version) readelf: Warning: corrupt note found at offset 18 into core notes readelf: Warning: type: 0, namesize: 00000000, descsize: 00000000 $ readelf -n ../bin/go Notes at offset 0x00000bd0 with length 0x00000018: Owner Data size Description NetBSD 0x00000004 NT_VERSION (version) LGTM=iant R=iant CC=golang-codereviews https://golang.org/cl/70710043
2014-02-27all: final merge of NaCl treeRuss Cox
This CL replays the following one CL from the rsc-go13nacl repo. This is the last replay CL: after this CL the main repo will have everything the rsc-go13nacl repo did. Changes made to the main repo after the rsc-go13nacl repo branched off probably mean that NaCl doesn't actually work after this CL, but all the code is now moved over and just needs to be redebugged. --- cmd/6l, cmd/8l, cmd/ld: support for Native Client See golang.org/s/go13nacl for design overview. This CL is publicly visible but not CC'ed to golang-dev, to avoid distracting from the preparation of the Go 1.2 release. This CL and the others will be checked into my rsc-go13nacl clone repo for now, and I will send CLs against the main repo early in the Go 1.3 development. R≡khr https://golang.org/cl/15750044 --- LGTM=bradfitz, dave, iant R=dave, bradfitz, iant CC=golang-codereviews https://golang.org/cl/69040044
2014-02-09include, linlink, cmd/6l, cmd/ld: part 1 of solaris/amd64 linker changes.Shenghou Ma
rsc suggested that we split the whole linker changes into three parts. This is the first one, mostly dealing with adding Hsolaris. LGTM=iant R=golang-codereviews, iant, dave CC=golang-codereviews https://golang.org/cl/54210050
2013-12-18cmd/6g, cmd/gc, cmd/ld: fix Plan 9 amd64 warningsDavid du Colombier
warning: src/cmd/6g/reg.c:671 format mismatch d VLONG, arg 4 warning: src/cmd/gc/pgen.c:230 set and not used: oldstksize warning: src/cmd/gc/plive.c:877 format mismatch lx UVLONG, arg 2 warning: src/cmd/gc/walk.c:2878 set and not used: cbv warning: src/cmd/gc/walk.c:2885 set and not used: hbv warning: src/cmd/ld/data.c:198 format mismatch s IND FUNC(IND CHAR) INT, arg 2 warning: src/cmd/ld/data.c:230 format mismatch s IND FUNC(IND CHAR) INT, arg 2 warning: src/cmd/ld/dwarf.c:1517 set and not used: pc warning: src/cmd/ld/elf.c:1507 format mismatch d VLONG, arg 2 warning: src/cmd/ld/ldmacho.c:509 set and not used: dsymtab R=golang-dev, gobot, rsc CC=golang-dev https://golang.org/cl/36740045
2013-12-08liblink: create new library based on linker codeRuss Cox
There is an enormous amount of code moving around in this CL, but the code is the same, and it is invoked in the same ways. This CL is preparation for the new linker structure, not the new structure itself. The new library's definition is in include/link.h. The main change is the use of a Link structure to hold all the linker-relevant state, replacing the smattering of global variables. The Link structure should both make it clearer which state must be carried around and make it possible to parallelize more easily later. The main body of the linker has moved into the architecture-independent cmd/ld directory. That includes the list of known header types, so the distinction between Hplan9x32 and Hplan9x64 is removed (no other header type distinguished 32- and 64-bit formats), and code for unused formats such as ipaq kernels has been deleted. The code being deleted from 5l, 6l, and 8l reappears in liblink or in ld. Because multiple files are being merged in the liblink directory, it is not possible to show the diffs nicely in hg. The Prog and Addr structures have been unified into an architecture-independent form and moved to link.h, where they will be shared by all tools: the assemblers, the compilers, and the linkers. The unification makes it possible to write architecture-independent traversal of Prog lists, among other benefits. The Sym structures cannot be unified: they are too fundamentally different between the linker and the compilers. Instead, liblink defines an LSym - a linker Sym - to be used in the Prog and Addr structures, and the linker now refers exclusively to LSyms. The compilers will keep using their own syms but will fill out the corresponding LSyms in the Prog and Addr structures. Although code from 5l, 6l, and 8l is now in a single library, the code has been arranged so that only one architecture needs to be linked into a particular program: 5l will not contain the code needed for x86 instruction layout, for example. The object file writing code in liblink/obj.c is from cmd/gc/obj.c. Preparation for golang.org/s/go13linker work. This CL does not build by itself. It depends on 35740044 and will be submitted at the same time. R=iant CC=golang-dev https://golang.org/cl/35790044
2013-08-24all: compiler/bootstrap for dragonfly/amd64Joel Sing
Add dragonfly/amd64 support to the Go compiler, bootstrap and GOOS list. R=devon.odell, bradfitz CC=golang-dev https://golang.org/cl/12796050
2013-08-14runtime.cmd/ld: Add ARM external linking and implement -shared in terms of ↵Elias Naur
external linking This CL is an aggregate of 10271047, 10499043, 9733044. Descriptions of each follow: 10499043 runtime,cmd/ld: Merge TLS symbols and teach 5l about ARM TLS This CL prepares for external linking support to ARM. The pseudo-symbols runtime.g and runtime.m are merged into a single runtime.tlsgm symbol. When external linking, the offset of a thread local variable is stored at a memory location instead of being embedded into a offset of a ldr instruction. With a single runtime.tlsgm symbol for both g and m, only one such offset is needed. The larger part of this CL moves TLS code from gcc compiled to internally compiled. The TLS code now uses the modern MRC instruction, and 5l is taught about TLS fallbacks in case the instruction is not available or appropriate. 10271047 This CL adds support for -linkmode external to 5l. For 5l itself, use addrel to allow for D_CALL relocations to be handled by the host linker. Of the cases listed in rsc's comment in issue 4069, only case 5 and 63 needed an update. One of the TODO: addrel cases was since replaced, and the rest of the cases are either covered by indirection through addpool (cases with LTO or LFROM flags) or stubs (case 74). The addpool cases are covered because addpool emits AWORD instructions, which in turn are handled by case 11. In the runtime, change the argv argument in the rt0* functions slightly to be a pointer to the argv list, instead of relying on a particular location of argv. 9733044 The -shared flag to 6l outputs a shared library, implemented in Go and callable from non-Go programs such as C. The main part of this CL change the thread local storage model. Go uses the fastest and least general mode, local exec. TLS data in shared libraries normally requires at least the local dynamic mode, however, this CL instead opts for using the initial exec mode. Initial exec mode is faster than local dynamic mode and can be used in linux since the linker has reserved a limited amount of TLS space for performance sensitive TLS code. Initial exec mode requires an extra load from the GOT table to determine the TLS offset. This penalty will not be paid if ld is not in -shared mode, since TLS accesses will be reduced to local exec. The elf sections .init_array and .rela.init_array are added to register the Go runtime entry with cgo at library load time. The "hidden" attribute is added to Cgo functions called from Go, since Go does not generate call through the GOT table, and adding non-GOT relocations for a global function is not supported by gcc. Cgo symbols don't need to be global and avoiding the GOT table is also faster. The changes to 8l are only removes code relevant to the old -shared mode where internal linking was used. This CL only address the low level linker work. It can be submitted by itself, but to be useful, the runtime changes in CL 9738047 is also needed. Design discussion at https://groups.google.com/forum/?fromgroups#!topic/golang-nuts/zmjXkGrEx6Q Fixes #5590. R=rsc CC=golang-dev https://golang.org/cl/12871044
2013-07-11cmd/ld: place read-only data in non-executable segmentRuss Cox
R=golang-dev, dave, r CC=golang-dev, nigeltao https://golang.org/cl/10713043
2013-06-12cmd/ld: supply -s to gcc if -s is passed.Shenghou Ma
Fixes #5463. R=golang-dev, iant CC=golang-dev https://golang.org/cl/9239045
2013-06-04cmd/ld: fix gcdata and gcbss symbolsAnthony Martin
These two symbols don't show up in the Go symbol table since they're defined in dodata which is called sometime after symtab. They do, however, show up in the ELF symbol table. This regression was introduced in changeset 01c40d533367. Also, remove the corresponding strings from the ELF strtab section now that they're unused. R=golang-dev, iant CC=golang-dev https://golang.org/cl/8650043
2013-05-18cmd/ld: emit .tbss section when doing dynamic internal linkingShenghou Ma
Fixes #5200. R=iant, dave CC=golang-dev https://golang.org/cl/9383043
2013-05-03cmd/ld: add .note.GNU-stack section for external linkingShenghou Ma
Fixes #5392. R=iant, r CC=golang-dev https://golang.org/cl/9119043
2013-04-30cmd/ld: emit relocs for DWARF info when doing an external linkIan Lance Taylor
I would like opinions on whether this is a good idea for 1.1. On the one hand it's a moderately important issue. On the other hand this introduces at least the possibility of external linker errors due to the additional relocations and it may be better to wait. I'm fairly confident that the behaviour is unchanged when not using an external linker. Update #5221 This CL is tested lightly on 386 and amd64 and fixes the cases I tested. I have not tested it on Darwin or Windows. R=golang-dev, dave, daniel.morsing, rsc CC=golang-dev https://golang.org/cl/8858047
2013-04-29cmd/ld: fix some 64-bit issuesRob Pike
A few places in the linker pushed 64-bit values through 32-bit holes, including in relocation. Clean them up, and check for a few other overflows as well. Tests to follow. R=dsymonds CC=gobot, golang-dev https://golang.org/cl/9032043
2013-03-27cmd/ld, cmd/8l: Fix OpenBSD build.Ian Lance Taylor
Don't generate TLS sections on OpenBSD. R=golang-dev, r CC=golang-dev https://golang.org/cl/8059043
2013-03-27cmd/ld: emit TLS relocations during external linkingIan Lance Taylor
This CL was written by rsc. I just tweaked 8l. This CL adds TLS relocation to the ELF .o file we write during external linking, so that the host linker (gcc) can decide the final location of m and g. Similar relocations are not necessary on OS X because we use an alternate program start-time mechanism to acquire thread-local storage. Similar relocations are not necessary on ARM or Plan 9 or Windows because external linking mode is not yet supported on those systems. On almost all ELF systems, the references we use are like %fs:-0x4 or %gs:-0x4, which we write in 6a/8a as -0x4(FS) or -0x4(GS). On Linux/ELF, however, Xen's lack of support for this mode forced us long ago to use a two-instruction sequence: first we load %gs:0x0 into a register r, and then we use -0x4(r). (The ELF program loader arranges that %gs:0x0 contains a regular pointer to that same memory location.) In order to relocate those -0x4(r) references, the linker must know where they are. This CL adds the equivalent notation -0x4(r)(GS*1) for this purpose: it assembles to the same encoding as -0x4(r) but the (GS*1) indicates to the linker that this is one of those thread-local references that needs relocation. Thanks to Elias Naur for reminding me about this missing piece and also for writing the test. R=r CC=golang-dev https://golang.org/cl/7891047
2013-03-19cmd/ld: replace -hostobj with -linkmodeRuss Cox
Still disabled. Need to fix TLS. R=golang-dev, minux.ma, bradfitz CC=golang-dev https://golang.org/cl/7783044
2013-03-10cmd/ld: avoid redundant external relocation calculationsRuss Cox
R=ken2, ken CC=golang-dev https://golang.org/cl/7483045
2013-03-10cmd/ld: replace dynimpname with extnameRuss Cox
Dynimpname was getting too confusing. Replace flag-like checks with tests of s->type. R=ken2 CC=golang-dev https://golang.org/cl/7594046
2013-03-08cmd/ld: external linking fixes for linux/386Russ Cox
The sticking point on 386 has been the "PC relative" relocations used to point the garbage collection metadata at the type info. These aren't in the code segment, and I don't trust that the linker isn't doing something special that would be okay in code but not when interpreting the pointers as data (for example, a PLT jump table would be terrible). Solve the problem in two steps: 1. Handle "PC relative" relocations within a section internally, so that the external linker never sees them. 2. Move the gcdata and gcbss tables into the rodata section, where the type information lives, so that the relocations can be handled internally. (To answer the obvious question, we make the gc->type references relative so that they need not be relocated individually when generating a shared object file.) R=golang-dev, iant CC=golang-dev https://golang.org/cl/7629043
2013-03-07cmd/ld: steps toward 386 host linkingRuss Cox
- Introduce MaxAlign constant and use in data layout and ELF section header. - Allow up to 16-byte alignment for large objects (will help Keith's hash changes). - Emit ELF symbol for .rathole (global /dev/null used by 8c). - Invoke gcc with -m32/-m64 as appropriate. - Don't invoke gcc if writing the .o file failed. R=golang-dev, iant CC=golang-dev https://golang.org/cl/7563045
2013-02-14cmd/ld: fix -s flag for ELF executablesAnthony Martin
This fixes a regression introduced in changeset 98034d036d03 which added support for producing host object files. R=rsc, minux.ma CC=dave, golang-dev https://golang.org/cl/7307107
2013-02-04cmd/5l, cmd/ld: support generating ELF binaries for NetBSD/ARMShenghou Ma
R=golang-dev, dave CC=golang-dev https://golang.org/cl/7261043
2013-01-31cmd/ld: support for linking with host linkerRuss Cox
A step toward a fix for issue 4069. To allow linking with arbitrary host object files, add a linker mode that can generate a host object file instead of an executable. Then the host linker can be invoked to generate the final executable. This CL adds a new -hostobj flag that instructs the linker to write a host object file instead of an executable. That is, this works: go tool 6g x.go go tool 6l -hostobj -o x.o x.6 ld -e _rt0_amd64_linux x.o ./a.out as does: go tool 8g x.go go tool 8l -hostld ignored -o x.o x.8 ld -m elf_i386 -e _rt0_386_linux x.o ./a.out Because 5l was never updated to use the standard relocation scheme, it will take more work to get this working on ARM. This is a checkpoint of the basic functionality. It does not work with cgo yet, and cgo is the main reason for the change. The command-line interface will likely change too. The gc linker has other information that needs to be returned to the caller for use when invoking the host linker besides the single object file. R=iant, iant CC=golang-dev https://golang.org/cl/7060044
2013-01-306l/5l: PIC and shared library support for the linkers.Elias Naur
Added the -shared flag to 5l/6l to output a PIC executable with the required dynamic relocations and RIP-relative addressing in machine code. Added dummy support to 8l to avoid compilation errors See also: https://golang.org/cl/6822078 https://golang.org/cl/7064048 and https://groups.google.com/d/topic/golang-nuts/P05BDjLcQ5k/discussion R=rsc, iant CC=golang-dev https://golang.org/cl/6926049
2013-01-06cmd/ld: move symtab, ELF generation to portable codeRuss Cox
More cleanup in preparation for fixing issue 4069. This CL replaces the three nearly identical copies of the asmb ELF code with a single asmbelf function in elf.c. In addition to the ELF code movement, remove the elfstr array in favor of a simpler lookup, and identify sections by name throughout instead of computing fragile indices. The CL also replaces the three nearly identical copies of the genasmsym code with a single genasmsym function in lib.c. The ARM linker still compiles and generates binaries, but I haven't tested the binaries. They may not work. R=ken2 CC=golang-dev https://golang.org/cl/7062047
2012-10-09cmd/ld: add -B option to set build IDIan Lance Taylor
Background on build ID: http://fedoraproject.org/wiki/RolandMcGrath/BuildID R=rsc CC=golang-dev https://golang.org/cl/6625072
2012-09-21cmd/{ld,5l,6l,8l}: add support for OpenBSD ELF signaturesJoel Sing
OpenBSD now requires ELF binaries to have a PT_NOTE that identifies it as an OpenBSD binary. Refactor the existing NetBSD ELF signature code and implement support for OpenBSD ELF signatures. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/6489131
2012-08-23cmd/ld: set ELF header flags for our Linux/ARM binaryShenghou Ma
To make it more compliant. This won't affect the behavior of running on OABI-only kernels. R=golang-dev, iant CC=golang-dev https://golang.org/cl/6475044
2012-05-31cmd/ld: increase number of ELF sectionsJoel Sing
On NetBSD a cgo enabled binary has more than 32 sections - bump NSECTS so that we can actually link them successfully. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/6261052
2011-12-205l/6l/8l: add support for netbsd signature note sectionJoel Sing
R=m4dh4tt3r, jsing, rsc CC=golang-dev https://golang.org/cl/5493068
2011-08-31runtime: make arm work on Ubuntu Natty qemuRuss Cox
R=golang-dev, r CC=golang-dev https://golang.org/cl/4963050
2011-07-21ld: fix freebsd build reverting .interp moveGustavo Niemeyer
R=golang-dev, r CC=golang-dev https://golang.org/cl/4794046
2011-07-20ld: remove overlap of ELF sections on dynamic binariesGustavo Niemeyer
The dynamic ELF sections were pointing to the proper data, but that data was already owned by the rodata and text sections. Some ELF references explicitly prohibit multiple sections from owning the same data, and strip behaves accordingly. The data for these sections was moved out and their ranges are now owned by their respective sections. This change makes strip happy both with and without -s being provided at link time. A test was added in debug/elf to ensure there are no regressions on this area in the future. Fixes #1242. Fixes #2022. NOTE: Tested on Linux amd64/386/arm only. R=rsc CC=golang-dev https://golang.org/cl/4808043
2011-07-18ld: allow seek within write bufferRuss Cox
Reduces number of write+seek's from 88516 to 2080 when linking godoc with 6l. Thanks to Alex Brainman for pointing out the many small writes. R=golang-dev, r, alex.brainman, robert.hencke CC=golang-dev https://golang.org/cl/4743043
2011-04-27cgo: handle versioned ELF symbolsRuss Cox
Fixes #1397. R=iant CC=golang-dev https://golang.org/cl/4444064
2011-04-09ld: 25% fasterRuss Cox
The ld time was dominated by symbol table processing, so * increase hash table size * emit fewer symbols in gc (just 1 per string, 1 per type) * add read-only lookup to avoid creating spurious symbols * add linked list to speed whole-table traversals Breaks dwarf generator (no idea why), so disable dwarf. Reduces time for 6l to link godoc by 25%. R=ken2 CC=golang-dev https://golang.org/cl/4383047
2010-12-086l, 8l: support for linking ELF and Mach-O .o filesRuss Cox
More support for references to dynamic symbols, including full GOT and PLT for ELF objects. For Mach-O everything ends up in the GOT: dealing with the real lazy PLT is too hard for now so we punt. R=iant, iant2 CC=golang-dev https://golang.org/cl/3491042
2010-10-135l, 6l, 8l: first pass cleanupRuss Cox
* Maintain Sym* list for text with individual prog lists instead of using one huge list and overloading p->pcond. * Comment what each file is for. * Move some output code from span.c to asm.c. * Move profiling into prof.c, symbol table into symtab.c. * Move mkfwd to ld/lib.c. * Throw away dhog dynamic loading code. * Throw away Alef become. * Fix printing of WORD instructions in 5l -a. Goal here is to be able to handle each piece of text or data as a separate piece, both to make it easier to load the occasional .o file and also to make it possible to split the work across multiple threads. R=ken2, r, ken3 CC=golang-dev https://golang.org/cl/2335043
generated by cgit v1.3 (git 2.53.0) at 2026-04-16 14:05:30 +0000