tree ad260aa56536235b5e69659d0bd2710e195611ac
parent 4196fabf75a2b9ad9c827761c02443b09786e086
author Fangrui Song <maskray@google.com> 1560521355 +0000
committer Fangrui Song <maskray@google.com> 1560521355 +0000

[ELF] Don't emit dynamic relocations with weak undef in writable sections

In processRelocAux(), our handling of 1) link-time constant and 2) weak
undef is the same, so put them together to simplify the logic.

This moves the weak undef code around. The result is that: in a writable
section (or -z notext), we will no longer emit dynamic relocations for
weak undefined symbols.

The new behavior seems to match GNU linkers, and improves consistency
with the case of a readonly section.

The condition `!Config->Shared` was there probably because it is common
for a -shared link not to specify full dependencies. Keep it now but we
may revisit the decision in the future.

gABI says:

> The behavior of weak symbols in areas not specified by this document is
> implementation defined. Weak symbols are intended primarily for use in
> system software. Applications using weak symbols are unreliable since
> changes in the runtime environment might cause the execution to fail.

Reviewed By: ruiu

Differential Revision: https://reviews.llvm.org/D63003

git-svn-id: https://llvm.org/svn/llvm-project/lld/trunk@363399 91177308-0d34-0410-b5e6-96231b3b80d8
