[ELF] - Reveal layout of synthetic mergeable sections when producing -Map

[grimar]

Summary

It is inspired by comments for PR35248 though not directly relative to it.
It turns out we do not show the internal layout for mergeable sections when
producing Map file. Though it can be useful to show where is content coming from and
what is initial size (before mrging) and final size.
Patch adds support for dumping such sections.

[ruiu]

How is this useful? Also, this change creates a malformed output that breaks the assumption that the 6th column contains symbol names.

[grimar]

In D40128#928250, @ruiu wrote:

How is this useful?

Isn't one of intentions of map file to show where are sections coming from ? Currently we don't print
file names for SHF_MERGE sections, that looks inconsistent with how we dump regular sections.

Also I think it can be useful to show difference between input and output size. That can be applied for mergeable
sections and also for compressed input/output ones.

Also, this change creates a malformed output that breaks the assumption that the 6th column contains symbol names.

Oops, I missed header says its should be symbol, sorry.

Will it make sence to omit synthetic part (which is there only because of our internal representation and not useful)
and print something like following then ?

Address          Size                 Align      Out           In
0000000000000000 0000000000000008     2          .strings
0000000000000000 0000000000000004     1                        {{.*}}{{/|\\}}map-file.s.tmp1.o:(.strings)
0000000000000000 0000000000000008     2                        {{.*}}{{/|\\}}map-file.s.tmp2.o:(.strings)

[ruiu]

First of all, the current output is consistent. It doesn't print out the information about mergeable input sections that consist make up an mergeable synthetic section, but that doesn't mean that the output is inconsistent.

So, back to the original question, I don't think the format you are proposing is useful for a few reasons:

• Address and size fields contains bogus values. So you cannot use these numbers to analyze the output
• There's no good way of printing out input sections that make up a synthetic section in the current format

I think the fundamental issue of this patch is that the information you are trying to print out doesn't actually fit well in the notion of the map file. The map file is to show how input sections are mapped to some contiguous output memory address, and it's not suitable to print out the information as to how mergeable section pieces are mapped to an output section.

[grimar]

In D40128#928354, @ruiu wrote:

First of all, the current output is consistent. It doesn't print out the information about mergeable input sections that consist make up an mergeable synthetic section, but that doesn't mean that the output is inconsistent.

So, back to the original question, I don't think the format you are proposing is useful for a few reasons:

• Address and size fields contains bogus values. So you cannot use these numbers to analyze the output

I cant just agree here, because they contain exactly what I wanted to see, but I should admit I might have misunderstood the
intention of map file. So it can be true. Let me think about it. Thank you for explanation.

• There's no good way of printing out input sections that make up a synthetic section in the current format

I think the fundamental issue of this patch is that the information you are trying to print out doesn't actually fit well in the notion of the map file. The map file is to show how input sections are mapped to some contiguous output memory address, and it's not suitable to print out the information as to how mergeable section pieces are mapped to an output section.

ELF/MapFile.cpp

 #include "MapFile.h"
 #include "InputFiles.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "lld/Common/Threads.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
 typedef DenseMap<const SectionBase *, SmallVector<Defined *, 4>> SymbolMapTy;
 
 // Print out the first three columns of a line.
for (BaseCommand *Base : OSec->SectionCommands) {
       if (!ISD)
         continue;
       for (InputSection *IS : ISD->Sections) {
         writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(),
                     IS->Alignment);
         OS << indent(1) << toString(IS) << '\n';
         for (Defined *Sym : SectionSyms[IS])
           OS << SymStr[Sym] << '\n';
+
+        // Dump synthetic mergeable sections layout.
+        if (!isa<SyntheticSection>(IS) || !(IS->Flags & SHF_MERGE))
+          continue;
+        MergeSyntheticSection *MS = static_cast<MergeSyntheticSection *>(IS);
+        for (MergeInputSection *Sec : MS->getSections()) {
+          writeHeader(OS, 0, Sec->getSize(), Sec->Alignment);
+          OS << indent(2) << toString(Sec) << '\n';
+        }
       }
     }
   }
 }

ELF/SyntheticSections.h

 // MergeSyntheticSection is a class that allows us to put mergeable sections
 // with different attributes in a single output sections. To do that
 // we put them into MergeSyntheticSection synthetic input sections which are
 // attached to regular output sections.
 class MergeSyntheticSection : public SyntheticSection {
 public:
   void addSection(MergeInputSection *MS);
 
+  ArrayRef<MergeInputSection *> getSections() { return Sections; }
+
 protected:
   MergeSyntheticSection(StringRef Name, uint32_t Type, uint64_t Flags,
                         uint32_t Alignment)
       : SyntheticSection(Flags, Type, Alignment, Name) {}
 
   std::vector<MergeInputSection *> Sections;
 };
 

test/ELF/Inputs/map-file2.s

 foo:
 nop
 .global bar
 bar:
 nop
 .section .text.zed,"ax",@progbits
 .global zed
 zed:
+.section .strings,"MS",@progbits,1
+.align 2
+.asciz "AAA"
+.asciz "AAA"

test/ELF/map-file.s

 .long bar - .
 .long zed - .
 local:
 .comm   common,4,16
 .global abs
 abs = 0xAB5
 labs = 0x1AB5
 
+.section .strings,"MS",@progbits,1
+.asciz "AAA"
+
 // CHECK:      Address          Size             Align Out     In      Symbol
 // CHECK-NEXT: 0000000000200158 0000000000000030     8 .eh_frame
 // CHECK-NEXT: 0000000000200158 0000000000000030     8         <internal>:(.eh_frame)
 // CHECK-NEXT: 0000000000201000 0000000000000015     4 .text
 // CHECK-NEXT: 0000000000201000 000000000000000e     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 0000000000201000 0000000000000000     0                 _start
 // CHECK-NEXT: 0000000000201005 0000000000000000     0                 f(int)
 // CHECK-NEXT: 000000000020100e 0000000000000000     0                 local
 // CHECK-NEXT: 0000000000201010 0000000000000002     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
 // CHECK-NEXT: 0000000000201010 0000000000000000     0                 foo
 // CHECK-NEXT: 0000000000201011 0000000000000000     0                 bar
 // CHECK-NEXT: 0000000000201012 0000000000000000     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
 // CHECK-NEXT: 0000000000201012 0000000000000000     0                 zed
 // CHECK-NEXT: 0000000000201014 0000000000000000     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
 // CHECK-NEXT: 0000000000201014 0000000000000000     0                 bah
 // CHECK-NEXT: 0000000000201014 0000000000000001     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
 // CHECK-NEXT: 0000000000201014 0000000000000000     0                 baz
 // CHECK-NEXT: 0000000000202000 0000000000000004    16 .bss
 // CHECK-NEXT: 0000000000202000 0000000000000004    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
 // CHECK-NEXT: 0000000000202000 0000000000000004     0                 common
+// CHECK-NEXT: 0000000000000000 0000000000000008     2 .strings
+// CHECK-NEXT: 0000000000000000 0000000000000004     1         <internal>:(.strings)
+// CHECK-NEXT: 0000000000000000 0000000000000004     1                 {{.*}}{{/|\\}}map-file.s.tmp1.o:(.strings)
+// CHECK-NEXT: 0000000000000004 0000000000000004     2         <internal>:(.strings)
+// CHECK-NEXT: 0000000000000000 0000000000000008     2                 {{.*}}{{/|\\}}map-file.s.tmp2.o:(.strings)
 // CHECK-NEXT: 0000000000000000 0000000000000008     1 .comment
 // CHECK-NEXT: 0000000000000000 0000000000000008     1         <internal>:(.comment)
+// CHECK-NEXT: 0000000000000000 0000000000000008     1                 <internal>:(.comment)
 // CHECK-NEXT: 0000000000000000 0000000000000120     8 .symtab
 // CHECK-NEXT: 0000000000000000 0000000000000120     8         <internal>:(.symtab)
-// CHECK-NEXT: 0000000000000000 0000000000000039     1 .shstrtab
-// CHECK-NEXT: 0000000000000000 0000000000000039     1         <internal>:(.shstrtab)
+// CHECK-NEXT: 0000000000000000 0000000000000042     1 .shstrtab
+// CHECK-NEXT: 0000000000000000 0000000000000042     1         <internal>:(.shstrtab)
 // CHECK-NEXT: 0000000000000000 0000000000000038     1 .strtab
 // CHECK-NEXT: 0000000000000000 0000000000000038     1         <internal>:(.strtab)
 
 // RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open map file /