[ELF] Add .eh_frame pieces to map file

[ruiu]

Summary

This patch is a simplified version of https://reviews.llvm.org/D42960
written by Andrew Ng.

[andrewng]

I agree that this change is simpler, but it also doesn't produce the same output as D42960. Part of the reason for the "complexity" in my change in D42960 was to try to prevent the map file output from getting too big/verbose.

However, this output is certainly more clear/explicit, if potentially rather verbose.

[ruiu]

How much do you have by you patch compared to this one? Actually I didn't notice that you patch tries squashing contiguous pieces to reduce number of lines until I apply your patch and play with that because the patch didn't explain that at all... So it just looked complicated.

[ruiu]

• squash contiguous section pieces.

[ruiu]

Turned out that squashing adjascent .eh_frame pieces before printing saves a lot of lines. When I used it agianst MySQL, it reduced the number of lines for .eh_frame in a map file by half. So we probably should do this.

[andrewng]

Apart from the typo and the value for the alignment, LGTM.

lld/ELF/MapFile.cpp

122 ↗

(On Diff #137246)

Typo: adjuscent -> adjacent.

143 ↗

(On Diff #137246)

Perhaps instead of 0 for the alignment, this could be the EhSectionPiece alignment which is Config->Wordsize?

[ruiu]

lld/ELF/MapFile.cpp

143 ↗

(On Diff #137246)

I actually don't think so -- I believe the section itself is aligned, but each piece within a section doesn't have a notion of alignment.

[andrewng]

Looking at the EhFrameSection writing and finalize code, it would seem that
some kind of alignment is being applied. This aligning is also the reason
why for x86_64 the mapping of CIE/FDE's to the output is so fragmented,
because all input we have seen is 4-byte aligned, but LLD uses 8-byte
alignment for the output.

Cheers,
Andrew

[• rafael]

Andrew Ng via Phabricator <[e-mail]> writes:

andrewng added a comment.

Looking at the EhFrameSection writing and finalize code, it would seem that
some kind of alignment is being applied. This aligning is also the reason
why for x86_64 the mapping of CIE/FDE's to the output is so fragmented,
because all input we have seen is 4-byte aligned, but LLD uses 8-byte
alignment for the output.

Both gcc and clang produce an alignment of 8 for a trivial function:

[ 6] .eh_frame PROGBITS 0000000000000000 000078 000038 00 A 0 0 8

The reason for doing that in an unfortunate backwards compatibility
problem. If a section whose size is not a multiple of 8 is followed by a
section aligned to 8 bytes we would have a zero padding which would be
interpreted as the terminator.

We (MC) could produce .eh_frame whose sizes are always multiples of 8
but the alignment is set to 4, but no one ever bothered to implement
that.

Cheers,
Rafael

lld/trunk/ELF/MapFile.cpp

getSymbolStrings(ArrayRef<Symbol *> Syms) {
   });
 
   DenseMap<Symbol *, std::string> Ret;
   for (size_t I = 0, E = Syms.size(); I < E; ++I)
     Ret[Syms[I]] = std::move(Str[I]);
   return Ret;
 }
 
+// Print .eh_frame contents. Since the section consists of EhSectionPieces,
+// we need a specialized printer for that section.
+//
+// .eh_frame tend to contain a lot of section pieces that are contiguous
+// both in input file and output file. Such pieces are squashed before
+// being displayed to make output compact.
+static void printEhFrame(raw_ostream &OS, OutputSection *OSec) {
+  std::vector<EhSectionPiece> Pieces;
+
+  auto Add = [&](const EhSectionPiece &P) {
+    // If P is adjacent to Last, squash the two.
+    if (!Pieces.empty()) {
+      EhSectionPiece &Last = Pieces.back();
+      if (Last.Sec == P.Sec && Last.InputOff + Last.Size == P.InputOff &&
+          Last.OutputOff + Last.Size == P.OutputOff) {
+        Last.Size += P.Size;
+        return;
+      }
+    }
+    Pieces.push_back(P);
+  };
+
+  // Gather section pieces.
+  for (const CieRecord *Rec : InX::EhFrame->getCieRecords()) {
+    Add(*Rec->Cie);
+    for (const EhSectionPiece *Fde : Rec->Fdes)
+      Add(*Fde);
+  }
+
+  // Print out section pieces.
+  for (EhSectionPiece &P : Pieces) {
+    writeHeader(OS, OSec->Addr + P.OutputOff, P.Size, 0);
+    OS << Indent8 << toString(P.Sec->File) << ":(" << P.Sec->Name << "+0x"
+       << Twine::utohexstr(P.InputOff) + ")\n";
+  }
+}
+
 void elf::writeMapFile() {
   if (Config->MapFile.empty())
     return;
 
   // Open a map file for writing.
   std::error_code EC;
   raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
   if (EC) {
void elf::writeMapFile() {
 
   // Print out file contents.
   for (OutputSection *OSec : OutputSections) {
     writeHeader(OS, OSec->Addr, OSec->Size, OSec->Alignment);
     OS << OSec->Name << '\n';
 
     // Dump symbols for each input section.
     for (InputSection *IS : getInputSections(OSec)) {
+      if (IS == InX::EhFrame) {
+        printEhFrame(OS, OSec);
+        continue;
+      }
+
       writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(), IS->Alignment);
       OS << Indent8 << toString(IS) << '\n';
       for (Symbol *Sym : SectionSyms[IS])
         OS << SymStr[Sym] << '\n';
     }
   }
 }
 

lld/trunk/ELF/SyntheticSections.h

public:
   size_t NumFdes = 0;
 
   struct FdeData {
     uint32_t Pc;
     uint32_t FdeVA;
   };
 
   std::vector<FdeData> getFdeData() const;
+  ArrayRef<CieRecord *> getCieRecords() const { return CieRecords; }
 
 private:
   uint64_t Size = 0;
 
   template <class ELFT, class RelTy>
   void addSectionAux(EhInputSection *S, llvm::ArrayRef<RelTy> Rels);
 
   template <class ELFT, class RelTy>

lld/trunk/test/ELF/Inputs/map-file2.s

 foo:
+.cfi_startproc
 nop
+.cfi_endproc
 .global bar
 bar:
 nop
 .section .text.zed,"ax",@progbits
 .global zed
 zed:

lld/trunk/test/ELF/map-file.s

 // RUN: llvm-ar rc %t4.a %t4.o
 // RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -M | FileCheck -strict-whitespace %s
 // RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -print-map | FileCheck -strict-whitespace %s
 // RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -Map=%t.map
 // RUN: FileCheck -strict-whitespace %s < %t.map
 
 .global _start
 _start:
+.cfi_startproc
+.cfi_endproc
  .quad sharedFoo
  .quad sharedBar
  .byte 0xe8
  .long sharedFunc1 - .
  .byte 0xe8
  .long sharedFunc2 - .
  .byte 0xe8
  .long baz - .
 .global _Z1fi
 _Z1fi:
 .cfi_startproc
-.cfi_endproc
 nop
+.cfi_endproc
 .weak bar
 bar:
 .long bar - .
 .long zed - .
 local:
 .comm   common,4,16
 .global abs
 abs = 0xAB5
 labs = 0x1AB5
 
 // CHECK:      Address          Size             Align Out     In      Symbol
 // CHECK-NEXT: 00000000002001c8 0000000000000078     8 .dynsym
 // CHECK-NEXT: 00000000002001c8 0000000000000078     8         <internal>:(.dynsym)
 // CHECK-NEXT: 0000000000200240 000000000000002c     8 .gnu.hash
 // CHECK-NEXT: 0000000000200240 000000000000002c     8         <internal>:(.gnu.hash)
 // CHECK-NEXT: 000000000020026c 0000000000000030     4 .hash
 // CHECK-NEXT: 000000000020026c 0000000000000030     4         <internal>:(.hash)
 // CHECK-NEXT: 000000000020029c 0000000000000031     1 .dynstr
 // CHECK-NEXT: 000000000020029c 0000000000000031     1         <internal>:(.dynstr)
 // CHECK-NEXT: 00000000002002d0 0000000000000030     8 .rela.dyn
 // CHECK-NEXT: 00000000002002d0 0000000000000030     8         <internal>:(.rela.dyn)
 // CHECK-NEXT: 0000000000200300 0000000000000030     8 .rela.plt
 // CHECK-NEXT: 0000000000200300 0000000000000030     8         <internal>:(.rela.plt)
-// CHECK-NEXT: 0000000000200330 0000000000000030     8 .eh_frame
-// CHECK-NEXT: 0000000000200330 0000000000000030     8         <internal>:(.eh_frame)
+// CHECK-NEXT: 0000000000200330 0000000000000060     8 .eh_frame
+// CHECK-NEXT: 0000000000200330 000000000000002c     0         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
+// CHECK-NEXT: 0000000000200360 0000000000000014     0         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
+// CHECK-NEXT: 0000000000200378 0000000000000018     0         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
 // CHECK-NEXT: 0000000000201000 000000000000002d     4 .text
 // CHECK-NEXT: 0000000000201000 0000000000000028     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 0000000000201000 0000000000000000     0                 _start
 // CHECK-NEXT: 000000000020101f 0000000000000000     0                 f(int)
 // CHECK-NEXT: 0000000000201028 0000000000000000     0                 local
 // CHECK-NEXT: 0000000000201028 0000000000000002     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
 // CHECK-NEXT: 0000000000201028 0000000000000000     0                 foo
 // CHECK-NEXT: 0000000000201029 0000000000000000     0                 bar