[ELF] - implemented --eh-frame-hdr command line option.

[grimar]

Summary

--eh-frame-hdr
Request creation of ".eh_frame_hdr" section and ELF "PT_GNU_EH_FRAME" segment header.

Both gold and the GNU linker support an option --eh-frame-hdr which tell them to construct a header for all the .eh_frame sections. This header is placed in a section named .eh_frame_hdr and also in a PT_GNU_EH_FRAME segment. At runtime the unwinder can find all the PT_GNU_EH_FRAME segments by calling dl_iterate_phdr.
This section contains a lookup table for quick binary search of FDEs.
Detailed info can be found here:
http://www.airs.com/blog/archives/462

[grimar]

• Rebased.
• Minor formatting/other improvements.

[ruiu]

ELF/OutputSections.cpp

760–857

Please add a short comment with the URL to the Ian's blog article.

764

Is this value correct? (If correct, it needs a comment.)

767

This function needs a brief comment.

776–784

I'd make this a function so that you write

case ...:
  return read16<E>(F.PCRel);

instead of

case ...:
  PcRel = read16<E>(F.PCRel);
  break;

822

Why don't you use range-based for loop?

853

Ah, OK, so sh_size is initialized to 12 and change in size as you add new FDEs. You want to write about that as a comment.

1136

Add a comment.

// Read a byte and advance D by one byte.

I think you don't need to template this function.

1178

Isn't this a fatal error?

1237

You can remove template <class ELFT>. Please move this just below readByte.

ELF/OutputSections.h

446

Alive -> Live.

test/ELF/eh-frame-hdr-no-out.s

3

How did you create the binary file? Can you use an assembler to create that file?

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

760–857

Done.

764

Added comment.

767

Done.

822

Interesting question. Fixed.

853

Added comment.

1136

Done.

1178

Thats a question. I think it is not. Linker here just should merge the .eh_frame sections in the way it can. It does not need to support any new versions for example to do that. But .eh_frame_hdr can`t be generated then without knowing internals.
Since my patch is about generating eh_frame_hdr then its correct for it to be Live=false with warning I think.

1237

Ah, yes, initially I did it as class member and forgot to remove after making static.
Fixed.

test/ELF/eh-frame-hdr-no-out.s

3

I dont know any way to generate corrupted CIE or CIE with specified version using assembler.
That is done by compiler itself I believe.
So I just took sample and then used hex editor to manually change the version.

[grimar]

Fixed urls formatting.

[ruiu]

ELF/OutputSections.cpp

760

Add a space before "--".

771–772

Remove "llvm::ELF::".

773

` -> '

774

Its -> It's

787

Can you remove "typename EhFrameHdr<ELFT>::"?

793

switch (F.enc & 0xF)

824

It is better to advance Buf here.

Buf += 12;

844

Isn't parameter Sec be non-null? If it is, you can just do

if (this->Sec != Sec)

1110–1112

We can exit from this function as soon as we read data, no?

return readByte(D, &Cie.FdeEncoding));

1124

Ditto

ELF/OutputSections.h

434

Please add a comment to this class.

435

You can remove this typedef.

[grimar]

• Addressed review comments.
• Rebased.

ELF/OutputSections.cpp

760

Done, comment was moved to class EhFrameHdr definition.

773

Removed that line.

844

Point to do "if (this->Sec)" check here is to avoid warning and disabling of header for first assignEhFrame call. I only want to warn if one ehframe is assigned already and somebody tries to assign another one.

1110–1112

I am not sure it is better. At first look it`s like a little optimization of parsing augmentation string but in fact it can hide a potential error when CIE information is corrupted. Early exit can hide warning about that if 'R' is not the latest in a sequence.

1124

Hmm, I dont think its "Ditto", the propose of the function is to read 1 byte that represents the pointer encoding for the address pointers used in the FDE, which is read in 'R', so we need to read and skip everything we met at least until we read 'R'.

[ruiu]

ELF/OutputSections.cpp

764

` -> '

777

Remove this empty line.

844

So, if Sec is nonnull but this->Sec can be null,

• If this->Sec == nullptr, (this->Sec != Sec) can never be true (because Sec is not null), no warning is displayed.
• If this->Sec != nullptr, (this->Sec != Sec) is true only when somebody tries to assign another one.

But this is a minor point. Leave it as is if you think yours more readable.

1110–1112

I'm pretty sure that that is better if this code is just for checking consistency. We generally don't want to read any data unless it is absolutely necessary to link stuff. It is compiler's responsibility to feed consistent file to the linker, so the linker doesn't have to verify all bits. Doing less is important for performance.

[grimar]

• Addressed review comments.

ELF/OutputSections.cpp

764

Sorry, I dont get what you want me to do here ?

844

if (this->Sec != Sec) {
 warning("multiple .eh_frame sections not supported for .eh_frame_hdr");
...

So initially (this->Sec != Sec) is always true, because this->Sec is null and Sec is not. Them are always not equal at first run. Warning is displayed, but it should not.

1110–1112

Ok, done.

[ruiu]

ELF/OutputSections.cpp

764

I meant please use apostrophe (') instead of backquote (`) for contractions.

1073

This function reads only encoding, right? Then maybe we should change this function signature to

ErrorOr<uint8_t> getFdeEncoding(ArrayRef<uint8_t> D)

?

Also I'm wondering if corrupted CIEs/FDEs are so prevalent that we have to take care of them. For now, I'd like to simply use error() whenever we find something wrong. Then we can change the signature to

uint8_t getFdeEncoding(ArrayRef<uint8_t> D)

which is pretty simple to understand.

[grimar]

Addressed review comments (refactored getFdeEnc method).

ELF/OutputSections.cpp

1073

What about getFdeEnc() then ? (to calm down the clang format).
I also changed readByte and skipLeb128 to uint8_t readByte() and void skipLeb128().
And introduced cieParseError() more method to report CIE parse errors in a single place.

[grimar]

ELF/OutputSections.cpp

1073

Please ignore getFdeEnc part. getFdeEncoding() is fine now, I`ll update patch in a minute.

[grimar]

getFdeEnc() -> getFdeEncoding()

[ruiu]

ELF/OutputSections.cpp

844

You can remove {}.

1008–1009

Please use Type and Flags instead of sh_type and sh_flags because of the LLVM coding style.

1031–1033

Do we need this? If this function is called only at a few places, I'd just inline it.

1059

This should be error() instead of llvm_reachable() because it is logically reachable if an input is corrupted.

1086

This is probably better.

if (Version != 1 && Version != 3)
  error("FDE version 1 or 3 expected, but got " + Version);

1094

if (readByte(D) != 1)
  error(".eh_frame alignment must be 1")

1100–1105

At this point it is guaranteed that Version is either 1 or 3, so

if (Version == 1)
  readByte(D);
else
  skipLeb128(D);

1117

More specific error message would be appreciated.

1130

More specific error message would be good. (error("Unknown XXX") or something like that.)

ELF/OutputSections.h

288

Is unsigned the right type here? If the linker runs on a 32-bit computer, it is 32-bit, but can it link a large 64-bit program?

444

Replace ` with ' (in general for propositions.)

[grimar]

• Addressed review comments
• Fixed eh-frame-hdr-no-out.s test

ELF/OutputSections.cpp

1008–1009

Hmm not sure how that happend. Fixed.

1031–1033

Now when there are few more specific errors introduced there is probably no need in that.

1059

Yes, nasty copypast issue :( I think I took it from llvm\tools\llvm-objdump\MachODump.cpp or llvm\lib\MC\MCDwarf.cpp where getSizeForEncoding() have the same one..

1094

Changed message to "CIE code alignment must be 1". As CIE also has data alignment factor.

ELF/OutputSections.h

288

Its constructed from
unsigned Index = S->Offsets.size();
...
Cie<ELFT> C(S, Index);
So it seems more correct would be to use size_t instead of unsigned. But I guess its not possible in real life to have overflow here (its hard to imagine).

[ruiu]

LGTM with a few nits.

ELF/OutputSections.cpp

814–815

Write this in one line.

822

It is odd that we are using uintX_t here but we write it as a 32-bit integer. Shouldn't we just use uint32_t here?

825

Ditto

1052

format -> Format

1100

else if (Version == 3) -> else

because we know that it's always 3.

ELF/OutputSections.h

438

Please move this above the definition of align.

[grimar]

ELF/OutputSections.cpp

825

What about eliminating them ?

  for (auto &I : PcToOffset) {
    // The first four bytes are an offset to the initial PC value for the FDE.
    write32<E>(Buf, I.first - VA);
    // The last four bytes are an offset to the FDE data itself.
    write32<E>(Buf + 4, EhVA + I.second - VA);
    Buf += 8;
  }
}

[ruiu]

ELF/OutputSections.cpp

825

LGTM

[grimar]

ELF/OutputSections.cpp

825

Nice. Thanks for review ! I'll commit this tomorrow.

[grimar]

ELF/OutputSections.cpp

1052

Replaced with

switch (Enc & 0x0f) {

ELF/OutputSections.h

481

I renamed class EhFrameHdr to EhFrameHeader because of compile error under linux here.

ELF/Config.h

struct Configuration {
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
+  bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;
   bool GnuHash = false;
   bool Mips64EL = false;
   bool NoInhibitExec;
   bool NoUndefined;
   bool PrintGcSections;

ELF/Driver.cpp

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->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
+  Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);

ELF/Options.td

def discard_locals : Flag<["-"], "discard-locals">,
   HelpText<"Delete temporary local symbols">;
 
 def discard_none : Flag<["-"], "discard-none">,
   HelpText<"Keep all symbols in the symbol table">;
 
 def dynamic_linker : Separate<["--", "-"], "dynamic-linker">,
   HelpText<"Which dynamic linker to use">;
 
+def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">,
+  HelpText<"Request creation of .eh_frame_hdr section and PT_GNU_EH_FRAME segment header">;
+
 def enable_new_dtags : Flag<["--"], "enable-new-dtags">,
   HelpText<"Enable new dynamic tags">;
 
 def entry : Separate<["--", "-"], "entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def export_dynamic : Flag<["--", "-"], "export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;

 // These options are recongized for compatibility but ignored.
 def end_group : Flag<["--"], "end-group">;
 def end_group_paren: Flag<["-"], ")">;
 def start_group : Flag<["--"], "start-group">;
 def start_group_paren: Flag<["-"], "(">;
 
 // Options listed below are silently ignored for now for compatibility.
 def build_id : Flag<["--"], "build-id">;
-def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">;
 def fatal_warnings : Flag<["--"], "fatal-warnings">;
 def no_add_needed : Flag<["--"], "no-add-needed">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def no_warn_mismatch : Flag<["--"], "no-warn-mismatch">;
 def version_script : Separate<["--"], "version-script">;
 def warn_common : Flag<["--"], "warn-common">;
 def warn_shared_textrel : Flag<["--"], "warn-shared-textrel">;
 def G : Separate<["-"], "G">;
 
 // Aliases for ignored options
 def alias_version_script_version_script : Joined<["--"], "version-script=">, Alias<version_script>;

ELF/OutputSections.h

template <class ELFT> struct EHRegion {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   EHRegion(EHInputSection<ELFT> *S, unsigned Index);
   StringRef data() const;
   EHInputSection<ELFT> *S;
   unsigned Index;
 };
 
 template <class ELFT> struct Cie : public EHRegion<ELFT> {
   Cie(EHInputSection<ELFT> *S, unsigned Index);
   std::vector<EHRegion<ELFT>> Fdes;
+  uint8_t FdeEncoding;
 };
 
 template <class ELFT>
 class EHOutputSection final : public OutputSectionBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   EHOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void writeTo(uint8_t *Buf) override;
 
   template <bool IsRela>
   void addSectionAux(
       EHInputSection<ELFT> *S,
       llvm::iterator_range<const llvm::object::Elf_Rel_Impl<ELFT, IsRela> *>
           Rels);
 
   void addSection(InputSectionBase<ELFT> *S) override;
 
 private:
+  uint8_t getFdeEncoding(ArrayRef<uint8_t> D);
   uintX_t readEntryLength(ArrayRef<uint8_t> D);
 
   std::vector<EHInputSection<ELFT> *> Sections;
   std::vector<Cie<ELFT>> Cies;
 
   // Maps CIE content + personality to a index in Cies.
   llvm::DenseMap<std::pair<StringRef, StringRef>, unsigned> CieMap;
 };
public:
   MipsReginfoOutputSection();
   void writeTo(uint8_t *Buf) override;
   void addSection(InputSectionBase<ELFT> *S) override;
 
 private:
   uint32_t GprMask = 0;
 };
 
 inline uint64_t align(uint64_t Value, uint64_t Align) {
   return llvm::RoundUpToAlignment(Value, Align);
 }
 
+// --eh-frame-hdr option tells linker to construct a header for all the
+// .eh_frame sections. This header is placed to a section named .eh_frame_hdr
+// and also to a PT_GNU_EH_FRAME segment.
+// At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
+// calling dl_iterate_phdr.
+// This section contains a lookup table for quick binary search of FDEs.
+// Detailed info about internals can be found in Ian Lance Taylor`s blog:
+// http://www.airs.com/blog/archives/460 (".eh_frame")
+// http://www.airs.com/blog/archives/462 (".eh_frame_hdr")
+template <class ELFT> class EhFrameHdr final : public OutputSectionBase<ELFT> {
+  typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
+
+public:
+  EhFrameHdr();
+  void writeTo(uint8_t *Buf) override;
+
+  void addFde(uint8_t Enc, size_t Off, uint8_t *PCRel);
+  void assignEhFrame(EHOutputSection<ELFT> *Sec);
+  void reserveFde();
+
+  bool Live = false;
+
+private:
+  struct FdeData {
+    uint8_t Enc;
+    size_t Off;
+    uint8_t *PCRel;
+  };
+
+  uintX_t getFdePc(uintX_t EhVA, const FdeData &F);
+
+  EHOutputSection<ELFT> *Sec = nullptr;
+  std::vector<FdeData> FdeList;
+};
+
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   static DynamicSection<ELFT> *Dynamic;
+  static EhFrameHdr<ELFT> *EhFrameHdr;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSection<ELFT> *MipsRldMap;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
   static Elf_Phdr *TlsPhdr;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
+template <class ELFT> EhFrameHdr<ELFT> *Out<ELFT>::EhFrameHdr;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;

ELF/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 #include "Config.h"
 #include "SymbolTable.h"
 #include "Target.h"
+#include "llvm/Support/Dwarf.h"
 #include "llvm/Support/MathExtras.h"
+#include <map>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
if (Config->EMachine == EM_MIPS) {
     WritePtr(DT_PLTGOT, Out<ELFT>::Got->getVA());
     if (Out<ELFT>::MipsRldMap)
       WritePtr(DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap->getVA());
   }
 
   WriteVal(DT_NULL, 0);
 }
 
 template <class ELFT>
+EhFrameHdr<ELFT>::EhFrameHdr()
+    : OutputSectionBase<ELFT>(".eh_frame_hdr", llvm::ELF::SHT_PROGBITS,
+                              SHF_ALLOC) {
+  // It's a 4 bytes of header + pointer to the contents of the .eh_frame section
+  // + the number of FDE pointers in the table.
+  this->Header.sh_size = 12;
+}
+
+// We have to get PC values of FDEs. They depend on relocations
+// which are target specific, so we run this code after performing
+// all relocations. We read the values from ouput buffer according to the
+// encoding given for FDEs. Return value is an offset to the initial PC value
+// for the FDE.
+template <class ELFT>
+typename EhFrameHdr<ELFT>::uintX_t
+EhFrameHdr<ELFT>::getFdePc(uintX_t EhVA, const FdeData &F) {
+  const endianness E = ELFT::TargetEndianness;
+  assert((F.Enc & 0xF0) != dwarf::DW_EH_PE_datarel);
+
+  uintX_t FdeOff = EhVA + F.Off + 8;
+  switch (F.Enc & 0xF) {
+  case dwarf::DW_EH_PE_udata2:
+  case dwarf::DW_EH_PE_sdata2:
+    return FdeOff + read16<E>(F.PCRel);
+  case dwarf::DW_EH_PE_udata4:
+  case dwarf::DW_EH_PE_sdata4:
+    return FdeOff + read32<E>(F.PCRel);
+  case dwarf::DW_EH_PE_udata8:
+  case dwarf::DW_EH_PE_sdata8:
+    return FdeOff + read64<E>(F.PCRel);
+  case dwarf::DW_EH_PE_absptr:
+    if (sizeof(uintX_t) == 8)
+      return FdeOff + read64<E>(F.PCRel);
+    return FdeOff + read32<E>(F.PCRel);
+  }
+  error("unknown FDE size encoding");
+}
+
+template <class ELFT> void EhFrameHdr<ELFT>::writeTo(uint8_t *Buf) {
+  const endianness E = ELFT::TargetEndianness;
+
+  const uint8_t Header[] = {1, dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4,
+                            dwarf::DW_EH_PE_udata4,
+                            dwarf::DW_EH_PE_datarel | dwarf::DW_EH_PE_sdata4};
+  memcpy(Buf, Header, sizeof(Header));
+
+  uintX_t EhVA = Sec->getVA();
+  uintX_t VA = this->getVA();
+  uintX_t EhOff = EhVA - VA - 4;
+  write32<E>(Buf + 4, EhOff);
+  write32<E>(Buf + 8, this->FdeList.size());
+  Buf += 12;
+
+  // InitialPC -> Offset in .eh_frame,
+  // sorted by InitialPC.
+  std::map<uintX_t, size_t> PcToOffset;
+  for (const FdeData &F : FdeList)
+    PcToOffset[getFdePc(EhVA, F)] = F.Off;
+
+  for (auto &I : PcToOffset) {
+    // The first four bytes are an offset to the initial PC value for the FDE.
+    uintX_t InitialPcOff = I.first - VA;
+    write32<E>(Buf, InitialPcOff);
+    // The last four bytes are an offset to the FDE data itself.
+    uintX_t FdeDataOff = EhVA + I.second - VA;
+    write32<E>(Buf + 4, FdeDataOff);
+    Buf += 8;
+  }
+}
+
+template <class ELFT>
+void EhFrameHdr<ELFT>::assignEhFrame(EHOutputSection<ELFT> *Sec) {
+  if (this->Sec && this->Sec != Sec) {
+    warning("multiple .eh_frame sections not supported for .eh_frame_hdr");
+    Live = false;
+    return;
+  }
+  Live = Config->EhFrameHdr;
+  this->Sec = Sec;
+}
+
+template <class ELFT>
+void EhFrameHdr<ELFT>::addFde(uint8_t Enc, size_t Off, uint8_t *PCRel) {
+  if (Live && (Enc & 0xF0) == dwarf::DW_EH_PE_datarel) {
+    error("DW_EH_PE_datarel encoding unsupported for FDEs by .eh_frame_hdr");
+  }
+  FdeList.push_back(FdeData{Enc, Off, PCRel});
+}
+
+template <class ELFT> void EhFrameHdr<ELFT>::reserveFde() {
+  // Each FDE entry is 8 bytes long:
+  // The first four bytes are an offset to the initial PC value for the FDE. The
+  // last four byte are an offset to the FDE data itself.
+  this->Header.sh_size += 8;
+}
+
+template <class ELFT>
 OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type,
                                    uintX_t Flags)
     : OutputSectionBase<ELFT>(Name, Type, Flags) {}
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<InputSection<ELFT>>(C);
   Sections.push_back(S);

 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Sections)
     C->writeTo(Buf);
 }
 
 template <class ELFT>
-EHOutputSection<ELFT>::EHOutputSection(StringRef Name, uint32_t Type,
-                                       uintX_t Flags)
-    : OutputSectionBase<ELFT>(Name, Type, Flags) {}
+EHOutputSection<ELFT>::EHOutputSection(StringRef Name, uint32_t sh_type,
+                                       uintX_t sh_flags)
+    : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {
+  Out<ELFT>::EhFrameHdr->assignEhFrame(this);
+}
 
 template <class ELFT>
 EHRegion<ELFT>::EHRegion(EHInputSection<ELFT> *S, unsigned Index)
     : S(S), Index(Index) {}
 
 template <class ELFT> StringRef EHRegion<ELFT>::data() const {
   ArrayRef<uint8_t> SecData = S->getSectionData();
   ArrayRef<std::pair<uintX_t, uintX_t>> Offsets = S->Offsets;
   size_t Start = Offsets[Index].first;
   size_t End =
       Index == Offsets.size() - 1 ? SecData.size() : Offsets[Index + 1].first;
   return StringRef((const char *)SecData.data() + Start, End - Start);
 }
 
 template <class ELFT>
 Cie<ELFT>::Cie(EHInputSection<ELFT> *S, unsigned Index)
     : EHRegion<ELFT>(S, Index) {}
 
+static void cieParseError() {
+  error("corrupted or unsupported CIE information");
+}
+
+// Read a byte and advance D by one byte.
+static uint8_t readByte(ArrayRef<uint8_t> &D) {
+  if (D.empty())
+    cieParseError();
+  uint8_t B = D.front();
+  D = D.slice(1);
+  return B;
+}
+
+static void skipLeb128(ArrayRef<uint8_t> &D) {
+  while (!D.empty()) {
+    uint8_t Val = D.front();
+    D = D.slice(1);
+    if ((Val & 0x80) == 0)
+      return;
+  }
+  cieParseError();
+}
+
+template <class ELFT> static unsigned getSizeForEncoding(unsigned Enc) {
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
+  unsigned format = Enc & 0x0f;
+  switch (format) {
+  default:
+    llvm_unreachable("Unknown encoding");
+  case dwarf::DW_EH_PE_absptr:
+  case dwarf::DW_EH_PE_signed:
+    return sizeof(uintX_t);
+  case dwarf::DW_EH_PE_udata2:
+  case dwarf::DW_EH_PE_sdata2:
+    return 2;
+  case dwarf::DW_EH_PE_udata4:
+  case dwarf::DW_EH_PE_sdata4:
+    return 4;
+  case dwarf::DW_EH_PE_udata8:
+  case dwarf::DW_EH_PE_sdata8:
+    return 8;
+  }
+}
+
+template <class ELFT>
+uint8_t EHOutputSection<ELFT>::getFdeEncoding(ArrayRef<uint8_t> D) {
+  auto Check = [](bool C) {
+    if (!C)
+      cieParseError();
+  };
+
+  Check(D.size() >= 8);
+  D = D.slice(8);
+
+  uint8_t Version = readByte(D);
+  Check(Version == 1 || Version == 3);
+
+  auto AugEnd = std::find(D.begin() + 1, D.end(), '\0');
+  Check(AugEnd != D.end());
+  ArrayRef<uint8_t> AugString(D.begin(), AugEnd - D.begin());
+  D = D.slice(AugString.size() + 1);
+
+  // Code alignment factor should always be 1 for .eh_frame.
+  Check(readByte(D) == 1);
+  // Skip data alignment factor
+  skipLeb128(D);
+
+  // Skip the return address register. In CIE version 1 this is a single
+  // byte. In CIE version 3 this is an unsigned LEB128.
+  if (Version == 1)
+    readByte(D);
+  else if (Version == 3)
+    skipLeb128(D);
+  else
+    cieParseError();
+
+  while (!AugString.empty()) {
+    switch (readByte(AugString)) {
+    case 'z':
+      skipLeb128(D);
+      break;
+    case 'R':
+      return readByte(D);
+    case 'P': {
+      uint8_t Enc = readByte(D);
+      // DW_EH_PE_aligned not yet supported.
+      Check((Enc & 0xf0) != dwarf::DW_EH_PE_aligned);
+      unsigned EncSize = getSizeForEncoding<ELFT>(Enc);
+      Check(D.size() >= EncSize);
+      D = D.slice(EncSize);
+      break;
+    }
+    case 'S':
+    case 'L':
+      // L: Language Specific Data Area (LSDA) encoding
+      // S: This CIE represents a stack frame for the invocation of a signal
+      //    handler
+      break;
+    default:
+      cieParseError();
+    }
+  }
+  return dwarf::DW_EH_PE_absptr;
+}
+
 template <class ELFT>
 template <bool IsRela>
 void EHOutputSection<ELFT>::addSectionAux(
     EHInputSection<ELFT> *S,
     iterator_range<const Elf_Rel_Impl<ELFT, IsRela> *> Rels) {
   const endianness E = ELFT::TargetEndianness;
 
   S->OutSec = this;
   uint32_t Align = S->getAlign();
while (RelI != RelE && RelI->r_offset < Offset)
       ++RelI;
     uintX_t NextOffset = Offset + Length;
     bool HasReloc = RelI != RelE && RelI->r_offset < NextOffset;
 
     uint32_t ID = read32<E>(D.data() + 4);
     if (ID == 0) {
       // CIE
       Cie<ELFT> C(S, Index);
+      if (Config->EhFrameHdr)
+        C.FdeEncoding = getFdeEncoding(D);
 
       StringRef Personality;
       if (HasReloc) {
         uint32_t SymIndex = RelI->getSymbol(Config->Mips64EL);
         SymbolBody &Body = *S->getFile()->getSymbolBody(SymIndex)->repl();
         Personality = Body.getName();
       }
 
       std::pair<StringRef, StringRef> CieInfo(Entry, Personality);
       auto P = CieMap.insert(std::make_pair(CieInfo, Cies.size()));
       if (P.second) {
         Cies.push_back(C);
         this->Header.sh_size += align(Length, sizeof(uintX_t));
       }
       OffsetToIndex[Offset] = P.first->second;
     } else {
       if (!HasReloc)
         error("FDE doesn't reference another section");
       InputSectionBase<ELFT> *Target = S->getRelocTarget(*RelI);
       if (Target != &InputSection<ELFT>::Discarded && Target->isLive()) {
         uint32_t CieOffset = Offset + 4 - ID;
         auto I = OffsetToIndex.find(CieOffset);
         if (I == OffsetToIndex.end())
           error("Invalid CIE reference");
         Cies[I->second].Fdes.push_back(EHRegion<ELFT>(S, Index));
+        Out<ELFT>::EhFrameHdr->reserveFde();
         this->Header.sh_size += align(Length, sizeof(uintX_t));
       }
     }
 
     Offset = NextOffset;
     D = D.slice(Length);
   }
 }
EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
   if (Len > (UINT64_MAX - 12))
     error("CIE/FIE size is too large");
   if (Len + 12 > D.size())
     error("CIE/FIE ends past the end of the section");
   return Len + 12;
 }
 
 template <class ELFT>
 void EHOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<EHInputSection<ELFT>>(C);
   const Elf_Shdr *RelSec = S->RelocSection;
   if (!RelSec)
     return addSectionAux(
         S, make_range((const Elf_Rela *)nullptr, (const Elf_Rela *)nullptr));
   ELFFile<ELFT> &Obj = S->getFile()->getObj();
   if (RelSec->sh_type == SHT_RELA)
     return addSectionAux(S, Obj.relas(RelSec));
for (const Cie<ELFT> &C : Cies) {
     uintX_t CIELen = writeAlignedCieOrFde<ELFT>(C.data(), Buf + Offset);
     C.S->Offsets[C.Index].second = Offset;
     Offset += CIELen;
 
     for (const EHRegion<ELFT> &F : C.Fdes) {
       uintX_t Len = writeAlignedCieOrFde<ELFT>(F.data(), Buf + Offset);
       write32<E>(Buf + Offset + 4, Offset + 4 - CieOffset); // Pointer
       F.S->Offsets[F.Index].second = Offset;
+      Out<ELFT>::EhFrameHdr->addFde(C.FdeEncoding, Offset, Buf + Offset + 8);
       Offset += Len;
     }
   }
 
   for (EHInputSection<ELFT> *S : Sections) {
     const Elf_Shdr *RelSec = S->RelocSection;
     if (!RelSec)
       continue;

 
 namespace lld {
 namespace elf2 {
 template class OutputSectionBase<ELF32LE>;
 template class OutputSectionBase<ELF32BE>;
 template class OutputSectionBase<ELF64LE>;
 template class OutputSectionBase<ELF64BE>;
 
+template class EhFrameHdr<ELF32LE>;
+template class EhFrameHdr<ELF32BE>;
+template class EhFrameHdr<ELF64LE>;
+template class EhFrameHdr<ELF64BE>;
+
 template class GotPltSection<ELF32LE>;
 template class GotPltSection<ELF32BE>;
 template class GotPltSection<ELF64LE>;
 template class GotPltSection<ELF64BE>;
 
 template class GotSection<ELF32LE>;
 template class GotSection<ELF32BE>;
 template class GotSection<ELF64LE>;

ELF/Writer.cpp

template <class ELFT> void elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   bool IsRela = shouldUseRela<ELFT>();
   RelocationSection<ELFT> RelaDyn(IsRela ? ".rela.dyn" : ".rel.dyn", IsRela);
   Out<ELFT>::RelaDyn = &RelaDyn;
   RelocationSection<ELFT> RelaPlt(IsRela ? ".rela.plt" : ".rel.plt", IsRela);
   if (Target->supportsLazyRelocations())
     Out<ELFT>::RelaPlt = &RelaPlt;
   DynamicSection<ELFT> Dynamic(*Symtab);
   Out<ELFT>::Dynamic = &Dynamic;
+  EhFrameHdr<ELFT> EhFrameHdr;
+  Out<ELFT>::EhFrameHdr = &EhFrameHdr;
 
   Writer<ELFT>(*Symtab).run();
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   buildSectionMap();
   if (!Config->DiscardAll)
if (HasGotOffRel)
     needsGot = true;
 
   if (needsGot)
     Add(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     Add(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     Add(Out<ELFT>::Plt);
+
+  if (Out<ELFT>::EhFrameHdr->Live)
+    Add(Out<ELFT>::EhFrameHdr);
 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End,
                     OutputSectionBase<ELFT> *OS) {
     if (OS) {
if (isOutputDynamic()) {
     copyPhdr(PH, Out<ELFT>::Dynamic);
   }
 
   if (HasRelro) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     *PH = GnuRelroPhdr;
   }
 
+  if (Out<ELFT>::EhFrameHdr->Live) {
+    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
+    PH->p_type = PT_GNU_EH_FRAME;
+    copyPhdr(PH, Out<ELFT>::EhFrameHdr);
+  }
+
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     PH->p_type = PT_GNU_STACK;
     PH->p_flags = PF_R | PF_W;
   }
 
if (Last != Flags) {
       Last = Flags;
       ++I;
     }
   }
   if (Tls)
     ++I;
   if (HasRelro)
     ++I;
+  if (Out<ELFT>::EhFrameHdr->Live)
+    ++I;
   return I;
 }
 
 static uint32_t getELFFlags() {
   if (Config->EMachine != EM_MIPS)
     return 0;
   // FIXME: In fact ELF flags depends on ELF flags of input object files
   // and selected emulation. For now just use hard coded values.

test/ELF/eh-frame-hdr-no-out.s

+// REQUIRES: x86
+// RUN: not ld.lld --eh-frame-hdr %p/Inputs/invalid-cie-version2.elf -o %t
+// CHECK: corrupted or unsupported CIE information
+
+// invalid-cie-version2.elf contains unsupported version of CIE = 2.

test/ELF/eh-frame-hdr-no-out2.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld --eh-frame-hdr %t.o -o %t
+// RUN: llvm-readobj -s -program-headers %t | FileCheck %s --check-prefix=NOHDR
+
+.section foo,"ax",@progbits
+ nop
+
+.text
+.globl _start;
+_start:
+
+// There is no .eh_frame section,
+// therefore .eh_frame_hdr also not created.
+// NOHDR:       Sections [
+// NOHDR-NOT:    Name: .eh_frame
+// NOHDR-NOT:    Name: .eh_frame_hdr
+// NOHDR:      ProgramHeaders [
+// NOHDR-NOT:   PT_GNU_EH_FRAME

test/ELF/eh-frame-hdr.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-readobj -file-headers -s -section-data -program-headers -symbols %t | FileCheck %s --check-prefix=NOHDR
+// RUN: ld.lld --eh-frame-hdr %t.o -o %t
+// RUN: llvm-readobj -file-headers -s -section-data -program-headers -symbols %t | FileCheck %s --check-prefix=HDR
+// RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=HDRDISASM
+
+.section foo,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section bar,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section dah,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.text
+.globl _start;
+_start:
+
+// NOHDR:       Sections [
+// NOHDR-NOT:    Name: .eh_frame_hdr
+// NOHDR:      ProgramHeaders [
+// NOHDR-NOT:   PT_GNU_EH_FRAME
+
+//HDRDISASM:      Disassembly of section foo:
+//HDRDISASM-NEXT: foo:
+//HDRDISASM-NEXT:    11000: 90 nop
+//HDRDISASM-NEXT: Disassembly of section bar:
+//HDRDISASM-NEXT: bar:
+//HDRDISASM-NEXT:    11001: 90 nop
+//HDRDISASM-NEXT: Disassembly of section dah:
+//HDRDISASM-NEXT: dah:
+//HDRDISASM-NEXT:    11002: 90 nop
+
+// HDR:       Sections [
+// HDR:        Section {
+// HDR:        Index: 1
+// HDR-NEXT:    Name: .eh_frame
+// HDR-NEXT:    Type: SHT_X86_64_UNWIND
+// HDR-NEXT:    Flags [
+// HDR-NEXT:      SHF_ALLOC
+// HDR-NEXT:    ]
+// HDR-NEXT:    Address: 0x10158
+// HDR-NEXT:    Offset: 0x158
+// HDR-NEXT:    Size: 96
+// HDR-NEXT:    Link: 0
+// HDR-NEXT:    Info: 0
+// HDR-NEXT:    AddressAlignment: 8
+// HDR-NEXT:    EntrySize: 0
+// HDR-NEXT:    SectionData (
+// HDR-NEXT:      0000: 14000000 00000000 017A5200 01781001  |
+// HDR-NEXT:      0010: 1B0C0708 90010000 14000000 1C000000  |
+// HDR-NEXT:      0020: 880E0000 01000000 00000000 00000000  |
+// HDR-NEXT:      0030: 14000000 34000000 710E0000 01000000  |
+// HDR-NEXT:      0040: 00000000 00000000 14000000 4C000000  |
+// HDR-NEXT:      0050: 5A0E0000 01000000 00000000 00000000  |
+//            CIE: 14000000 00000000 017A5200 01781001 1B0C0708 90010000
+//            FDE(1): 14000000 1C000000 880E0000 01000000 00000000 00000000
+//                    address of data (starts with 0x880E0000) = 0x10158 + 0x0020 = 0x10178
+//                    The starting address to which this FDE applies = 0xE88 + 0x10178 = 0x11000
+//                    The number of bytes after the start address to which this FDE applies = 0x01000000 = 1
+//            FDE(2): 14000000 34000000 710E0000 01000000 00000000 00000000
+//                    address of data (starts with 0x710E0000) = 0x10158 + 0x0038 = 0x10190
+//                    The starting address to which this FDE applies = 0xE71 + 0x10190 = 0x11001
+//                    The number of bytes after the start address to which this FDE applies = 0x01000000 = 1
+//            FDE(3): 14000000 4C000000 5A0E0000 01000000 00000000 00000000
+//                    address of data (starts with 0x5A0E0000) = 0x10158 + 0x0050 = 0x101A8
+//                    The starting address to which this FDE applies = 0xE5A + 0x101A8 = 0x11002
+//                    The number of bytes after the start address to which this FDE applies = 0x01000000 = 1
+// HDR-NEXT:    )
+// HDR-NEXT:  }
+// HDR-NEXT:  Section {
+// HDR-NEXT:    Index: 2
+// HDR-NEXT:    Name: .eh_frame_hdr
+// HDR-NEXT:    Type: SHT_PROGBITS
+// HDR-NEXT:    Flags [
+// HDR-NEXT:      SHF_ALLOC
+// HDR-NEXT:    ]
+// HDR-NEXT:    Address: 0x101B8
+// HDR-NEXT:    Offset: 0x1B8
+// HDR-NEXT:    Size: 36
+// HDR-NEXT:    Link: 0
+// HDR-NEXT:    Info: 0
+// HDR-NEXT:    AddressAlignment: 0
+// HDR-NEXT:    EntrySize: 0
+// HDR-NEXT:    SectionData (
+// HDR-NEXT:      0000: 011B033B 9CFFFFFF 03000000 480E0000  |
+// HDR-NEXT:      0010: B8FFFFFF 490E0000 D0FFFFFF 4A0E0000  |
+// HDR-NEXT:      0020: E8FFFFFF                             |
+//                Header (always 4 bytes): 0x011B033B
+//                   9CFFFFFF = .eh_frame(0x10158) - .eh_frame_hdr(0x101B8) - 4
+//                   03000000 = 3 = the number of FDE pointers in the table.
+//                Entry(1): 480E0000 B8FFFFFF
+//                   480E0000 = 0x11000 - .eh_frame_hdr(0x101B8) = 0xE48
+//                   B8FFFFFF = address of FDE(1) - .eh_frame_hdr(0x101B8) =
+//                      = .eh_frame(0x10158) + 24 - 0x101B8 = 0xFFFFFFB8
+//                Entry(2): 490E0000 D0FFFFFF
+//                   490E0000 = 0x11001 - .eh_frame_hdr(0x101B8) = 0xE49
+//                   D0FFFFFF = address of FDE(2) - .eh_frame_hdr(0x101B8) =
+//                      = .eh_frame(0x10158) + 24 + 24 - 0x101B8 = 0xFFFFFFD0
+//                Entry(3): 4A0E0000 E8FFFFFF
+//                   4A0E0000 = 0x11002 - .eh_frame_hdr(0x101B8) = 0xE4A
+//                   E8FFFFFF = address of FDE(2) - .eh_frame_hdr(0x101B8) =
+//                      = .eh_frame(0x10158) + 24 + 24 - 0x101B8 = 0xFFFFFFE8
+// HDR-NEXT:    )
+// HDR-NEXT:  }
+// HDR:     ProgramHeaders [
+// HDR:      ProgramHeader {
+// HDR:       Type: PT_GNU_EH_FRAME
+// HDR-NEXT:   Offset: 0x1B8
+// HDR-NEXT:   VirtualAddress: 0x101B8
+// HDR-NEXT:   PhysicalAddress: 0x101B8
+// HDR-NEXT:   FileSize: 36
+// HDR-NEXT:   MemSize: 36
+// HDR-NEXT:   Flags [
+// HDR-NEXT:     PF_R
+// HDR-NEXT:   ]
+// HDR-NEXT:   Alignment: 1
+// HDR-NEXT: }