[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

875

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

879

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

882

This function needs a brief comment.

891–899

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;

937

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

968

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.

1153

Add a comment.

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

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

1193

Isn't this a fatal error?

1254

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

ELF/OutputSections.h

448

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

875

Done.

879

Added comment.

882

Done.

937

Interesting question. Fixed.

968

Added comment.

1153

Done.

1193

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.

1254

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

767

Add a space before "--".

778–779

Remove "llvm::ELF::".

780

` -> '

781

Its -> It's

794

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

800

switch (F.enc & 0xF)

831

It is better to advance Buf here.

Buf += 12;

851

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

if (this->Sec != Sec)

1122–1124

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

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

1136

Ditto

ELF/OutputSections.h

436

Please add a comment to this class.

437

You can remove this typedef.

[grimar]

• Addressed review comments.
• Rebased.

ELF/OutputSections.cpp

767

Done, comment was moved to class EhFrameHdr definition.

780

Removed that line.

851

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.

1122–1124

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.

1136

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

879

` -> '

892

Remove this empty line.

959

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.

1122–1124

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

879

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

959

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.

1122–1124

Ok, done.

[ruiu]

ELF/OutputSections.cpp

879

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

1085

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

1085

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

1085

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

[grimar]

getFdeEnc() -> getFdeEncoding()

[ruiu]

ELF/OutputSections.cpp

959

You can remove {}.

1020–1025

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

1043–1045

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

1071

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

1098

This is probably better.

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

1106

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

1112–1117

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

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

1129

More specific error message would be appreciated.

1142

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

ELF/OutputSections.h

286

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?

442

Replace ` with ' (in general for propositions.)

[grimar]

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

ELF/OutputSections.cpp

1020–1025

Hmm not sure how that happend. Fixed.

1043–1045

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

1071

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..

1106

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

ELF/OutputSections.h

286

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

929–930

Write this in one line.

937

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?

940

Ditto

1064

format -> Format

1112

else if (Version == 3) -> else

because we know that it's always 3.

ELF/OutputSections.h

436

Please move this above the definition of align.

[grimar]

ELF/OutputSections.cpp

940

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

940

LGTM

[grimar]

ELF/OutputSections.cpp

940

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

[grimar]

ELF/OutputSections.cpp

1064

Replaced with

switch (Enc & 0x0f) {

ELF/OutputSections.h

471

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(EHInputSection<ELFT> *S);
 
 private:
+  bool readCieInfo(Cie<ELFT> &Cie, 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:
   void writeTo(uint8_t *Buf) override;
 
   void addSection(MipsReginfoInputSection<ELFT> *S);
 
 private:
   uint32_t GeneralMask = 0;
 };
 
+template <class ELFT> class EhFrameHdr final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+  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);
 }
 
+//--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>
+EhFrameHdr<ELFT>::EhFrameHdr()
+    : OutputSectionBase<ELFT>(".eh_frame_hdr", llvm::ELF::SHT_PROGBITS,
+                              llvm::ELF::SHF_ALLOC) {
+  // This is initial size without counting FDE`s entries descriptors size.
+  // Its 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,
+                           typename const EhFrameHdr<ELFT>::FdeData &F) {
+  const endianness E = ELFT::TargetEndianness;
+  assert((F.Enc & 0xF0) != dwarf::DW_EH_PE_datarel);
+
+  uint8_t S = F.Enc & 0x0F;
+  uintX_t FdeOff = EhVA + F.Off + 8;
+  switch (S) {
+  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());
+
+  // 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 + 12, InitialPcOff);
+    // The last four bytes are an offset to the FDE data itself.
+    uintX_t FdeDataOff = EhVA + I.second - VA;
+    write32<E>(Buf + 16, 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 sh_type,
                                    uintX_t sh_flags)
     : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
   Sections.push_back(C);
   C->OutSec = this;
   uint32_t Align = C->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
 
   uintX_t Off = this->Header.sh_size;
   Off = RoundUpToAlignment(Off, Align);
   C->OutSecOff = Off;
   Off += C->getSize();
   this->Header.sh_size = Off;
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Value;
   }
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> *SC = DR.Section;
     if (!SC)
       return DR.Sym.st_value;
     if (DR.Sym.getType() == STT_TLS)
typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyKind:
     assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("Invalid symbol kind");
 }
 
 // Returns a VA which a relocatin RI refers to. Used only for local symbols.
 // For non-local symbols, use getSymVA instead.
 template <class ELFT, bool IsRela>
 typename ELFFile<ELFT>::uintX_t
 lld::elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
                              const Elf_Rel_Impl<ELFT, IsRela> &RI,
                              typename ELFFile<ELFT>::uintX_t Addend) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
   // PPC64 has a special relocation representing the TOC base pointer
   // that does not have a corresponding symbol.
   if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC)
     return getPPC64TocBase() + Addend;
 
   const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
   if (!Sym)
     error("Unsupported relocation without symbol");
 
   InputSectionBase<ELFT> *Section = File.getSection(*Sym);
 
   if (Sym->getType() == STT_TLS)
     return (Section->OutSec->getVA() + Section->getOffset(*Sym) + Addend) -
            Out<ELFT>::TlsPhdr->p_vaddr;
 
   // According to the ELF spec reference to a local symbol from outside
   // the group are not allowed. Unfortunately .eh_frame breaks that rule
   // and must be treated specially. For now we just replace the symbol with
   // 0.
   if (Section == &InputSection<ELFT>::Discarded || !Section->isLive())
     return Addend;
 
   uintX_t VA = Section->OutSec->getVA();
   if (isa<InputSection<ELFT>>(Section))
     return VA + Section->getOffset(*Sym) + Addend;
 
   uintX_t Offset = Sym->st_value;
   if (Sym->getType() == STT_SECTION) {
     Offset += Addend;
     Addend = 0;
   }
   return VA + Section->getOffset(Offset) + Addend;
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol

 }
 
 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 sh_type,
                                        uintX_t sh_flags)
-    : OutputSectionBase<ELFT>(Name, sh_type, 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) {}
 
+// Read a byte and advance D by one byte.
+static bool readByte(ArrayRef<uint8_t> &D, uint8_t *R = nullptr) {
+  if (D.empty())
+    return false;
+  if (R)
+    *R = D.front();
+  D = D.slice(1);
+  return true;
+}
+
+static bool skipLeb128(ArrayRef<uint8_t> &D) {
+  while (!D.empty()) {
+    uint8_t Val = D.front();
+    D = D.slice(1);
+    if ((Val & 0x80) == 0)
+      return true;
+  }
+  return false;
+}
+
+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>
+bool EHOutputSection<ELFT>::readCieInfo(Cie<ELFT> &Cie, ArrayRef<uint8_t> D) {
+  uint8_t Version;
+  if (!readByte(D, &Version))
+    return false;
+  if (Version != 1 && Version != 3)
+    return false;
+
+  auto AugEnd = std::find(D.begin() + 1, D.end(), '\0');
+  if (AugEnd == D.end())
+    return false;
+
+  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.
+  uint8_t CodeAlign;
+  if (!readByte(D, &CodeAlign) || CodeAlign != 1)
+    return false;
+  // Skip data alignment factor
+  if (!skipLeb128(D))
+    return false;
+
+  // 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)) || (Version == 3 && !skipLeb128(D)))
+    return false;
+
+  uint8_t FdeEnc = dwarf::DW_EH_PE_absptr;
+  uint8_t AugSym;
+  while (readByte(AugString, &AugSym)) {
+    switch (AugSym) {
+    case 'z':
+      if (!skipLeb128(D))
+        return false;
+      break;
+    case 'R':
+      if (!readByte(D, &FdeEnc))
+        return false;
+      break;
+    case 'P': {
+      uint8_t Enc;
+      if (!readByte(D, &Enc))
+        return false;
+      unsigned EncSize = getSizeForEncoding<ELFT>(Enc);
+      // DW_EH_PE_aligned not yet supported.
+      if ((Enc & 0xf0) == dwarf::DW_EH_PE_aligned)
+        return false;
+      if (D.size() < EncSize)
+        return false;
+      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:
+      return false;
+    }
+  }
+
+  Cie.FdeEncoding = FdeEnc;
+  return true;
+}
+
 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 (!D.empty()) {
     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 (!readCieInfo(C, ArrayRef<uint8_t>(D.data() + 8, Length - 8))) {
+        Out<ELFT>::EhFrameHdr->Live = false;
+        warning("corrupted or unsupported CIE information");
+      }
+
       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 += RoundUpToAlignment(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 += RoundUpToAlignment(Length, sizeof(uintX_t));
       }
     }
 
     Offset = NextOffset;
     D = D.slice(Length);
   }
 }
EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
   if (D.size() < 12)
     error("Truncated CIE/FDE length");
   Len = read64<E>(D.data() + 4);
   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(EHInputSection<ELFT> *S) {
   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();
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 lld::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)
template <class ELFT> void Writer<ELFT>::createSections() {
 
   if (needsGot)
     OutputSections.push_back(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     OutputSections.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
+  if (Out<ELFT>::EhFrameHdr->Live)
+    OutputSections.push_back(Out<ELFT>::EhFrameHdr);
+
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareSections<ELFT>);
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I) {
     OutputSections[I]->SectionIndex = I + 1;
     HasRelro |= (Config->ZRelro && isRelroSection(OutputSections[I]));
   }
 
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 hadr coded values.

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

+// REQUIRES: x86
+// RUN: ld.lld --eh-frame-hdr %p/Inputs/invalid-cie-version2.elf -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 %p/Inputs/invalid-cie-version2.elf -o %t 2>&1 | FileCheck %s
+// CHECK: corrupted or unsupported CIE information
+
+// invalid-cie-version2.elf contains unsupported
+// version of CIE = 2. No .eh_frame_hdr is produced.
+// NOHDR:       Sections [
+// NOHDR-NOT:    Name: .eh_frame_hdr
+// NOHDR:      ProgramHeaders [
+// NOHDR-NOT:   PT_GNU_EH_FRAME

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: }