Provide a stub _rtld_call_ifunc when a platform doesn't use one of the
common ones or doesn't provide its own.

initfini array support for everyone.

branches: 1.1.4; 1.1.24; 1.1.26;
Preliminary files for AARCH64 (64-bit ARM) support.
Enough for a distribution build.

ld.elf_so: Cite reference for Arm ELF relocations.

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

branches: 1.18.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.17.2;
Whitespace. NFC.

Support ifunc on aarch64. The tests pass at least.

fix various typos in comments, documentation and messages.

Honor addend for R_AARCH64_TLS_TPREL relocation.

branches: 1.13.2;
Adapt https://svnweb.freebsd.org/base?view=revision&revision=342113 to
NetBSD.

This brings us resolving for dynamically loaded libraries and makes
tests/libexec/ld.elf_so/t_thread_local_dtor pass.

With suggestions from joerg@

Fix RTLD_DEBUG_RELOC build

Trailing whitespace

Revise previous to not deadlock.

Improve support for R_AARCH64_TLSDESC relocations.

In large part from FreeBSD.

Initialize new_value to account for bogus return from the function.

branches: 1.7.2; 1.7.4;
Various fixes / changes from Ryo Shimizu / Toru Nishimura to make this
work.

_rtld_call_ifunc copied from other rela platforms by me - not tested in
any way.

explain AARCH64 PLT design

- avoid caddr_t. use Elf_Addr instead.
- iron out rdbg() errors.

Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.2.8;
Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.1.2; 1.1.4;
Preliminary files for AARCH64 (64-bit ARM) support.
Enough for a distribution build.

ld.elf_so aarch64/rtld_start.S: Fix dynamic TLS fast path branch.

Bug found and patch prepared by pho@.

PR lib/58154

ld.elf_so aarch64/rtld_start.S: Sprinkle comments.

No functional change intended.

Prompted by PR lib/58154.

branches: 1.5.2; 1.5.4;
s/interger/integer/ and s/Compensatin/Compensation/ in comments.

branches: 1.4.2;
Adapt https://svnweb.freebsd.org/base?view=revision&revision=342113 to
NetBSD.

This brings us resolving for dynamically loaded libraries and makes
tests/libexec/ld.elf_so/t_thread_local_dtor pass.

With suggestions from joerg@

Improve support for R_AARCH64_TLSDESC relocations.

In large part from FreeBSD.

branches: 1.2.2; 1.2.4;
Various fixes / changes from Ryo Shimizu / Toru Nishimura to make this
work.

_rtld_call_ifunc copied from other rela platforms by me - not tested in
any way.

branches: 1.1.4;
Preliminary files for AARCH64 (64-bit ARM) support.
Enough for a distribution build.

Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

The ld script is no longer necessary.

branches: 1.8.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

Add code to peek into the PLT and determine which PLT entry format
is being used.

Supply two lazy binding routines for Alpha: one that works with the
old PLT format, and one that works with the new.

XXX We currently always use _rtld_bind_start_old() in
_rtld_setup_alpha_pltgot(). We need to add code to peek
into one of the PLT entries to see which format it's in
and pick the correct binding routine.

* Add a linker script which provides a _GOT_END_ symbol that we can
use to find the end of the GOT, rather than relying on _DYNAMIC
to immediately follow the GOT. (A change in current binutils
moved _DYNAMIC, and thus would have broken our Alpha ld.elf_so).
* Add #ifdef'd out code to deal with the new PLT format.

Tidy this up a little.

use CPPFLAGS instead of CFLAGS

branches: 1.1.2;
First cut at an ELF shared loader. Originally from John Polstra's FreeBSD elf
kit, then hacked on by Matt Thomas <matt@3am-software.com>, then by me (to
make it work with new versions of the toolchain, etc.). This runs, but it's
in serious need of cleaning and/or a fair bit of reworking. See the README
file for more information, and a list of things to do.

ld.elf_so/arch/alpha: Fix debug build by initializing symnum earlier.

PR lib/59319: ld.elf_so: build broken with DEBUG, RTLD_DEBUG_RELOC

ld.elf_so on alpha: Add support for secureplt.

ok thorpej

PR port-alpha/57511: ld.elf_so(1) does not support secure PLT for alpha
PR port-alpha/57717: Alpha linker generates LOAD segments (and
generates warnings about them)

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

branches: 1.44.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.43.6; 1.43.14;
Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.41.8;
Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.40.22;
Enable TLS for alpha - a 2nd class^Wtier system in pookaBSD^WNetBSD

alpha_reloc.c diff from joerg on port-alpha.

Add basic locking to ld.elf_so.

Introduce a new type Elf_Symindx for use in decoding the symbol hash table
section and allow this type to be overridden.

The ELF specification says it should always be uint32_t (Elf_Word), but
alpha decided to be different (not sure why). Define Elf_Symindx to be
uint64_t on alpha.

Alpha no longer uses non-standard definitions of Elf64_Sword and
Elf64_Word. Remove the ability to override these types.

Fixes ld.elf_so after Herculean effort from me and martin.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Wrap a few long lines.

Shut gcc up.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

Copy build fix from i386: Fix const issues (cast const pointers
to "const uint8_t *" instead of "caddr_t").

branches: 1.31.4;
Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

branches: 1.30.12;
Remove MD COMBRELOC support since it's now MI.
Enable COMBRELOC for all arches

Remove leading __ from __(const|inline|signed|volatile) -- it is obsolete.

Add __RCSID.

KNF

appease gcc -Wuninitialized

Support LD_BIND_NOW for alpha.

ANSIfy and de-__P().

Skip the lazy PLT relocation if relocbase==0 (useful if libraries are loaded
at their VMA address).

Remove the `self' args to _rtld_relocate_objects() and
_rtld_relocate_nonplt_objects().

Push the _rtld_bind() interface into MD code -- it's just a trivial wrapper
anyway.

Add combreloc code here too.

It is possible for reloc entries to point to unaligned locations; handle
this.

Do not use the implicit addend on REFQUAD relocs (same as GLOB_DAT).

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Implement _rtld_relocate_nonplt_self() on Alpha.

Fix a serious performance problem for large programs on the Alpha.

Large programs need multiple GOTs. The lazy binding stub in the PLT
can be reached from any of these GOTs, but the dynamic linker only
has enough information to fix up the first GOT entry. Thus, calls
through the other GOTs went through the time-consuming lazy binding
process on every call.

This fix rewrites the PLT entries themselves to bypass the lazy binding
for those GOT entries that the dynamic linker can't fixup.

Fix from FreeBSD.

Note that now that we patch up the PLT, we need to put back the "imb"
that was removed from the binder exit path.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Fix one indentation error.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split _rtld_relocate_nonplt_object() into separate MD files.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

There is no need to do an imb after each call to the binder, because we only
patch the GOT, not the PLT. However, do an imb when setting up the PLT thunk,
just in case.

branches: 1.2.2;
Add code to peek into the PLT and determine which PLT entry format
is being used.

Supply two lazy binding routines for Alpha: one that works with the
old PLT format, and one that works with the new.

XXX We currently always use _rtld_bind_start_old() in
_rtld_setup_alpha_pltgot(). We need to add code to peek
into one of the PLT entries to see which format it's in
and pick the correct binding routine.

The ld script is no longer necessary.

Sync with current binutils.

branches: 1.2.2;
Add RCS ID.

* Add a linker script which provides a _GOT_END_ symbol that we can
use to find the end of the GOT, rather than relying on _DYNAMIC
to immediately follow the GOT. (A change in current binutils
moved _DYNAMIC, and thus would have broken our Alpha ld.elf_so).
* Add #ifdef'd out code to deal with the new PLT format.

ld.elf_so on alpha: Add support for secureplt.

ok thorpej

PR port-alpha/57511: ld.elf_so(1) does not support secure PLT for alpha
PR port-alpha/57717: Alpha linker generates LOAD segments (and
generates warnings about them)

branches: 1.16.108;
Salvage the instruction to save the pointer to ps_strings for later use
so that setproctitle() works again. The problem reported by Naoki Fukaumi
on japanese mailing list.

Approved by: Ross Harvey

Minor cleanup.

Update comments.

Pass the calculated relocation offset down to _rtld().

We don't use _GLOBAL_OFFSET_TABLE_ any more, so don't .global it.

Implement _rtld_relocate_nonplt_self() on Alpha.

Fix a serious performance problem for large programs on the Alpha.

Large programs need multiple GOTs. The lazy binding stub in the PLT
can be reached from any of these GOTs, but the dynamic linker only
has enough information to fix up the first GOT entry. Thus, calls
through the other GOTs went through the time-consuming lazy binding
process on every call.

This fix rewrites the PLT entries themselves to bypass the lazy binding
for those GOT entries that the dynamic linker can't fixup.

Fix from FreeBSD.

Note that now that we patch up the PLT, we need to put back the "imb"
that was removed from the binder exit path.

There is no need to do an imb after each call to the binder, because we only
patch the GOT, not the PLT. However, do an imb when setting up the PLT thunk,
just in case.

branches: 1.8.2;
Garbage-collect the OLD_GOT stuff.

Supply two lazy binding routines for Alpha: one that works with the
old PLT format, and one that works with the new.

XXX We currently always use _rtld_bind_start_old() in
_rtld_setup_alpha_pltgot(). We need to add code to peek
into one of the PLT entries to see which format it's in
and pick the correct binding routine.

Use numeric labels.

* Add a linker script which provides a _GOT_END_ symbol that we can
use to find the end of the GOT, rather than relying on _DYNAMIC
to immediately follow the GOT. (A change in current binutils
moved _DYNAMIC, and thus would have broken our Alpha ld.elf_so).
* Add #ifdef'd out code to deal with the new PLT format.

Correct spelling in a comment.

branches: 1.3.8;
Simplify _rtld_start() a little, and shave some cycles. Spefically, there's
no need to save the stack pointer. Just push the space for the cleanup
and obj_main pointers before calling _rtld(), and pop it after loading those
pointers into the appropriate argument registers for the program entry point.

Tidy this up a little.

First cut at an ELF shared loader. Originally from John Polstra's FreeBSD elf
kit, then hacked on by Matt Thomas <matt@3am-software.com>, then by me (to
make it work with new versions of the toolchain, etc.). This runs, but it's
in serious need of cleaning and/or a fair bit of reworking. See the README
file for more information, and a list of things to do.

initfini array support for everyone.

branches: 1.21.2;
Rework ifunc support to address a number of short comings:
- Move to a shared _rtld_call_ifunc for rel and rela architectures
- Architectures using rel format must patch IRELATIVE non-PLT
relocations like RELATIVE in additition to the later ifunc handling
- Consistently record the delta to the end of the relocation group for
non-PLT IRELATIVE relocations

Hidden ifunc is now supported on all ifunc platforms, even when using
-fno-plt. The combination of -fno-plt and relro is broken due to
incorrect GNU ld output though.

branches: 1.20.24;
For earm, emit a MARCH note.

Consistently use LDELFSO_MACHINE_ARCH.

Provide a default LDELFSO_MACHINE_ARCH. hi matt!

atf-run works again - the init/fini stuff didn't get run otherwise.

Changes for MKCOMPAT for earm.

Add support for PT_ARM_EXIDX and __gnu_Unwind_Find_exidx for libgcc's support
of the ARM EHABI.

Handle CPUFLAGS being empty

Make sure CFLAGS is not empty.

If you are using aapcs, you must be using INITFINI

branches: 1.12.2;
Add .init_array/.fini_array support (conditionalized on HAVE_INITFINI_ARRAY).

branches: 1.11.42; 1.11.46;
Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

Remove vestiges of VARPSZ.

Do the _rtld_relocate_nonplt_self() thing here, and nuke the ld script.

Only one linker script is needed.

Nuke RTLD_RELOCATE_SELF on ARM.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

branches: 1.3.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

Initial support for dynamic ELF support on ARM.

Don't provide __gnu_Unwind_Find_exidx if __ARM_DWARF_EH__ is defined

branches: 1.3.2; 1.3.8;
Remove trailing whitespace

Use relocbase, not mapbase.

Add a ld.elf_so internals version of __gnu_Unwind_Find_exidx for that the
libgcc EHABI can find the exception tables for a supplied PC.

Do the _rtld_relocate_nonplt_self() thing here, and nuke the ld script.

Only one linker script is needed.

Only one linker script is needed.

Nuke RTLD_RELOCATE_SELF on ARM.

Only one linker script is needed.

Nuke RTLD_RELOCATE_SELF on ARM.

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

ld.elf_so: Cite reference for Arm ELF relocations.

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

branches: 1.46.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.45.6;
R_ARM_TLS_TPOFF32 needs to adjust the existing value, not blindly
overwrite it.

branches: 1.44.4;
Rework ifunc support to address a number of short comings:
- Move to a shared _rtld_call_ifunc for rel and rela architectures
- Architectures using rel format must patch IRELATIVE non-PLT
relocations like RELATIVE in additition to the later ifunc handling
- Consistently record the delta to the end of the relocation group for
non-PLT IRELATIVE relocations

Hidden ifunc is now supported on all ifunc platforms, even when using
-fno-plt. The combination of -fno-plt and relro is broken due to
incorrect GNU ld output though.

branches: 1.43.2;
init/fini for the main program is handled by crt0.o, so ifunc handling
is skipped right now as it iterates the same list. Don't repeat that
mistake and explicitly take care of it in the dynamic linker.

Add IRELATIVE support for ARM, X86 and PowerPC.

Expand symnum, GCC's uninitialized used tracking is too imprecise.

Drop symbol number from default branch diagnostic, it isn't set at this
point and most likely not valid either.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.38.8;
Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.37.18;
Hook up TLS support on ARM. Tested by martin@, kernel support from matt@

branches: 1.36.4;
Add support for TLS relocations.
From Joerg Sonnenberger

Add basic locking to ld.elf_so.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Make DEBUG build compile.

Shut gcc up.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

Fix const issues (cast const pointers to "const uint8_t *" instead of "caddr_t")

NOTE: change based on ../i386/mdreloc.c 1.27
XXX: not compile tested

branches: 1.28.4; 1.28.6;
Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

branches: 1.27.20;
Remove leading __ from __(const|inline|signed|volatile) -- it is obsolete.

Add __RCSID.

ELF32_ST_TYPE -> ELF_ST_TYPE

Check the type of symbols; if it's a Thumb function, then set the Thumb
bit in the relocated value (JUMP_SLOT, ABS32 & GLOB_DAT).

branches: 1.23.4;
include <string.h> or <stdlib.h> for all prototypes

ANSIfy and de-__P().

Support immediate binding on arm.

Skip the lazy PLT relocation if relocbase==0 (useful if libraries are loaded
at their VMA address).

Remove the `self' args to _rtld_relocate_objects() and
_rtld_relocate_nonplt_objects().

Push the _rtld_bind() interface into MD code -- it's just a trivial wrapper
anyway.

No PC24 relocs will ever be unaligned. Pointed out by mycroft.

It is possible for reloc entries to point to unaligned locations; handle
this.

Use the addend on GLOB_DAT relocs (same as ABS32).

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Do the _rtld_relocate_nonplt_self() thing here, and nuke the ld script.

Add $NetBSD$.

Nuke RTLD_RELOCATE_SELF on ARM.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split _rtld_relocate_nonplt_object() into separate MD files.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

Don't use GOT relocations. Use PC relative for the GOT and GOTOFF for
_DYNAMIC. Make thumb friendly.

branches: 1.11.2;
Add a comment for EABI. Use "pop" instructions to save one instruction.

branches: 1.10.6; 1.10.10;
Add RCSID

Remove clause 3 and 4 from TNF licenses

branches: 1.8.24;
Use BX if available.

Update comments.

Pass the calculated relocation offset down to _rtld().

Do the _rtld_relocate_nonplt_self() thing here, and nuke the ld script.

Nuke RTLD_RELOCATE_SELF on ARM.

branches: 1.3.2;
Fix binder routine to not use a volatile register.

Bugfix for _rtld_start. Enable common plt processing code for arm

Initial support for dynamic ELF support on ARM.

Fix the start symbol.

Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Fix the dynamic linker for hppa using ELF.

Lazy binding doesn't work 100% of the time so force immediate binding.
One possible reason is that the PLT stub blows away r20 which the
compiler might not take into account.

Remove the millicode hack - its not needed anymore.

Get the entry point right.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

Remove vestiges of VARPSZ.

Add support for dynamic linking on HP PA-RISC.

KNF and remove trailing whitespace in previous.

skip R_PARISC_NONE reloc entries instead of segfaulting on them
now windowmaker runs on my C360

ld.elf_so: Cite reference for HP PA-RISC ELF relocations.

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

branches: 1.50.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.49.2;
Set DP early so that any binary functions that override others get the
right value if they're called before _start. This is true of bash where
it provides its own getenv.

Part of port-hppa/56118: sporadic app crashes in HPPA -current

Restore the fptr_t type of {init,fini}{,_array} that was removed when initial
support for indirect functions was added. This fixes {init,fini}_array support
on hppa where each member of the array is (already) a plabel.

Discussed with joerg.

4 files changed, 29 insertions(+), 39 deletions(-)
: ----------------------------------------------------------------------

Avoid compiler warnings about uninitialised symnum

Trailing whitespace

branches: 1.45.6;
Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.43.8;
Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.42.18;
Implement lazy binding on hppa. rump_server needs it!?!?!

Mostly from OpenBSD.

Use the tlsoffset from the correct object.

branches: 1.40.2;
gcc 4.5 generates an extra plabel in ld.elf_so,
so expand the array of preallocated ones.

Add basic locking to ld.elf_so.

Another TLS reloc. Thanks to joerg for a hint.

More PLABELS are required due to TLS stuff.

Handle some TLS relocs.

Whitespace.

Wrap long lines

Reformat comments.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Shut gcc up.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

ld.elf_so grew more PLABELS with dlinfo so bump HPPA_PLABEL_PRE.

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

After a recent WARNS= bump on ld.elf_so it fails to build on hppa,
complaining that we're "discarding qualifier from pointer target
type".

Use const char * instead of caddr_t to avoid the warning and get
distribution building on hppa again.

branches: 1.27.4;
Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

branches: 1.26.2;
Remove clause 3 and 4 from TNF licenses

branches: 1.25.16;
Create _rtld_relocate_plt_object and use it in _rtld_bind and
_rtld_relocate_plt_objects.

No functional change.

Support unaligned DIR32 relocs.

Closes PR 18293

Add __RCSID.

appease gcc -Wuninitialized on hp700.

Copyright maintenance.

Fix the dynamic linker for hppa using ELF.

Lazy binding doesn't work 100% of the time so force immediate binding.
One possible reason is that the PLT stub blows away r20 which the
compiler might not take into account.

Wrap a couple of lines to <80 columns

Whitespace.

Update to new reality. XXX _rtld_bind still needs to be written.

ANSIfy and de-__P().

Remove the `self' args to _rtld_relocate_objects() and
_rtld_relocate_nonplt_objects().

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

Move another declaration that doesn't belong in MI source.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split _rtld_relocate_nonplt_object() into separate MD files.

Remove unused arguments of _rtld_find_symdef().

Make _rtld_setup_pltgot() a consistent interface on all platforms.

Add support for dynamic linking on HP PA-RISC.

Fix the dynamic linker for hppa using ELF.

Lazy binding doesn't work 100% of the time so force immediate binding.
One possible reason is that the PLT stub blows away r20 which the
compiler might not take into account.

Update to new reality. XXX _rtld_bind still needs to be written.

Add support for dynamic linking on HP PA-RISC.

Remove unused file.

branches: 1.1.4;
First cut at mdtls.c for hppa.

Set DP early so that any binary functions that override others get the
right value if they're called before _start. This is true of bash where
it provides its own getenv.

Part of port-hppa/56118: sporadic app crashes in HPPA -current

Trailing whitespace

branches: 1.12.42;
Implement lazy binding on hppa. rump_server needs it!?!?!

Mostly from OpenBSD.

branches: 1.11.2;
match EXIT() with LEAF_ENTRY() so that sizes are actually constants.
fixes binutils 2.21 build issues reported by he and chuq.

Whitespace.

Add the magic branch instruction that is used by GCC's
__canonicalize_funcptr_for_compare() function to fixup relocations in
order to do function pointer comparisons.

From OpenBSD.

Wrap long lines

Reformat comments.

Small tidyup.

Remove clause 3 and 4 from TNF licenses

branches: 1.5.16;
Reformat a comment.

Correct the frame size for a couple of ENTRYs

Fix the dynamic linker for hppa using ELF.

Lazy binding doesn't work 100% of the time so force immediate binding.
One possible reason is that the PLT stub blows away r20 which the
compiler might not take into account.

Update to new reality. XXX _rtld_bind still needs to be written.

Add support for dynamic linking on HP PA-RISC.

Rework ifunc support to address a number of short comings:
- Move to a shared _rtld_call_ifunc for rel and rela architectures
- Architectures using rel format must patch IRELATIVE non-PLT
relocations like RELATIVE in additition to the later ifunc handling
- Consistently record the delta to the end of the relocation group for
non-PLT IRELATIVE relocations

Hidden ifunc is now supported on all ifunc platforms, even when using
-fno-plt. The combination of -fno-plt and relro is broken due to
incorrect GNU ld output though.

branches: 1.14.44;
simplify the logic for compat ld.elf_so and move it here. we now can
find the libc objdir for multiple compat ld.elf_so's, too.

rename LD32DIR to MLIBDIR.

move the defines for RTLD_ARCH_SUBDIR into a sub-sub-makefile so we can
grab these values via reach-over more easily.

branches: 1.11.2;
if LD32DIR is defined:
- look in src/compat/lib/libc for libc_pic.
- define RTLD_ARCH_SUBDIR to "i386" or "sparc" for amd64 and sparc64
builds, respectively
if RTLD_ARCH_SUBDIR is defined, add this path before
RTLD_DEFAULT_LIBRARY_PATH in the default search path.

Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

Split the `self' case out of _rtld_relocate_nonplt_objects, into a new function
_rtld_relocate_nonplt_self(), which is called from _rtld_start.
Now we're completely relocated before main() is called.
We also no longer need _GOT_END_, so junk the ld script.

This code assumes that ld.elf_so only contains RELATIVE relocs, but that's
supposed to be the case for -Bsymbolic anyway.

Get rid of RTLD_RELOCATE_SELF on i386.
* Add a ld.so.script that exports _GOT_END_.
* Prebind the GOT in _rtld_start.
* Skip over GOT relocs in _rtld_relocate_nonplt_objects().
This makes debugging work better at least.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

branches: 1.4.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

Cleanup global variable access so rtld can be self relocating. Also KNF
reloc.c and move md sparc parts to arch/sparc/mdreloc.c
Now we don't need to load at address 0 on the i386 and the mips should be
trivial to fix.

Add i386 bits. Only works with -fpic or -fPIC compiled binaries since
COPY relocations don't work.

simplify the logic for compat ld.elf_so and move it here. we now can
find the libc objdir for multiple compat ld.elf_so's, too.

branches: 1.1.2;
move the defines for RTLD_ARCH_SUBDIR into a sub-sub-makefile so we can
grab these values via reach-over more easily.

Split the `self' case out of _rtld_relocate_nonplt_objects, into a new function
_rtld_relocate_nonplt_self(), which is called from _rtld_start.
Now we're completely relocated before main() is called.
We also no longer need _GOT_END_, so junk the ld script.

This code assumes that ld.elf_so only contains RELATIVE relocs, but that's
supposed to be the case for -Bsymbolic anyway.

Get rid of RTLD_RELOCATE_SELF on i386.
* Add a ld.so.script that exports _GOT_END_.
* Prebind the GOT in _rtld_start.
* Skip over GOT relocs in _rtld_relocate_nonplt_objects().
This makes debugging work better at least.

ld.elf_so/arch/i386: Add ELF references.

Also copy the copyright notice from the file this one was originally
derived from back in 2002.

Create a new header lwp_private.h to contain _lwp_getprivate_fast,
_lwp_gettcb_fast, _lwp_settcb and remove them from mcontext.h, so that:
1. we don't need special hacks to hide them
2. we can include <lwp.h> where needed to get the necessary prototypes
without redefining them locally.

Undo previous lwp.h change

Split __lwp_getprivate_fast and __lwp_*tcb from mcontext.h into a separate
lwp.h file.

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

branches: 1.43.2;
Avoid using uninitialized variable "symnum" when building with DEBUG
enabled by borrowing the rdbg_symname() macro from arch/x86_64.

Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.41.4; 1.41.12;
Rework ifunc support to address a number of short comings:
- Move to a shared _rtld_call_ifunc for rel and rela architectures
- Architectures using rel format must patch IRELATIVE non-PLT
relocations like RELATIVE in additition to the later ifunc handling
- Consistently record the delta to the end of the relocation group for
non-PLT IRELATIVE relocations

Hidden ifunc is now supported on all ifunc platforms, even when using
-fno-plt. The combination of -fno-plt and relro is broken due to
incorrect GNU ld output though.

branches: 1.40.2;
init/fini for the main program is handled by crt0.o, so ifunc handling
is skipped right now as it iterates the same list. Don't repeat that
mistake and explicitly take care of it in the dynamic linker.

Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.37.8;
Remove (now duplicated) target computation.

Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.35.8;
Add support for R_386_TLS_TPOFF32. This patch was created by
Nick Hudson for PR 47061.

branches: 1.34.4; 1.34.6; 1.34.10;
Add basic locking to ld.elf_so.

Add TLS support for AMD64, i386 and SH3.

This material is based upon work partially supported by
The NetBSD Foundation under a contract with Joerg Sonnenberger.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Wrap a few long lines.

Shut gcc up.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

Fix const issues (cast const pointers to "const uint8_t *" instead of "caddr_t")

branches: 1.26.4; 1.26.6;
Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

abort() if we are trying to use an undefined weak symbol from the plt. Remove
check from relocate_plt_object() since we cannot return _rtld_sym_zero anymore.
Code from gimpy.

handle sym_zero like x86_64; other ports might need this too.

branches: 1.23.12;
Remove MD COMBRELOC support since it's now MI.
Enable COMBRELOC for all arches

Coverity CID 923: Avoid NULL deref.

Add __RCSID.

appease gcc -Wuninitialized

branches: 1.19.4;
ANSIfy and de-__P().

Skip the lazy PLT relocation if relocbase==0 (useful if libraries are loaded
at their VMA address).

Remove the `self' args to _rtld_relocate_objects() and
_rtld_relocate_nonplt_objects().

Push the _rtld_bind() interface into MD code -- it's just a trivial wrapper
anyway.

Make immediate binding work again by actually implementing
_rtld_relocate_plt_objects(). Note that this is for i386 only;
any efforts to make it work on other platforms are left to
those who are using them...

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Split the `self' case out of _rtld_relocate_nonplt_objects, into a new function
_rtld_relocate_nonplt_self(), which is called from _rtld_start.
Now we're completely relocated before main() is called.
We also no longer need _GOT_END_, so junk the ld script.

This code assumes that ld.elf_so only contains RELATIVE relocs, but that's
supposed to be the case for -Bsymbolic anyway.

Add $NetBSD$.

Get rid of RTLD_RELOCATE_SELF on i386.
* Add a ld.so.script that exports _GOT_END_.
* Prebind the GOT in _rtld_start.
* Skip over GOT relocs in _rtld_relocate_nonplt_objects().
This makes debugging work better at least.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split _rtld_relocate_nonplt_object() into separate MD files.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

Build ld.elf_so with -fvisibility=hidden. Exploit this for i386/x86_64
to simplify the assembler code.

Remove clause 3 and 4 from TNF licenses

branches: 1.9.30;
Shorten rtld_start() by 2 instructions or 8 bytes, and make it not use GOT
entries.

We don't need to save quite as many registers in the stub.

Update comments.

Pass the calculated relocation offset down to _rtld().

Split the `self' case out of _rtld_relocate_nonplt_objects, into a new function
_rtld_relocate_nonplt_self(), which is called from _rtld_start.
Now we're completely relocated before main() is called.
We also no longer need _GOT_END_, so junk the ld script.

This code assumes that ld.elf_so only contains RELATIVE relocs, but that's
supposed to be the case for -Bsymbolic anyway.

Get rid of RTLD_RELOCATE_SELF on i386.
* Add a ld.so.script that exports _GOT_END_.
* Prebind the GOT in _rtld_start.
* Skip over GOT relocs in _rtld_relocate_nonplt_objects().
This makes debugging work better at least.

branches: 1.3.12;
Remove unneeded args for rtld (kleink)

Be consistant about the .rtld_start and _rtld_start

Add i386 bits. Only works with -fpic or -fPIC compiled binaries since
COPY relocations don't work.

Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

Remove vestiges of VARPSZ.

Add a _rtld_relocate_nonplt_self() here too.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

branches: 1.4.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

Define VARPSZ so dynamic binaries work on both 4K and 8K page size machines.

Add m68k code.

ld.elf_so/arch/m68k: Cite reference for m68k elf relocations.

Missing anything about thread-local storage; presumably TLS support
on m68k is a gnuish invention.

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

ld.elf_so/arch/m68k: Add copyright notice from the original.

The bulk of mdreloc.c was copied from libexec/ld.elf_so/reloc.c
rev. 1.58.

XXX Still need some elven references -- any m68k wizards have this
lore handy in their libraries?

Create a new header lwp_private.h to contain _lwp_getprivate_fast,
_lwp_gettcb_fast, _lwp_settcb and remove them from mcontext.h, so that:
1. we don't need special hacks to hide them
2. we can include <lwp.h> where needed to get the necessary prototypes
without redefining them locally.

branches: 1.34.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.33.6; 1.33.14;
Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.31.8;
Remove duplicated __RCSIDs I added years ago - I blame CVS.

Spotted by Miod Vallat

Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.29.18;
Add TLS support for m68k.

branches: 1.28.4;
Add basic locking to ld.elf_so.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Wrap a few long lines.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

Fix const issues (cast const pointers to "const uint8_t *" instead of "caddr_t")

NOTE: change based on ../i386/mdreloc.c 1.27
XXX: not compile tested

branches: 1.22.4; 1.22.6;
RCSID police

Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

branches: 1.20.20;
in _rtld_bind() initialise result to appease GCC4.

Add __RCSID.

Support immediate PLT binding on m68k. Tested on NetBSD/sun3 using the new
version of tme.

Not far now...

branches: 1.17.4;
ANSIfy and de-__P().

Skip the lazy PLT relocation if relocbase==0 (useful if libraries are loaded
at their VMA address).

Remove the `self' args to _rtld_relocate_objects() and
_rtld_relocate_nonplt_objects().

Push the _rtld_bind() interface into MD code -- it's just a trivial wrapper
anyway.

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Add a _rtld_relocate_nonplt_self() here too.

Add $NetBSD$.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split _rtld_relocate_nonplt_object() into separate MD files.

Make _rtld_setup_pltgot() a consistent interface on all platforms.

Merge riastradh-drm2 to HEAD.

Use new macros from <machine/asm.h> to be more portable

branches: 1.9.4; 1.9.26; 1.9.32;
Remove clause 3 and 4 from TNF licenses

branches: 1.8.30;
Update copyright.

Similar to other rela platforms, do not use any GOT entries (other than the
first entry, which is a special case) in rtld_start, because they could be
all 0s. Instead we use the difference between the real _DYNAMIC address
(which we can determine on 68k with a "lea (%pc,_DYNAMIC),..." and the
base-relative one (at the beginning of the GOT) to figure out the relocation
offset.

Not needed for binutils-current, but I might as well fix it now.

Update comments.

Pass the calculated relocation offset down to _rtld().

Add a _rtld_relocate_nonplt_self() here too.

branches: 1.3.8;
Make __SVR4_ABI__ optional.

branches: 1.2.2;
Bump text alignments to 4 bytes.

Add m68k code.

Add a newline

Simplify ELFSIZE by using _MIPS_SZPTR

branches: 1.19.6; 1.19.12;
make sure to look in CFLAGS, COPTS and CPPFLAGS for abi options.

fixes sgimips64 build of n64 ld.elf_so.

use COPTS for -G0.
replace ${CPUFLAGS:M-mabi=64:M-mabi=o64} with two constructs.
the former doesn't seem to work anymore.

Merge from matt-nb5-mips64:
Add N32/N64 support for mips dynamic loader.

Fix start symbols for new binutils.

branches: 1.15.32;
Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

-I${.CURDIR} is done at the top-level, so there's no need to do it here.

This ld script is now unnecessary.

Snapshot of work to make MIPS ld.elf_so relocatable.

branches: 1.9.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

This should use MACHINE_ARCH and test on "mipseb" instead of MACHINE and
"newsmips"

Remove the ld.so link for ld.elf_so - the compat13 package takes care
of this.

branches: 1.5.2;
Introduce pre-preocessor symbol RTLD_INHIBIT_COPY_RELOCS.
Currently, only mips does not include COPY_RELOCs code.

PR/6824: Erik Bertelsen: Missed arch directory in recent move.

${DESTDIR} isn't needed - which isn't what the example in
/usr/share/mk/bsd.README seems to indicate.

branches: 1.2.2;
Make this work with objdirs.

Add support for mips.

This ld script is now unnecessary.

Snapshot of work to make MIPS ld.elf_so relocatable.

branches: 1.2.6;
Don't try to get libc_pic from the libc compile directory. If we're doing a
build, libc has already been installed.

branches: 1.1.2;
Add support for mips.

Create a new header lwp_private.h to contain _lwp_getprivate_fast,
_lwp_gettcb_fast, _lwp_settcb and remove them from mcontext.h, so that:
1. we don't need special hacks to hide them
2. we can include <lwp.h> where needed to get the necessary prototypes
without redefining them locally.

ld.elf_so(1): Cite reference for MIPS ELF relocations.

This doesn't cover everything -- it's missing the thread-local
storage relocations -- but it's a start.

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

branches: 1.75.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.74.6;
Don't or the got object in, just assign it. Fixes cc -mabi=64 hello.c -lcrypto
Now all 64 bit binaries work, and I tested that we did not break the 32 bit
ones
XXX: That 0x80000000 seems wrong for 64 bit stuff.

simplify pointer gymnastics that sprained gcc-8

branches: 1.72.4; 1.72.6;
don't forget to eat the high bits.

Fix typo in comment

from freebsd

fix debug build

Add IRELATIVE support for ARM, X86 and PowerPC.

Replace last use of r_type.

Fix C&P bug. Deal with more MIPS hacks overriding def.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.65.8;
where is already void *

make debug code compile again
from christos

Add basic support for indirect functions. It allows providing a public
function symbol with an implementation choosen at run time.
Refactor calls to functions by address in ld.elf_so to create temporary
function descriptors on the stack, if the address is not leaked outside.

Limitations:
- no support for initialising static storage with function pointers
- no support for unnamed resolver functions

Inspired by FreeBSD's r228435 by kib@freebsd.org.

branches: 1.62.22;
Add basic locking to ld.elf_so.

Add support for the MIPS TLS reloc types in shared libraries.

Make the GOT1_MASK 64-bit clean.

Reduce header pollution for mdreloc.c. Make Obj_Entry argument of
_rtld_relocate_nonplt_objects non-const in preparation for TLS support.

Shut gcc up.

PR/39240: Satoshi Suetake: Don't fail when attempting to resolve weak symbols
when we are doing immediate binding, leave them alone and they will be dealt
with later during lazy binding. From skrll@

Merge from matt-nb5-mips64:
Add N32/N64 support for mips dynamic loader.

Remove trailing \n in calls to _rtld_error: a newline is automatically
added by a call to the function.

fix signed/unsigned comparisons and const cast away (untested)

branches: 1.53.4; 1.53.10;
Refactor common code to _rtld_relocate_plt_object to i386 and arm so they
act like the other versions.
In _rtld_bind, if the result is 0, call _rtld_die.
Initialize _rtld_sym_zero.st_value to -_rtld_objself.maprelocbase. Now when
the symbol is resolved, st_value + maprelocbase will equal 0 and the above
check in _rtld_bind will fire and a call to NULL will be avoided.

branches: 1.52.20;
Fix unaligned loads and stores generated by gcc4. Problem described in
http://mail-index.NetBSD.org/tech-toolchain/2006/06/27/0001.html.
This cleaner version of the patch from Christos - thanks!

Remove empty lines.

Add LD_BIND_NOW support for mips.

This is the last arch to be done so remove the large ugly #if defined()
stuff in reloc.c.

Remove leading __ from __(const|inline|signed|volatile) -- it is obsolete.

Add __RCSID.

Initialize a bunch of local variables in _rtld_relocate_nonplt_self().
Found by -Wuninitialized while compiling for newsmips.

Reviewed by lukem.

Apply fixes from Charles:

- Fix how _rtld_relocate_nonplt_self deals with REL32 relocations.

- Change the assert so that it is correct for binutils 2.14 and 2.15.

There are still problems with the libraries generated with binutils 2.15,
but at least ld.elf_so doesn't crash.

Restore handling of reloc entries that point to unaligned locations
that seems to have disappeared in rev 1.34.

Thanks to Jason Thorpe for suggesting where to look.
Fixes the simple test case in PR port-mips/23366.

Make the effect of the hack clearer.

One more tweak...

Make the comment a little more accurate.

Temporary workaround for some binutils/ld lossage. See the comment for more
information.

include <string.h> or <stdlib.h> for all prototypes

ANSIfy and de-__P().

Correct the in_plt parameter of a couple of _rtld_find_symdef calls.

The mips_reloc.c case is a no-op as _rtld_symlook_obj ignores in_plt for
MIPS.

OK'ed by Charles.

Minor cleanup.

Add an iffy heuristic that allows us to do lazy binding with new objects, but
detect old objects and deal with them.

Minor cleanup, for clarity.

Resolve the GOT before doing relocations. Then, when doing relocations, for
symbols in the global part of the symbol table, use the updated GOT entry
rather than doing a lookup. (This provides the same effect as `-z combreloc'
on other platforms -- at most one lookup is done per symbol.)

Unfortunately, it is necessary to turn off lazy binding on MIPS. As the
comment says:

* XXX DANGER WILL ROBINSON!
* You might think this is stupid, as it intentionally
* defeats lazy binding -- and you'd be right.
* Unfortunately, for lazy binding to work right, we
* need to a way to force the GOT slots used for
* function pointers to be resolved immediately. This
* is supposed to be done automatically by the linker,
* by not outputting a PLT slot and setting st_value
* to 0, but GNU ld does not do so reliably.

It is possible for reloc entries to point to unaligned locations; handle
this.

In _rtld_bind_mips(), if the symbol is undefined, die.

Add an explanatory comment.

The sense of the SHN_ABS test has always been reversed. Fortunately nobody
ever tried to reference stuff like _DYNAMIC_LINK and _gp_disp in C code...

Put back the lazy binding. For some bizarre reason, the linker occasionally
does not create a PLT entry for a symbol, so we test st_value!=0 to see
whether we can do a PLT fixup.

Er, turn off lazy binding for the moment. It doesn't seem to be fully working.

Simplify the GOT relocation code somewhat.

Actually do lazy binding on this platform.

Remove an old comment.

_rtld_bind() is not used on MIPS. Should probably move it to MD code.

Nuke -DRTLD_RELOCATE_SELF and `dodebug' from orbit.

_rtld_bind_start() is not used in MI code, so declare it in the MD code.

Slight tweak.

The GOT is Elf_Addr[], not Elf_Word[]...

Clean up a little.

Move GOT relocation code from _rtld_setup_pltgot() to
_rtld_relocate_nonplt_objects(). Add GOT self-relocation in
_rtld_relocate_nonplt_self().
MIPS ld.elf_so can now relocate itself.

Snapshot of work to make MIPS ld.elf_so relocatable.

Pass down an additional flag to _rtld_relocate_nonplt_objects() which
indicates whether we're relocating ld.elf_so itself. Use this in some places
rather than hackish tests on `dodebug'. (The Alpha and HPPA `dodebug' tests
were actually noops, because RTLD_RELOCATE_SELF is not set, and therefore
dodebug is always true.)

Introduce a new flag, `isdynamic', which is used to remember whether the
executable was of type ET_DYN. Use this instead of `mainprog' to determine
whether we need to do base-relative fixups of the PLT. (This allows loading
non-relocatable objects, should we desire to do that at some point...)

More const poisoning. Now the entire _rtld_bind() path useds a const Obj_Entry.

Re-poison a lot of consts, now that the mark shite is gone.

Split _rtld_relocate_plt_object() into two MD functions:
* _rtld_relocate_plt_lazy() fixes up all the relocs pointing to the PLT. (On
most platforms it just does a simple base-relative fixup; on SPARC it does
nothing.)
* _rtld_relocate_plt_object() does immediate binding for a PLT entry.
The basic gist is that this saves a bit of time on SPARC (where the iteration
through the pltrela table was gratuitous), and a little less time on all other
platforms. A whole lot of #ifdef'ed crap is moved out of reloc.c, too.

NOT tested on: hppa sh x86_64

Partially fix up some debug printf()s that don't need to use defobj.

A few things:
* Pass a symbol number to _rtld_find_symdef(), not a r_info.
* Don't try to do a symbol lookup when we find an unsupported relocation;
instead get the symbol name from the referencing object's strtab.
* Add preliminary support for `-z combreloc'-style startup optimization on
i386, `#ifdef COMBRELOC'.

Rename _rtld_relocate_nonplt_object() to _rtld_relocate_nonplt_objects(),
and push the outer loop into it. This actually shaves a couple % off startup
time at least on PCs.

Split MIPS relocation goo into mips_reloc.c.

Remove unused arguments of _rtld_find_symdef().

Make _rtld_setup_pltgot() a consistent interface on all platforms.

branches: 1.5.2;
Fix bug found by Izumi Tsutsui -- if _rtld_find_symdef returned NULL, the
runtime linker would crash. Restore behavior similar to version 1.3, where
the runtime linker continues on, ignoring the symbol.

Fix how underfined weak symbols are treated -- before, ld.so would do nothing
with them, rather than defaulting them to zero. This caused breakage with
the drawf EH stuff and init/fini code when they weren't used by the caller
(and hence the appropriate handlers were left undefined). Also fix an un-
initialized variable in symbol.c that only MIPS MD code tripped over.

branches: 1.3.4;
Make this more likely to compile with ld.elf_so changes. (But this is
untested.)

Update to match new SVR4-style definition names in <sys/exec_elf.h>.

branches: 1.1.2; 1.1.6;
Add support for mips.

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

branches: 1.10.58;
Merge from matt-nb5-mips64:
Add N32/N64 support for mips dynamic loader.

branches: 1.9.44;
Minor cleanup.

Add an iffy heuristic that allows us to do lazy binding with new objects, but
detect old objects and deal with them.

DOH! Adjust all the stack slots in _rtld_bind_start() so that the saved $a0
is not in _rtld_bind_mips()'s $a3 argument save area.

Update comments.

Snapshot of work to make MIPS ld.elf_so relocatable.

branches: 1.4.12;
Don't include <machine/regdef.h>.

Avoid confusing various C preprocessors by avoiding # [0-9]

branches: 1.2.2;
Oops - when assembled with PIC, the jal gets expanded, so what used to be
in the branch delay slot was no longer getting executed at the proper time.
This resulted in a corrupt ps_strings pointer and caused programs trying to
use ps_strings to fail.

Add support for mips.

Add a newline

New files for OR1K support

Create a new header lwp_private.h to contain _lwp_getprivate_fast,
_lwp_gettcb_fast, _lwp_settcb and remove them from mcontext.h, so that:
1. we don't need special hacks to hide them
2. we can include <lwp.h> where needed to get the necessary prototypes
without redefining them locally.

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

branches: 1.4.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.3.6; 1.3.14;
Add IRELATIVE support for ARM, X86 and PowerPC.

Replace COMBREL with just-in-time check in _rtld_relocate_nonplt_objects.

The COMBREL logic predates thread-safety of the dynamic linker and
breaks the use of shared locks for the common symbol lookup case. It is
unlikely to provide any benefit for lazy binding or PLT lookups, so
provide equivalent functionality in the non-PLT relocation handling loop
by checking if the symbol used by the current relocation is the same as
the one used during the last lookup. No inter-object cachine is done as
it is also unlikely to be benefical.

Testing with Firefox startup on AMD64 shows a small performance gain by
the new method.

branches: 1.1.8;
New files for OR1K support

New files for OR1K support

ld.elf_so powerpc: remove bogus ldscript

This ldscript is not needed and actually makes things worse by putting
everything in one LOAD section, which then needs to have rwx permission.
Remove it so that we get two LOAD sections with better permissions.
Fixes PR 57323.

branches: 1.16.12;
Rework ifunc support to address a number of short comings:
- Move to a shared _rtld_call_ifunc for rel and rela architectures
- Architectures using rel format must patch IRELATIVE non-PLT
relocations like RELATIVE in additition to the later ifunc handling
- Consistently record the delta to the end of the relocation group for
non-PLT IRELATIVE relocations

Hidden ifunc is now supported on all ifunc platforms, even when using
-fno-plt. The combination of -fno-plt and relro is broken due to
incorrect GNU ld output though.

branches: 1.15.14;
Use -fPIC since powerpc64 is always compiled as -fPIC and -fpic would cause
__PIC__ to change.

Build position independent on PPC64, too.

powerpc64 changes

branches: 1.12.2; 1.12.8;
avoid linker warnings with the new binutils by not forcing ld.elf_so
to be soft-float. the floating-point usage in ld.elf_so is only
because of stdarg functions like printf(), and gcc 4.5 is good
about not actually executing the FP instructions in such functions
unless FP values are passed to them, which ld.elf_so doesn't do.

Fix start symbol for newer binutils.

Explicitly prefix ld(1) options in LDFLAGS with "-Wl," rather than
using the ${LDFLAGS:@F@-Wl,$F@} make substitution because that breaks
if LDFLAGS is already set.

Move common LDFLAGS into Makefile from arch/*/Makefile.inc

Whitespace.

Remove vestiges of VARPSZ.

-I${.CURDIR} is done at the top-level, so there's no need to do it here.

branches: 1.5.2;
Grumble. Put compiler options back into CPPFLAGS for now, since
they're needed to build .S files with the correct PIC options.

XXX Really needs cleanup in <bsd.*.mk> to do this properly.

Don't put compiler options into CPPFLAGS.

Add code to use the kernel provided page size.
Enable this on the powerpc only for now.

PR/6824: Erik Bertelsen: Missed arch directory in recent move.

Add powerpc support.

ld.elf_so powerpc: remove bogus ldscript

This ldscript is not needed and actually makes things worse by putting
everything in one LOAD section, which then needs to have rwx permission.
Remove it so that we get two LOAD sections with better permissions.
Fixes PR 57323.

branches: 1.4.36;
Change OUTPUT to powerpc:common to make powerpc64 ld happy

branches: 1.3.54; 1.3.60;
Sync with current binutils.

branches: 1.2.6;
Don't try to get libc_pic from the libc compile directory. If we're doing a
build, libc has already been installed.

Add powerpc support.

Create a new header lwp_private.h to contain _lwp_getprivate_fast,
_lwp_gettcb_fast, _lwp_settcb and remove them from mcontext.h, so that:
1. we don't need special hacks to hide them
2. we can include <lwp.h> where needed to get the necessary prototypes
without redefining them locally.

ld.elf_so(1): Nix trailing whitespace.

No functional change intended.

ld.elf_so: Cite reference for PowerPC ELF relocations

PR lib/58455: Missing references for processor-specific ELF
relocation semantics

branches: 1.63.2;
Fix interactions of initial-exec TLS model and dlopen

(1) If an initial-exec relocation was used for a non-local symbol
(i.e. the definition of the symbol is in a different DSO), the
computation of the static TLS offset used the wrong DSO.
This would effectively mean the wrong address was computed
(PR toolchain/50277, PR pkg/57445).

Fix this by forcing the computation of the correct DSO (the one defining
the symbol).

This code uses __UNCONST to avoid the vast interface changes for this
special case.

(2) If symbols from a DSO loaded via dlopen are used with both
global-dynamic/local-dynamic and initial-exec relocations AND
a initial-exec relocation was resolved first in a thread, a split brain
situation could exist where the dynamic relocations would use one memory
block (separate allocation) and the initial-exec relocations the static
per-thread TLS space.

(3) If the initial-exec relocation in (2) is seen after any thread has
already used a GD/LD allocation, bail out. Since IE relocations are used
only in the GOT, this will prevent the dlopen. This is a bit more
aggressive than necessary, but a full blown reference counting doesn't
seem to be justified.

branches: 1.62.2;
Fix copy & pasto: DTPREL relocations do not need to allocate a static
TLS index. Patch from joerg@

new binutils/gcc started emitting R_PPC_UADDR32 reloc entries, so for now
treat them like R_PPC_ADDR32
XXX
these relocs have been observed in the xf86-video-radeon driver, but only in
the AtomBios support code, which is unused on PowerPC. This allows the driver
to load but it's not clear if the affected parts would actually function.

Use existing lo() and hi() macros. Same object code is generated.