[ELF2] R_X86_64_COPY relocation implemented

[grimar]

Summary

R_X86_64_COPY relocation implemented.

It fixes (at least I checked the mandelbrot set case):
https://llvm.org/bugs/show_bug.cgi?id=25283

It also fixed:
https://llvm.org/bugs/show_bug.cgi?id=25175

[grimar]

ELF/Writer.cpp

414

I just not sure what to use here for RoundUpToAlignment. May be should find the largest symbol and use its size for that ?

[ruiu]

ELF/InputSection.cpp

86

E->Sym.getType() is accessible from Body, so you can only pass Body to relocNeedsCopy. Then you can write.

if (Target->relocNeedsCopy(Type, Body)) {
  Type = Target->getCopyReloc();
} else if (Target->relocNeedsPlt(Type, Body)) {
...

ELF/OutputSections.cpp

171

Shared is also derived from Body, so you don't have to pass to that function.

194–196

} else if (NeedsCopy) {

203–206

Can you return here?

628

Revert the condition in if

if (SS.NeedsCopy)
  return Out...;
return 0;

1005

Remove {}. What's the point of setting Bss to OutSec? I just don't understand what that code is for.

ELF/Symbols.h

287–288

uintX_t OffsetInBss = 0;
bool NeedsCopy = false;

ELF/Target.cpp

346–348

We only create copy relocations, no? Copy relocations are consumed only by the dynamic linker.

ELF/Writer.cpp

210–211

What does this code do?

216

If Body needs a copy relocation, it never need a GOT, no? If so, relocNeedsGot should take care of that.

[grimar]

Review comments addressed.

ELF/InputSection.cpp

86

No, its not. It accessible from ELFSymbolBody, which is template and inherits SymbolBody. So anyways dyn_cast with using of concrete ELFT will be needed inside relocNeedsCopy. Did you mean that is correct way ?
I changed it in this way in updated patch.

ELF/OutputSections.cpp

171

Ditto, changed.

194–196

Ok.

203–206

No. Because below that ifs section there is a code which I need:

if (IsRela)
  static_cast<Elf_Rela *>(P)->r_addend = Addend;

628

Ok.

1005

Point is to have correct Ndx in .symtab. Below output of readelf with this code and without:
with:

55: 00000000000121f8     8 OBJECT  GLOBAL DEFAULT   26 stdout

w/o:

55: 00000000000121f8     8 OBJECT  GLOBAL DEFAULT  UND stdout

26 is bss section.
I know you dont want to emulate ld behavior but thats just 3 lines of code that not only make behavor consistent with ld, which is good here I believe, but also make more clear symbol status for those who look into that table. Bss section index looks much better that UND. At least it gives surety that symbol was found and processed.

ELF/Symbols.h

287–288

Ok.

ELF/Target.cpp

346–348

Ok, that code was called because of reassigning type of relocation in InputSection.cpp:

line 87:

Type = Target->getCopyReloc();

That`s really not nessecary to do. Fixed.

ELF/Writer.cpp

210–211

1. Founds if relocNeedsCopy and sets is to SharedSymbol->NeedsCopy which is used in void SymbolTableSection<ELFT>::writeGlobalSymbols to write correct Ndx of body section.

2. GNU ld places symbols that needs copy relocations to .dynbss and its relocations to .rel[a].bss. Then "linker script puts the .dynbss section into the .bss section of the final image". I dont see the reasons to do the equal things if we can just allocate space in bss directly. But what we really need is to be sure that we dont create .rela.dyn relocations for one symbol twice. Thats why we have to use InRelaBss flag. It prevents to call Out<ELFT>::RelaDyn->addReloc({C, RI}); (which is at the end of this method) twice or more.

Its like Out<ELFT>::Got->addEntry(Body) sets got index and then if (Body->isInGot()) continue; called for the same.

216

Probably you`re right. The same should be applied for relocNeedsPlt then.

[grimar]

About https://llvm.org/bugs/show_bug.cgi?id=25175:

I found that this patch fixes it for -O3/O2/O1, so both ld and lld produces R_X86_64_COPY _ZSt4cout and executable works fine.
But when I compile with -O0:

#include <iostream>
int main() { std::cout << "hello\n"; }

~/LLVM/build/bin/clang++ -fuse-ld=lld2 -o out -O0 main.c
~/LLVM/build/bin/clang++ -o out-ld -O0 main.c

then out contains R_X86_64_64 _ZSt4cout, but out-ld still has R_X86_64_COPY _ZSt4cout. Is it clang issue of lld one ?
Anyways I think that fix is for another patch.

[grimar]

then out contains R_X86_64_64 _ZSt4cout, but out-ld still has R_X86_64_COPY _ZSt4cout. Is it clang issue of lld one ?
Anyways I think that fix is for another patch.

And I mean that out crashes but out-ld works.

[ruiu]

ELF/OutputSections.cpp

203–206

This makes me think whether this function as a whole is correct or not. If IsRela is false, we compute an addend and then discard that value? If that information is discardable, what's the point of computing that value here?

1002

I think you don't want to call repl(). Body->repl() may not be of type SharedSymbol if the same symbol is resolved to something else.

if (cast<SharedSymbol<ELFT>>(Body)->NeedsCopy)
  Outsec = Out<ELFT>::Bss;
break;

ELF/Target.cpp

253

Remove this blank line.

254

Do you need "lld::elf2::" namespace specifiers?

254–259

You can make this a bit shorter.

if (Type == R_X86_64_32S || Type == R_X86_64_32 || Type == R_X86_64_PC32)
  if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(&S))
    return SS->Sym.getType() == STT_OBJECT;
return false;

ELF/Writer.cpp

414

st_size is too large to align. (If a copy relocation points to an array, st_size can be very large.) Maybe we should align to some reasonable boundary, say, 32-byte boundaries for now. I don't think we are going to have tons of copy relocations, so doing something simple should suffice.

[grimar]

ELF/OutputSections.cpp

203–206

Probably it needs early return after

uintX_t OrigAddend = 0;

if IsRela false. But that is not for this patch I guess ?

ELF/Writer.cpp

414

I found the next comment in gnu code (http://www.opensource.apple.com/source/gdb/gdb-213/src/bfd/elf64-x86-64.c):

/* We need to figure out the alignment required for this symbol.  I
   have no idea how ELF linkers handle this.	16-bytes is the size
   of the largest type that requires hard alignment -- long double.  */
/* FIXME: This is VERY ugly. Should be fixed for all architectures using
   this construct.  */

So it looks we can use 16.
Also I guess even if we take 32 bytes then alignment should be calculated as max(Sym.st_size, 32) ?

[grimar]

ELF/OutputSections.cpp

203–206

*before

[ruiu]

ELF/OutputSections.cpp

203–206

Right, this is not for this patch. It's just that this is something we want to take a look (after this patch).

ELF/Writer.cpp

414

Do you mean min(Sym.st_size, 32)?

There are actually some instructions that require 32 -byte alignment such as some AVX instructions, but we probably don't have to take care of them for the copy relocation.

There seems to be no "right thing to do" here. Saving a few bytes per one copy relocation using a clever technique is very unlikely to worth the effort. How about this: Always align to 16-byte boundaries. This is very easy to understand.

[grimar]

ELF/Writer.cpp

414

Yes, "min" certainly.
Ok, I`ll align to 16 then.

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

1002

Fixed.

ELF/Target.cpp

253

Fixed.

254

Fixed.

254–259

Fixed.

[ruiu]

ELF/Symbols.h

96

Can you move this to SharedSymbol? This increases the size of SymbolBody at least one byte, but this field is not going to be used except for SharedSymbol.

ELF/Writer.cpp

209

No else after continue.

412

Add a brief comment here to say that we don't know the exact alignment requirement for the data copied by a copy relocation, so align that to 16 byte boundaries (which we think is large enough) unconditionally.

[grimar]

Review comments addressed.

ELF/Symbols.h

96

I just removed it at all. SharedSymbol has NeedsCopy flag which is sufficient to replace the single use of InRelaBss.

ELF/Writer.cpp

209

Done.

412

Done.

[grimar]

Added R_X86_64_64 to X86_64TargetInfo::relocNeedsCopy.
It can be met if compile sample from https://llvm.org/bugs/show_bug.cgi?id=25175 with -O0.
This is one of prerequisites to fix -O0 crash. Other part of fix is for another following patch since relative to lazy relocations.

[ruiu]

ELF/OutputSections.cpp

627

Drop const.

ELF/Writer.cpp

203–209

I'm trying to understand this. So, if two or more relocations exist for a shared symbol, the last relocation's NeedsCopy may override the previous results? Is this correct?

[grimar]

ELF/Writer.cpp

203–209

What kind of relocations ? According to current logic plt relocations will never happen because it is not function and so the only possible case is relocNeedsGot() which implemented as

bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {

return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);

}

that gives us the only case is R_X86_64_GOTPCREL.
Is it possible that symbol will require both R_X86_64_GOTPCREL and copy relocation ? If I understand correctly that case - we can use copy relocation here. So I see nothing wrong, please correct me if I am mistaken.

[grimar]

ELF/Writer.cpp

203–209

I am wrong here I think, I need to investigate that case, pelase ignore my comment.

[ruiu]

ELF/Writer.cpp

203–209

Is that the same as this?

if (auto *E = dyn_cast<SharedSymbol<ELFT>>(Body)) {
  E->NeedsCopy = E->NeedsCopy || Target->relocNeedsCopy(Type, *Body);
  if (E->NeedsCopy)
    continue;
}

[grimar]

ELF/Writer.cpp

203–209

No, its not. Because in your code any relocation that needs copy will lead to continue and that will not add the relocation to reladyn at the bottom of method.
I am trying to add the copy relocation reladyn entry but only once for symbol.

[grimar]

ELF/Writer.cpp

203–209

So I think my code is correct:
if this is copy relocation that if it is the first one, it will pass through and create the reladyn entry.
If this is copy relocation and it is not the first one - nothing shall be done here, it continues;
If this is not copy relocation it will change nothing and continue checking other relocation types.

[ruiu]

ELF/Writer.cpp

203–209

Then how about this?

if (auto *E = dyn_cast<SharedSymbol<ELFT>>(Body)) {
  if (E->NeedsCopy)
    continue;
  E->NeedsCopy = Target->relocNeedsCopy(Type, *Body);
}

[grimar]

ELF/Writer.cpp

203–209

That should work. I think I was need bool NeedsCopy variable few iterations ago and just forgot to remove it. Thats why such strange construction happened.

[ruiu]

Then LGTM with that change. Thank you for doing this!

[grimar]

Revision: 251526

ELF/InputSection.cpp

if (SymIndex < SymTab->sh_info) {
                           BaseAddr + RI.r_offset, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPLTRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       Type = Target->getGotRefReloc();
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
-    } else if (isa<SharedSymbol<ELFT>>(Body)) {
+    } else if (!Target->relocNeedsCopy(Type, Body) &&
+               isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
     Target->relocateOne(Buf + RI.r_offset, BufEnd, Type, BaseAddr + RI.r_offset,
                         SymVA + getAddend<ELFT>(RI));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {

ELF/OutputSections.cpp

for (const DynamicReloc<ELFT> &Rel : Relocs) {
     const Elf_Rel &RI = Rel.RI;
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     const ObjectFile<ELFT> &File = *C.getFile();
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     if (Body)
       Body = Body->repl();
 
     uint32_t Type = RI.getType(Config->Mips64EL);
+    bool NeedsCopy = Body && Target->relocNeedsCopy(Type, *Body);
     bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
     bool CanBePreempted = canBePreempted(Body, NeedsGot);
     bool LazyReloc = Body && Target->supportsLazyRelocations() &&
                      Target->relocNeedsPlt(Type, *Body);
 
     if (CanBePreempted) {
       if (NeedsGot)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                             LazyReloc ? Target->getPltReloc()
                                       : Target->getGotReloc(),
                             Config->Mips64EL);
       else
-        P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
+        P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
+                            NeedsCopy ? Target->getCopyReloc() : Type,
                             Config->Mips64EL);
     } else {
       P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
     }
 
     if (NeedsGot) {
       if (LazyReloc)
         P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
       else
         P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
+    } else if (NeedsCopy) {
+      P->r_offset = Out<ELFT>::Bss->getVA() +
+                    dyn_cast<SharedSymbol<ELFT>>(Body)->OffsetInBSS;
     } else {
       P->r_offset = RI.r_offset + C.OutSec->getVA() + C.OutSecOff;
     }
 
     uintX_t OrigAddend = 0;
     if (IsRela && !NeedsGot)
       OrigAddend = static_cast<const Elf_Rela &>(RI).r_addend;
 
     uintX_t Addend;
-    if (CanBePreempted)
+    if (NeedsCopy)
+      Addend = 0;
+    else if (CanBePreempted)
       Addend = OrigAddend;
     else if (Body)
       Addend = getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body)) + OrigAddend;
     else if (IsRela)
       Addend = getLocalRelTarget(File, static_cast<const Elf_Rela &>(RI));
     else
       Addend = getLocalRelTarget(File, RI);
 
     if (IsRela)
case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> &SC = DR.Section;
     return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
   }
   case SymbolBody::DefinedCommonKind:
     return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
-  case SymbolBody::SharedKind:
+  case SymbolBody::SharedKind: {
+    const auto &SS = cast<SharedSymbol<ELFT>>(S);
+    if (SS.NeedsCopy)
+      return Out<ELFT>::Bss->getVA() + SS.OffsetInBSS;
+    return 0;
+  }
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyKind:
     assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("Invalid symbol kind");
 }
case SymbolBody::DefinedRegularKind: {
       if (!Sym->Section.isLive())
         continue;
       OutSec = Sym->Section.OutSec;
       break;
     }
     case SymbolBody::DefinedCommonKind:
       OutSec = Out<ELFT>::Bss;
       break;
+    case SymbolBody::SharedKind: {
+      if (cast<SharedSymbol<ELFT>>(Body)->NeedsCopy)
+        OutSec = Out<ELFT>::Bss;
+      break;
+    }
     case SymbolBody::UndefinedKind:
     case SymbolBody::DefinedAbsoluteKind:
-    case SymbolBody::SharedKind:
     case SymbolBody::LazyKind:
       break;
     }
 
     StringRef Name = Body->getName();
     ESym->st_name = StrTabSec.getOffset(Name);
 
     unsigned char Type = STT_NOTYPE;

ELF/Symbols.h

public:
   unsigned getDynamicSymbolTableIndex() const {
     return DynamicSymbolTableIndex;
   }
   void setDynamicSymbolTableIndex(unsigned V) { DynamicSymbolTableIndex = V; }
 
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   bool isInGot() const { return GotIndex != -1U; }
   bool isInGotPlt() const { return GotPltIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver
   // has chosen the object among other objects having the same name,

 template <class ELFT>
 typename Undefined<ELFT>::Elf_Sym Undefined<ELFT>::Required;
 template <class ELFT>
 typename Undefined<ELFT>::Elf_Sym Undefined<ELFT>::Optional;
 
 template <class ELFT> class SharedSymbol : public Defined<ELFT> {
   typedef Defined<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
+  typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::SharedKind;
   }
 
   SharedSymbol(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::SharedKind, Name, Sym), File(F) {}
 
   SharedFile<ELFT> *File;
+
+  // Can have offset if requires copy relocation.
+  uintX_t OffsetInBSS = 0;
+  bool NeedsCopy = false;
 };
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {

ELF/Target.h

 namespace lld {
 namespace elf2 {
 class SymbolBody;
 
 class TargetInfo {
 public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const { return VAStart; }
+  unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getGotRefReloc() const { return GotRefReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
   unsigned getPltZeroEntrySize() const { return PltZeroEntrySize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
   bool supportsLazyRelocations() const { return LazyRelocations; }
   virtual unsigned getPLTRefReloc(unsigned Type) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                  uint64_t PltEntryAddr) const = 0;
   virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                              uint64_t PltEntryAddr, int32_t Index) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
+  virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocPointsToGot(uint32_t Type) const;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA) const = 0;
 
   virtual ~TargetInfo();
 
 protected:
   unsigned PageSize = 4096;
 
   // On freebsd x86_64 the first page cannot be mmaped.
   // On linux that is controled by vm.mmap_min_addr. At least on some x86_64
   // installs that is 65536, so the first 15 pages cannot be used.
   // Given that, the smallest value that can be used in here is 0x10000.
   // If using 2MB pages, the smallest page aligned address that works is
   // 0x200000, but it looks like every OS uses 4k pages for executables.
   uint64_t VAStart = 0x10000;
 
+  unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
   unsigned PltZeroEntrySize = 0;
   bool LazyRelocations = false;

ELF/Target.cpp

 public:
   X86_64TargetInfo();
   unsigned getPLTRefReloc(unsigned Type) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index) const override;
+  bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
TargetInfo *createTarget() {
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
   error("Unknown target machine");
 }
 
 TargetInfo::~TargetInfo() {}
 
+bool TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
+  return false;
+}
+
 unsigned TargetInfo::getPLTRefReloc(unsigned Type) const { return PCRelReloc; }
 
 bool TargetInfo::relocPointsToGot(uint32_t Type) const { return false; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
 X86TargetInfo::X86TargetInfo() {
   PCRelReloc = R_386_PC32;
case R_386_32:
     add32le(Loc, SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
+  CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   GotRefReloc = R_X86_64_PC32;
   PltReloc = R_X86_64_JUMP_SLOT;
   RelativeReloc = R_X86_64_RELATIVE;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;
void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
   };
   memcpy(Buf, Inst, sizeof(Inst));
 
   write32le(Buf + 2, GotEntryAddr - PltEntryAddr - 6);
   write32le(Buf + 7, Index);
   write32le(Buf + 12, -Index * PltEntrySize - PltZeroEntrySize - 16);
 }
 
+bool X86_64TargetInfo::relocNeedsCopy(uint32_t Type,
+                                      const SymbolBody &S) const {
+  if (Type == R_X86_64_32S || Type == R_X86_64_32 || Type == R_X86_64_PC32 ||
+      Type == R_X86_64_64)
+    if (auto *SS = dyn_cast<SharedSymbol<ELF64LE>>(&S))
+      return SS->Sym.getType() == STT_OBJECT;
+  return false;
+}
+
 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);
 }
 
 unsigned X86_64TargetInfo::getPLTRefReloc(unsigned Type) const {
   switch (Type) {
   case R_X86_64_32:
     return R_X86_64_32;
   case R_X86_64_PC32:
   case R_X86_64_PLT32:
     return R_X86_64_PC32;
   }
   llvm_unreachable("Unexpected relocation");
 }
 
 bool X86_64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
+  if (relocNeedsCopy(Type, S))
+    return false;
+
   switch (Type) {
   default:
     return false;
   case R_X86_64_32:
   case R_X86_64_PC32:
     // This relocation is defined to have a value of (S + A - P).
     // The problems start when a non PIC program calls a function in a shared
     // library.
void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   case R_X86_64_32:
   case R_X86_64_32S:
     if (Type == R_X86_64_32 && !isUInt<32>(SA))
       error("R_X86_64_32 out of range");
     else if (!isInt<32>(SA))
       error("R_X86_64_32S out of range");
     write32le(Loc, SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t applyPPCLo(uint64_t V) { return V; }
 static uint16_t applyPPCHi(uint64_t V) { return V >> 16; }

ELF/Writer.cpp

if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
     bool NeedsGot = false;
     bool NeedsPlt = false;
     if (Body) {
+      bool NeedsCopy = false;
+      if (auto *E = dyn_cast<SharedSymbol<ELFT>>(Body)) {
+        NeedsCopy = Target->relocNeedsCopy(Type, *Body);
+        if (NeedsCopy && E->NeedsCopy)
+          continue;
+        E->NeedsCopy = NeedsCopy;
+      }
       NeedsPlt = Target->relocNeedsPlt(Type, *Body);
       if (NeedsPlt) {
         if (Body->isInPlt())
           continue;
         Out<ELFT>::Plt->addEntry(Body);
       }
       NeedsGot = Target->relocNeedsGot(Type, *Body);
       if (NeedsGot) {
         if (NeedsPlt && Target->supportsLazyRelocations()) {
           Out<ELFT>::GotPlt->addEntry(Body);
         } else {
           if (Body->isInGot())
             continue;
           Out<ELFT>::Got->addEntry(Body);
         }
for (DefinedCommon<ELFT> *C : Syms) {
     Off = RoundUpToAlignment(Off, Align);
     C->OffsetInBSS = Off;
     Off += Sym.st_size;
   }
 
   Out<ELFT>::Bss->setSize(Off);
 }
 
+template <class ELFT>
+static void addSharedCopySymbols(std::vector<SharedSymbol<ELFT> *> &Syms) {
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
+  typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+
+  uintX_t Off = Out<ELFT>::Bss->getSize();
+  for (SharedSymbol<ELFT> *C : Syms) {
+    const Elf_Sym &Sym = C->Sym;
+    // We don't know the exact alignment requirement for the data copied by a
+    // copy relocation, so align that to 16 byte boundaries that should be large
+    // enough unconditionally.
+    Off = RoundUpToAlignment(Off, 16);
+    C->OffsetInBSS = Off;
+    Off += Sym.st_size;
+  }
+  Out<ELFT>::Bss->setSize(Off);
+}
+
 static StringRef getOutputName(StringRef S) {
   if (S.startswith(".text."))
     return ".text";
   if (S.startswith(".rodata."))
     return ".rodata";
   if (S.startswith(".data."))
     return ".data";
   if (S.startswith(".bss."))
template <class ELFT> void Writer<ELFT>::createSections() {
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles())
     for (InputSectionBase<ELFT> *B : F->getSections())
       if (auto *S = dyn_cast_or_null<InputSection<ELFT>>(B))
         if (S != &InputSection<ELFT>::Discarded)
           if (S->isLive())
             scanRelocs(*S);
 
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
+  std::vector<SharedSymbol<ELFT> *> SharedCopySymbols;
   for (auto &P : Symtab.getSymbols()) {
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
         reportUndefined<ELFT>(Symtab, *Body);
 
     if (auto *C = dyn_cast<DefinedCommon<ELFT>>(Body))
       CommonSymbols.push_back(C);
+    if (auto *SC = dyn_cast<SharedSymbol<ELFT>>(Body))
+      if (SC->NeedsCopy)
+        SharedCopySymbols.push_back(SC);
+
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);
 
     if (isOutputDynamic() && includeInDynamicSymtab(*Body))
       Out<ELFT>::DynSymTab->addSymbol(Body);
   }
   addCommonSymbols(CommonSymbols);
+  addSharedCopySymbols(SharedCopySymbols);
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   if (Out<ELFT>::SymTab)
     OutputSections.push_back(Out<ELFT>::SymTab);
   OutputSections.push_back(Out<ELFT>::ShStrTab);
   if (Out<ELFT>::StrTab)
     OutputSections.push_back(Out<ELFT>::StrTab);

test/elf2/Inputs/relocation-copy.s

+.text
+.type x,@object
+.bss
+.globl x
+.align 4
+x:
+.long 0
+.size x, 4
+.type y,@object
+.globl y
+.align 4
+y:
+.long 0
+.size y, 4

test/elf2/relocation-copy.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/relocation-copy.s -o %t2.o
+// RUN: ld.lld2 -shared %t2.o -o %t.so
+// RUN: ld.lld2 -e main %t.o %t.so -o %t3
+// RUN: llvm-readobj --program-headers --dynamic-table -t -s -dyn-symbols -section-data -r --expand-relocs %t3 | FileCheck %s
+// RUN: llvm-objdump -r -d %t3 | FileCheck -check-prefix=CODE %s
+
+.text
+.globl main
+.align 16, 0x90
+.type main,@function
+main:
+movl $5, x
+movl $7, y
+
+// CHECK:      Name: .bss
+// CHECK-NEXT:  Type: SHT_NOBITS (0x8)
+// CHECK-NEXT:  Flags [ (0x3)
+// CHECK-NEXT:   SHF_ALLOC (0x2)
+// CHECK-NEXT:   SHF_WRITE (0x1)
+// CHECK-NEXT:  ]
+// CHECK-NEXT:  Address: 0x120A0
+// CHECK-NEXT:  Offset: 0x20A0
+// CHECK-NEXT:  Size: 20
+// CHECK-NEXT:  Link: 0
+// CHECK-NEXT:  Info: 0
+// CHECK-NEXT:  AddressAlignment: 4
+// CHECK-NEXT:  EntrySize: 0
+
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset:
+// CHECK-NEXT:       Type: R_X86_64_COPY
+// CHECK-NEXT:       Symbol: x
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset:
+// CHECK-NEXT:       Type: R_X86_64_COPY
+// CHECK-NEXT:       Symbol: y
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+
+// 73888 = 0x120A0
+// 16 is alignment here
+// 73892 = 0x120A0 + 16
+// CODE: Disassembly of section .text:
+// CODE-NEXT: main:
+// CODE-NEXT: 11000: c7 04 25 a0 20 01 00 05 00 00 00 movl $5, 73888
+// CODE-NEXT: 1100b: c7 04 25 b0 20 01 00 07 00 00 00 movl $7, 73904