[ELF] - Added support for --emit-relocs.

[grimar]

Summary

This is PR31579.

-q, --emit-relocs - Generate relocations in output

We used DynsymIndex for storing symtab index of symbol for -r
and I reused it in this patch for the same for --emit-relocs.
Had to add restriction that --emit-reloc and -pie/-shared/.so inputs
are not compatible together (so .dynsym is never created with --emit-reloc).
That seems fine as looks enough to fix PR31579.

Alternative probably can be another variable in SymbolBody for that,
but I am not sure we want it.

[ruiu]

Did you verify that this output is the same as ld.bfd's output?

ELF/Driver.cpp

166–169

Why do you need this restriction?

223–225

Why?

ELF/InputFiles.cpp

416–417

Use if instead of ?:.

[grimar]

In D28612#644422, @ruiu wrote:

Did you verify that this output is the same as ld.bfd's output?

Sure I did,
below is output from bfd:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000400078  00000078
       0000000000000018  0000000000000000  AX       0     0     4
  [ 2] .rela.text        RELA             0000000000000000  000001f0
       0000000000000060  0000000000000018   I       4     1     8
  [ 3] .shstrtab         STRTAB           0000000000000000  00000250
       0000000000000026  0000000000000000           0     0     1
  [ 4] .symtab           SYMTAB           0000000000000000  00000090
       0000000000000108  0000000000000018           5     6     8
  [ 5] .strtab           STRTAB           0000000000000000  00000198
       0000000000000052  0000000000000000           0     0     1

Relocation section '.rela.text' at offset 0x1f0 contains 4 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
00000040007a  00010000000a R_X86_64_32       0000000000400078 .text + 1
00000040007f  000a00000004 R_X86_64_PLT32    0000000000400078 fn - 4
000000400086  00010000000a R_X86_64_32       0000000000400078 .text + d
00000040008b  000700000004 R_X86_64_PLT32    0000000000400084 fn2 - 4

Symbol table '.symtab' contains 11 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000400078     0 SECTION LOCAL  DEFAULT    1 
     2: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS emit-relocs.s.tmp1.o
     3: 0000000000400079     0 NOTYPE  LOCAL  DEFAULT    1 bar
     4: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS emit-relocs.s.tmp2.o
     5: 0000000000400085     0 NOTYPE  LOCAL  DEFAULT    1 foo
     6: 0000000000601000     0 NOTYPE  GLOBAL DEFAULT    1 __bss_start
     7: 0000000000400084     0 FUNC    GLOBAL DEFAULT    1 fn2
     8: 0000000000601000     0 NOTYPE  GLOBAL DEFAULT    1 _edata
     9: 0000000000601000     0 NOTYPE  GLOBAL DEFAULT    1 _end
    10: 0000000000400078     0 FUNC    GLOBAL DEFAULT    1 fn

and our output:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000201000  00001000
       0000000000000018  0000000000000000  AX       0     0     4
  [ 2] .rela.text        RELA             0000000000000000  00001018
       0000000000000060  0000000000000018           4     1     8
  [ 3] .comment          PROGBITS         0000000000000000  00001078
       0000000000000012  0000000000000001  MS       0     0     1
  [ 4] .symtab           SYMTAB           0000000000000000  00001090
       00000000000000a8  0000000000000018           6     5     8
  [ 5] .shstrtab         STRTAB           0000000000000000  00001138
       0000000000000035  0000000000000000           0     0     1
  [ 6] .strtab           STRTAB           0000000000000000  0000116d
       0000000000000011  0000000000000000           0     0     1

Relocation section '.rela.text' at offset 0x1018 contains 4 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000201002  00020000000a R_X86_64_32       0000000000201000  + 1
000000201007  000500000004 R_X86_64_PLT32    0000000000201000 fn - 4
00000020100e  00040000000a R_X86_64_32       000000000020100c  + 1
000000201013  000600000004 R_X86_64_PLT32    000000000020100c fn2 - 4

Symbol table '.symtab' contains 7 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000201001     0 NOTYPE  LOCAL  DEFAULT    1 bar
     2: 0000000000201000     0 SECTION LOCAL  DEFAULT    1 
     3: 000000000020100d     0 NOTYPE  LOCAL  DEFAULT    1 foo
     4: 000000000020100c     0 SECTION LOCAL  DEFAULT    1 
     5: 0000000000201000     0 FUNC    GLOBAL DEFAULT    1 fn
     6: 000000000020100c     0 FUNC    GLOBAL DEFAULT    1 fn2

DIfference that bfd creates 1 section symbol, we create 2 with different values. But final values in '.rela.text'
are the same after that, so I think that should work fine.

Another difference that bfd marks ".rela.text" section with SHF_INFO_LINK flag (original objects does not have it),
I am not sure if it is critical to have, I think we can try without for now and add it separatelly if we need.

[grimar]

• Addressed review comments.

ELF/Driver.cpp

166–169

Like I mentioned in patch description, currently we use Symbol->DynsymIndex to store symbol index in .symtab for -relocatable output.
That works because -r means static linking, so .dynsym not exist.
We need to know symtab symbol index when perform fixup of relocations in InputSection<ELFT>::copyRelocations(),
because .rela.text is linked with .symtab.

This patch reuses Symbol->DynsymIndex for the same purpose for --emit-reloc.
That should work for linux kerner I think. So I had to add the same restrictions for now.

That restrictions probably can be fixed with adding one more variable to Symbol, like SymtabIndex instead of reusing
DynsymIndex. But I am not sure if it is worst to do ?

223–225

Reasons in comment above,
Out condition for creating .dynsymtab is:

bool HasDynSymTab = !Symtab<ELFT>::X->getSharedFiles().empty() || Config->Pic;

ELF/InputFiles.cpp

416–417

Done.

[ruiu]

Can you please investigate the Linux kernel why they are using this option before proceeding with this patch? The fact that they are using the option is not strong enough to justify that we need to implement it, because the use might be easily replaced by other features. And if that's the case, we don't need this change. We need to understand use cases before checking in any new feature.

ELF/Driver.cpp

166–169

That wasn't good in the first place. We shouldn't have reused a field for different purposes in such a obscure way. That needs to be fixed first.

[grimar]

In D28612#645471, @ruiu wrote:

Can you please investigate the Linux kernel why they are using this option before proceeding with this patch? The fact that they are using the option is not strong enough to justify that we need to implement it, because the use might be easily replaced by other features. And if that's the case, we don't need this change. We need to understand use cases before checking in any new feature.

Sure. I'll try to do that.

ELF/Driver.cpp

166–169

Yep. I think we did it to reduce Symbol size, but I never liked reusing this variable, I am happy to prepare the patch for it :)

[grimar]

So after little investigation about how linux kerner works with this featue I found next:

1. It links the real mode loader, and produces binary file realmode.bin using objcopy and realmode.relocs file with relocations using /x86/tools/relocs tool:

(http://git.kernel.org/cgit/linux/kernel/git/tip/tip.git/tree/arch/x86/realmode/rm/Makefile?id=f2604c141a00c00b92b7fd2f9d2455517fdd6c15#n43)

$(obj)/realmode.bin: $(obj)/realmode.elf
	$(call if_changed,objcopy)

quiet_cmd_relocs = RELOCS  $@
      cmd_relocs = arch/x86/tools/relocs --realmode $< > $@
$(obj)/realmode.relocs: $(obj)/realmode.elf FORCE
	$(call if_changed,relocs)

2. /x86/tools/relocs --realmode do next:

(https://github.com/torvalds/linux/blob/5924bbecd0267d87c24110cbe2041b5075173a25/arch/x86/tools/relocs.c#L1012)

		write_reloc(relocs16.count, stdout);
		for (i = 0; i < relocs16.count; i++)
			write_reloc(relocs16.offset[i], stdout);

		write_reloc(relocs32.count, stdout);
		for (i = 0; i < relocs32.count; i++)
			write_reloc(relocs32.offset[i], stdout);

So its output is a custom binary that has amount the relocations and relocations itself following.
Also it do some relocations sorting sorting before that code.

3. Then https://github.com/torvalds/linux/blob/master/arch/x86/realmode/rmpiggy.S packs the

result realmode.bin and realmode.relocs into single file, into .init.data section.
Also it creates symbol real_mode_relocs:

GLOBAL(real_mode_blob)
	.incbin	"arch/x86/realmode/rm/realmode.bin"
END(real_mode_blob)

GLOBAL(real_mode_blob_end);

GLOBAL(real_mode_relocs)
	.incbin	"arch/x86/realmode/rm/realmode.relocs"
END(real_mode_relocs)

4. After that all init.c uses the all data from above to perform self-relocations:

(https://github.com/torvalds/linux/blob/5924bbecd0267d87c24110cbe2041b5075173a25/arch/x86/realmode/init.c#L69)

	/* 32-bit linear relocations. */
	count = *rel++;
	while (count--) {
		u32 *ptr = (u32 *) (base + *rel++);
		*ptr += phys_base;
	}

I think we should just support that feature.
It is specific, but not huge itself + looks stoned in linux kernel atm.
It is easier to support it than to force users to create workarounds. What do you think ?

[grimar]

ELF/Driver.cpp

166–169

I prepared demo patch to show one of the ways to avoid reusing it. It is D28773.
Actually it seems that introducing something like Symbol::SymtabIndex would be simpler.
Though that makes Symbol class larger and -r/--emit-relocs are not often used probably to do that.
What do you think we should prefer ?

[grimar]

ELF/Driver.cpp

166–169

Also, may be we should just rename this variable to something more common, like SymbolIndex and leave it as is with current restrictions implemented in this patch ?
Seems it should work fine for linux kernel, it does not link agains DSO and not uses -pie/-shared.

[grimar]

• Rebased
• Fixed crash happened because rel/rela section refered to section discarded in script. Added testcase.

[grimar]

• Minor cleanup.

[grimar]

• Addressed review comment (removed command line combination restrictions, what became possible after D29021).
• Rebased.

[ruiu]

ELF/InputFiles.cpp

403–404

Needs comment.

// Relocation sections processed by the linker are usually removed
// from the output, so returning `nullptr` for the normal case.
// However, if -emit-relocs is given, we need to leave them in the output.
// (Some post link analysis tools need this information.)

ELF/LinkerScript.cpp

266–277

What is this?

[grimar]

• Addressed review comments.
• Added few comments.

ELF/InputFiles.cpp

403–404

Done. Thanks for comment.

ELF/LinkerScript.cpp

266–277

It fixes crash reported for PR31579, showed in emit-reloc-discard.s testcase.

If we have some section, for example .debug_info and discard it from script,
then we are not able to emit .rela.debug_info section.

Because "section to which the relocation applies" is not exist:

// sh_info for SHT_REL[A] sections should contain the section header index of
// the section to which the relocation applies.
InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
this->Info = S->OutSec->SectionIndex;

So that code discards .rel[a] sections in that case as well. That is consistent to what gnu linkers do.
I added comment.

[ruiu]

ELF/InputFiles.cpp

409

nit: remove this blank line.

ELF/LinkerScript.cpp

266–277

This seems like you are implement your own GC in some sense here. You probably should use DependentSection member of InputSection to do that automatically.

[grimar]

• Addressed comments.

(reimplemented logic relative to discarding target section, added support and testcase for --gc-sections --emit-relocs used together).

ELF/LinkerScript.cpp

266–277

Thanks for hit about DependentSection, I used it in --gc-sections case (updated code and added testcase to show how it works now).

That place of code is used for handling "/DISCARD/". Which is handled in script much later than GC runs and not relative to GC. Though using of DependentSection helped here as well. It is not what I would call "automatically", but since it is not relative to GC, code looks good for me now. What do you think ?

[grimar]

• Minor cleanup in testcase.

[grimar]

ELF/InputFiles.cpp

409

I am going to remove that fatal error in following patch.
It is needed for linux kernel, but since it involves move DependentSection from InputSection<ELFT> to somewhere and also adding more additional tests probably, I think it is better not to do that change in this patch.
Hope it's ok.

[ruiu]

ELF/InputFiles.cpp

409

I think what you really need to do is to make it a vector just like Rafael did in https://reviews.llvm.org/D28626.

ELF/InputSection.cpp

45–56

Exporting this as a global function is probably not a good idea. Whether a section could be discarded or never be discarded can be decided when the section is instantiated (because the decision depends only on Sec->Type, Config->GcSections and its section name, all of which are available at the constructor.)

So, the right way of doing it is to set Live bit in the ctor if it should never be GC'ed.

ELF/LinkerScript.cpp

265–270

I don't think this is correct. You shouldn't add any code this function, or there's a bug in GC.

If section S depends on section T, and if S is marked as dead, T must be marked as dead too before the control reaches this function. So both S and T will be discarded without doing anything special.

[grimar]

ELF/InputFiles.cpp

409

I do not see how vector helps. Issue here is that

DependentSection is a member of InputSection, but
EhInputSection inhireted from InputSectionBase<ELFT>

EhInputSection : public InputSectionBase<ELFT>

In following patch I plan to move DependentSection to InputSectionBase probably to solve that problem.

ELF/LinkerScript.cpp

265–270

It is not relative to GC at all.
Please look at emit-reloc-discard.s.

Call is:

# RUN: echo "SECTIONS { /DISCARD/ : { *(.debug*) } }" > %t.script
# RUN: ld.lld --emit-relocs --script %t.script %t.o -o %t1

So .debug_* sections are discarded from script, GC is not involved and not executed.
And since .debug_ are discarded, .rela.debug_* should be discarded as well. That is what that place do.

[grimar]

ELF/InputSection.cpp

45–56

That looks good idea, I prepared patch D29170.

[tpimh]

ELF/InputFiles.cpp

406

Building Linux kernel with CONFIG_ACPI=y also fails because of this.

[grimar]

Simplified version of this was posted as D29273.

ELF/InputFiles.cpp

406

I know. But simplified version of this patch (D29273) is still on review. I am going to prepare separate patch supporting this when it be landed.

ELF/Config.h

struct Configuration {
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool ColorDiagnostics = false;
   bool DefineCommon;
   bool Demangle = true;
   bool DisableVerify;
   bool EhFrameHdr;
+  bool EmitRelocs;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool FatalWarnings;
   bool GcSections;
   bool GdbIndex;
   bool GnuHash = false;
   bool ICF;
   bool Mips64EL = false;

ELF/Driver.cpp

case file_magic::archive:
     }
     Files.push_back(make<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
     if (Config->Relocatable) {
       error("attempted static link of dynamic object " + Path);
       return;
     }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     if (InLib)
       Files.push_back(make<LazyObjectFile>(MBRef));
     else
       Files.push_back(createObjectFile(MBRef));
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
if (Config->Shared)
       error("-r and -shared may not be used together");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Config->ICF)
       error("-r and --icf may not be used together");
     if (Config->Pie)
       error("-r and -pie may not be used together");
   }
 }
 
 static StringRef getString(opt::InputArgList &Args, unsigned Key,
                            StringRef Default = "") {
   if (auto *Arg = Args.getLastArg(Key))
     return Arg->getValue();
   return Default;
 }
 
 static int getInteger(opt::InputArgList &Args, unsigned Key, int Default) {
   int V = Default;
if (auto *Arg = Args.getLastArg(OPT_m)) {
     Config->Emulation = S;
   }
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->Demangle = getArg(Args, OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
+  Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic =
       getArg(Args, OPT_export_dynamic, OPT_no_export_dynamic, false);
   Config->FatalWarnings =
       getArg(Args, OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->GcSections = getArg(Args, OPT_gc_sections, OPT_no_gc_sections, false);
   Config->GdbIndex = Args.hasArg(OPT_gdb_index);

ELF/InputFiles.cpp

case SHT_REL: {
     } else {
       ArrayRef<Elf_Rel> Rels = check(this->getObj().rels(&Sec));
       Target->FirstRelocation = Rels.begin();
       NumRelocations = Rels.size();
       Target->AreRelocsRela = false;
     }
     assert(isUInt<31>(NumRelocations));
     Target->NumRelocations = NumRelocations;
+
+    // Relocation sections processed by the linker are usually removed
+    // from the output, so returning `nullptr` for the normal case.
+    // However, if -emit-relocs is given, we need to leave them in the output.
+    // (Some post link analysis tools need this information.)
+    if (Config->EmitRelocs) {
+      if (!isa<InputSection<ELFT>>(Target))
+        fatal(toString(this) + ": --emit-relocs for relocations sections "
+                               "pointing to .eh_frame is not supported");
+      InputSection<ELFT> *RelocSec = make<InputSection<ELFT>>(this, &Sec, Name);
+      cast<InputSection<ELFT>>(Target)->DependentSection = RelocSec;
+      return RelocSec;
+    }
     return nullptr;
   }
   }
 
   // .note.GNU-stack is a marker section to control the presence of
   // PT_GNU_STACK segment in outputs. Since the presence of the segment
   // is controlled only by the command line option (-z execstack) in LLD,
   // .note.GNU-stack is ignored.
   if (Name == ".note.GNU-stack")
     return &InputSection<ELFT>::Discarded;
 

ELF/InputSection.h

private:
 
   llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
 template <class ELFT> InputSection<ELFT> InputSection<ELFT>::Discarded;
 } // namespace elf
 
 template <class ELFT> std::string toString(const elf::InputSectionBase<ELFT> *);
+bool shouldGC(uint64_t Flags, uint32_t Type);
+
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 template <class ELFT>
 std::string lld::toString(const InputSectionBase<ELFT> *Sec) {
   // File can be absent if section is synthetic.
   std::string FileName =
       Sec->getFile() ? Sec->getFile()->getName() : "<internal>";
   return (FileName + ":(" + Sec->Name + ")").str();
 }
 
+// Returns if GC should be enabled for section. We do not run GC for
+// non-allocatable sections, which typically contain debugging information.
+// REL[A] sections are not allocatable, but we do GC for them, because them are
+// dependent on section they relocate, we do not want them be live
+// unconditionally. That is used for --emit-relocs.
+bool lld::shouldGC(uint64_t Flags, uint32_t Type) {
+  if (!Config->GcSections)
+    return false;
+  if (Type == SHT_RELA || Type == SHT_REL)
+    return true;
+  return Flags & SHF_ALLOC;
+}
+
 template <class ELFT>
 static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File,
                                             const typename ELFT::Shdr *Hdr) {
   if (!File || Hdr->sh_type == SHT_NOBITS)
     return makeArrayRef<uint8_t>(nullptr, Hdr->sh_size);
   return check(File->getObj().getSectionContents(Hdr));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          uintX_t Flags, uint32_t Type,
                                          uintX_t Entsize, uint32_t Link,
                                          uint32_t Info, uintX_t Addralign,
                                          ArrayRef<uint8_t> Data, StringRef Name,
                                          Kind SectionKind)
-    : InputSectionData(SectionKind, Name, Data,
-                       !Config->GcSections || !(Flags & SHF_ALLOC)),
+    : InputSectionData(SectionKind, Name, Data, !shouldGC(Flags, Type)),
       File(File), Flags(Flags), Entsize(Entsize), Type(Type), Link(Link),
       Info(Info), Repl(this) {
   NumRelocations = 0;
   AreRelocsRela = false;
 
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraits.
   uint64_t V = std::max<uint64_t>(Addralign, 1);

 
 template <class ELFT> uint64_t InputSection<ELFT>::getThunksSize() const {
   uint64_t Total = 0;
   for (const Thunk<ELFT> *T : Thunks)
     Total += T->size();
   return Total;
 }
 
-// This is used for -r. We can't use memcpy to copy relocations because we need
-// to update symbol table offset and section index for each relocation. So we
-// copy relocations one by one.
+// This is used for -r and --emit-relocs. We can't use memcpy to copy
+// relocations because we need to update symbol table offset and section index
+// for each relocation. So we copy relocations one by one.
 template <class ELFT>
 template <class RelTy>
 void InputSection<ELFT>::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) {
   InputSectionBase<ELFT> *RelocatedSection = getRelocatedSection();
 
   // Loop is slow and have complexity O(N*M), where N - amount of
   // relocations and M - amount of symbols in symbol table.
   // That happens because getSymbolIndex(...) call below performs
   // simple linear search.
   for (const RelTy &Rel : Rels) {
     uint32_t Type = Rel.getType(Config->Mips64EL);
     SymbolBody &Body = this->File->getRelocTargetSym(Rel);
 
     Elf_Rela *P = reinterpret_cast<Elf_Rela *>(Buf);
     Buf += sizeof(RelTy);
 
     if (Config->Rela)
       P->r_addend = getAddend<ELFT>(Rel);
-    P->r_offset = RelocatedSection->getOffset(Rel.r_offset);
+
+    // Output section VA is zero for -r, so r_offset is an offset within the
+    // section, but for --emit-relocs it is an absolute address.
+    P->r_offset = RelocatedSection->OutSec->Addr +
+                  RelocatedSection->getOffset(Rel.r_offset);
     P->setSymbolAndType(In<ELFT>::SymTab->getSymbolIndex(&Body), Type,
                         Config->Mips64EL);
   }
 }
 
 static uint32_t getARMUndefinedRelativeWeakVA(uint32_t Type, uint32_t A,
                                               uint32_t P) {
   switch (Type) {
template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Type == SHT_NOBITS)
     return;
 
   if (auto *S = dyn_cast<SyntheticSection<ELFT>>(this)) {
     S->writeTo(Buf + OutSecOff);
     return;
   }
 
-  // If -r is given, then an InputSection may be a relocation section.
+  // If -r or --emit-relocs is given, then an InputSection
+  // may be a relocation section.
   if (this->Type == SHT_RELA) {
     copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rela>());
     return;
   }
   if (this->Type == SHT_REL) {
     copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rel>());
     return;
   }

ELF/LinkerScript.cpp

void LinkerScript<ELFT>::computeInputSections(InputSectionDescription *I) {
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::discard(ArrayRef<InputSectionBase<ELFT> *> V) {
   for (InputSectionBase<ELFT> *S : V) {
     S->Live = false;
     reportDiscarded(S);
+
+    // If we discard a section, we also should discard a dependent section.
+    InputSection<ELFT> *IS = dyn_cast<InputSection<ELFT>>(S);
+    if (!IS || !IS->DependentSection || !IS->DependentSection->Live)
+      continue;
+    discard({IS->DependentSection});
   }
 }
 
 template <class ELFT>
 std::vector<InputSectionBase<ELFT> *>
 LinkerScript<ELFT>::createInputSectionList(OutputSectionCommand &OutCmd) {
   std::vector<InputSectionBase<ELFT> *> Ret;
 
   for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     auto *Cmd = dyn_cast<InputSectionDescription>(Base.get());
     if (!Cmd)
       continue;
     computeInputSections(Cmd);
     for (InputSectionData *S : Cmd->Sections)
       Ret.push_back(static_cast<InputSectionBase<ELFT> *>(S));

ELF/MarkLive.cpp

scanEhFrameSection(EhInputSection<ELFT> &EH,
   if (EH.AreRelocsRela)
     scanEhFrameSection(EH, EH.relas(), Enqueue);
   else
     scanEhFrameSection(EH, EH.rels(), Enqueue);
 }
 
 // We do not garbage-collect two types of sections:
 // 1) Sections used by the loader (.init, .fini, .ctors, .dtors or .jcr)
-// 2) Non-allocatable sections which typically contain debugging information
+// 2) Sections that are not supposed to be GC, see comment for shouldGC().
 template <class ELFT> static bool isReserved(InputSectionBase<ELFT> *Sec) {
   switch (Sec->Type) {
   case SHT_FINI_ARRAY:
   case SHT_INIT_ARRAY:
   case SHT_NOTE:
   case SHT_PREINIT_ARRAY:
     return true;
   default:
-    if (!(Sec->Flags & SHF_ALLOC))
+    if (!shouldGC(Sec->Flags, Sec->Type))
       return true;
 
     // We do not want to reclaim sections if they can be referred
     // by __start_* and __stop_* symbols.
     StringRef S = Sec->Name;
     if (isValidCIdentifier(S))
       return true;
 
template <class ELFT> void elf::markLive() {
   auto Enqueue = [&](ResolvedReloc<ELFT> R) {
     // Skip over discarded sections. This in theory shouldn't happen, because
     // the ELF spec doesn't allow a relocation to point to a deduplicated
     // COMDAT section directly. Unfortunately this happens in practice (e.g.
     // .eh_frame) so we need to add a check.
     if (!R.Sec || R.Sec == &InputSection<ELFT>::Discarded)
       return;
 
-    // We don't gc non alloc sections.
-    if (!(R.Sec->Flags & SHF_ALLOC))
+    // We don't GC some sections, see comment for shouldGC().
+    if (!shouldGC(R.Sec->Flags, R.Sec->Type))
       return;
 
     // Usually, a whole section is marked as live or dead, but in mergeable
     // (splittable) sections, each piece of data has independent liveness bit.
     // So we explicitly tell it which offset is in use.
     if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(R.Sec))
       MS->markLiveAt(R.Offset);
 

ELF/Options.td

def dynamic_linker: S<"dynamic-linker">,
   HelpText<"Which dynamic linker to use">;
 
 def dynamic_list: S<"dynamic-list">,
   HelpText<"Read a list of dynamic symbols">;
 
 def eh_frame_hdr: F<"eh-frame-hdr">,
   HelpText<"Request creation of .eh_frame_hdr section and PT_GNU_EH_FRAME segment header">;
 
+def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
+
 def enable_new_dtags: F<"enable-new-dtags">,
   HelpText<"Enable new dynamic tags">;
 
 def end_lib: F<"end-lib">,
   HelpText<"End a grouping of objects that should be treated as if they were together in an archive">;
 
 def entry: S<"entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;

 def alias_Bstatic_static: F<"static">, Alias<Bstatic>;
 def alias_L__library_path: J<"library-path=">, Alias<L>;
 def alias_define_common_d: Flag<["-"], "d">, Alias<define_common>;
 def alias_define_common_dc: F<"dc">, Alias<define_common>;
 def alias_define_common_dp: F<"dp">, Alias<define_common>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
 def alias_dynamic_list: J<"dynamic-list=">, Alias<dynamic_list>;
+def alias_emit_relocs: Flag<["-"], "q">, Alias<emit_relocs>;
 def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
 def alias_entry_entry: J<"entry=">, Alias<entry>;
 def alias_error_limit: J<"error-limit=">, Alias<error_limit>;
 def alias_export_dynamic_E: Flag<["-"], "E">, Alias<export_dynamic>;
 def alias_export_dynamic_symbol: J<"export-dynamic-symbol=">,
   Alias<export_dynamic_symbol>;
 def alias_fini_fini: J<"fini=">, Alias<fini>;
 def alias_format_b: S<"b">, Alias<format>;

ELF/OutputSections.cpp

if ((this->Flags & SHF_LINK_ORDER) && !this->Sections.empty()) {
     // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We
     // need to translate the InputSection sh_link to the OutputSection sh_link,
     // all InputSections in the OutputSection have the same dependency.
     if (auto *D = this->Sections.front()->getLinkOrderDep())
       this->Link = D->OutSec->SectionIndex;
   }
 
   uint32_t Type = this->Type;
-  if (!Config->Relocatable || (Type != SHT_RELA && Type != SHT_REL))
+  if ((!Config->Relocatable && !Config->EmitRelocs) ||
+      (Type != SHT_RELA && Type != SHT_REL))
     return;
 
   this->Link = In<ELFT>::SymTab->OutSec->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
   this->Info = S->OutSec->SectionIndex;
 }

ELF/Writer.cpp

 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
-  // We keep sections in symtab for relocatable output.
+  // We keep sections in symtab for relocatable output and --emit-reloc.
   if (B.isSection())
-    return Config->Relocatable;
+    return Config->Relocatable || Config->EmitRelocs;
 
   // If sym references a section in a discarded group, don't keep it.
   if (Sec == &InputSection<ELFT>::Discarded)
     return false;
 
   if (Config->Discard == DiscardPolicy::None)
     return true;
 

test/ELF/Inputs/emit-relocs.s

+.section .text
+.globl fn2
+.type fn2,@function
+fn2:
+ nop
+
+foo:
+  movl $foo, %edx
+  callq fn2@PLT
+  nop

test/ELF/emit-relocs-gc.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+
+## Check what we emit for non-gc case.
+# RUN: ld.lld --emit-relocs %t1.o -o %t
+# RUN: llvm-objdump %t -section-headers | FileCheck %s --check-prefix=NOGC
+# NOGC:      Sections:
+# NOGC-NEXT: Idx Name
+# NOGC-NEXT:   0
+# NOGC-NEXT:   1 .bar
+# NOGC-NEXT:   2 .text
+# NOGC-NEXT:   3 .rela.text
+# NOGC-NEXT:   4 .rela.bar
+
+## GC collects .bar section and we do not emit .rela.bar then.
+# RUN: ld.lld --gc-sections --emit-relocs %t1.o -o %t
+# RUN: llvm-objdump %t -section-headers | FileCheck %s --check-prefix=GC
+# GC:      Sections:
+# GC-NEXT: Idx Name
+# GC-NEXT:   0
+# GC-NEXT:   1 .text
+# GC-NEXT:   2 .rela.text
+# GC-NOT:  rela.bar
+
+.globl _start
+_start:
+ .quad .text
+
+.section .bar,"a"
+.quad .bar

test/ELF/emit-relocs.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/emit-relocs.s -o %t2.o
+# RUN: ld.lld --emit-relocs %t1.o %t2.o -o %t
+# RUN: llvm-readobj -t -r %t | FileCheck %s
+
+## Check single dash form.
+# RUN: ld.lld -emit-relocs %t1.o %t2.o -o %t1
+# RUN: llvm-readobj -t -r %t1 | FileCheck %s
+
+## Check alias.
+# RUN: ld.lld -q %t1.o %t2.o -o %t2
+# RUN: llvm-readobj -t -r %t2 | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section ({{.*}}) .rela.text {
+# CHECK-NEXT:     0x201002 R_X86_64_32 .text 0x1
+# CHECK-NEXT:     0x201007 R_X86_64_PLT32 fn 0xFFFFFFFFFFFFFFFC
+# CHECK-NEXT:     0x20100E R_X86_64_32 .text 0x1
+# CHECK-NEXT:     0x201013 R_X86_64_PLT32 fn2 0xFFFFFFFFFFFFFFFC
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: Symbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name:
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: bar
+# CHECK-NEXT:     Value: 0x201001
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name:
+# CHECK-NEXT:     Value: 0x201000
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: Section
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: foo
+# CHECK-NEXT:     Value: 0x20100D
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name:
+# CHECK-NEXT:     Value: 0x20100C
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: Section
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: fn
+# CHECK-NEXT:     Value: 0x201000
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Function
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: fn2
+# CHECK-NEXT:     Value: 0x20100C
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Function
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+.section .text
+.globl fn
+.type fn,@function
+fn:
+ nop
+
+bar:
+  movl $bar, %edx
+  callq fn@PLT
+  nop

test/ELF/linkerscript/emit-reloc-discard.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "SECTIONS { /DISCARD/ : { *(.debug*) } }" > %t.script
+# RUN: ld.lld --emit-relocs --script %t.script %t.o -o %t1
+# RUN: llvm-readobj -r %t1 | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT: ]
+
+.section .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz "AAA"
+
+.section  .debug_info,"",@progbits
+  .long .Linfo_string0