[ELF] - Print LMA in a -Map file.

[grimar]

Summary

Currently, LLD prints VA, but not LMA in a map file.
It seems can be useful to print both to reveal layout details
and patch implements it.

Note that gold also show LMA in a map file, but it is very limited,
for example:

.ddd            0x000000000000104c      0x101 load address 0x000000000000303c
                0x000000000000104c        0x1 BYTE 0x11
                0x000000000000114d                . = (. + 0x100)
 *fill*         0x000000000000104d      0x100 
 *(.ddd.*)

.text           0x0000000000001150        0x1 load address 0x0000000000003140
 *(.text.*)
 .text          0x0000000000001150        0x1 test.o
                0x0000000000001150                _start
                0x0000000000001150                f(int)

I think we can do better and show more detailed info like this patch does.

One more thing I thought about was to hide LMA column if it is known there
is no difference with VA column. Then VA could be renamed to VA/LMA

[ruiu]

I don't know if this is useful. This makes every line in a map file longer. Can you explain why you thought that would be useful?

[peter.smith]

It can be very useful when developing embedded systems. There is often a case where the load address of an output section is in flash and it is copied to a different execution address in sdram. Seeing the load address in the map file can be useful when debugging problems, especially when the device won't boot up. It is probably sufficient to give the LMA of each OutputSection as the LMA of the input sections can be derived from it.

[ruiu]

ELF/MapFile.cpp

50

I think I'm fine with showing LMA along with VMA, but my concern was that we would be showing too much information that's not easy to digest. I have one suggestion. We could stop printing out leading zeros for VMA and LMA to make it more concise. I.e. changing this line to

format("%*llx %*llx %*llx %5lld ", W, VA, W, LMA, W, Size, Align)

106

Please always be consistent. The word that pair up with "LMA" is "VMA".

175–177

Use right_justify.

[jhenderson]

Do we always want to show LMAs and VMAs? In some (possibly many) systems, the LMA will always match the VMA, so it seems like a lot of noise that doesn't benefit many consumers. Perhaps this could be put under an extra switch? Something like "--show-lma-in-map" (happy with a better name)?

[grimar]

In D44899#1050199, @jhenderson wrote:

Do we always want to show LMAs and VMAs? In some (possibly many) systems, the LMA will always match the VMA, so it seems like a lot of noise that doesn't benefit many consumers. Perhaps this could be put under an extra switch? Something like "--show-lma-in-map" (happy with a better name)?

I suggested a bit different thing in the description that might help to solve this:
"to hide LMA column if it is known there is no difference with VA column. Then VA could be renamed to VMA/LMA"

That might not be convenient for parsing sometimes probably since we would have a different amount of columns depending on inputs.
Not sure how much it is a problem though.

FWIW, Rui's suggestion to drop leading zeroes also looks fine for me, it should make map file more readable with both VMA/LMA I think.

[peter.smith]

With respect to parsing, at a recent conference one of the main requirements embedded developers had on ld.bfd was a machine readable (xml, json, etc.) map file. If ease of parsing is a concern, could we separate those concerns and have an alternative way to output the necessary information?

[jhenderson]

In D44899#1050202, @grimar wrote:

In D44899#1050199, @jhenderson wrote:

Do we always want to show LMAs and VMAs? In some (possibly many) systems, the LMA will always match the VMA, so it seems like a lot of noise that doesn't benefit many consumers. Perhaps this could be put under an extra switch? Something like "--show-lma-in-map" (happy with a better name)?

I suggested a bit different thing in the description that might help to solve this:
"to hide LMA column if it is known there is no difference with VA column. Then VA could be renamed to VMA/LMA"

That might not be convenient for parsing sometimes probably since we would have a different amount of columns depending on inputs.
Not sure how much it is a problem though.

I missed that comment, but this would work for me, although the switch might resolve the parsing issue better. I think in general terms, it is likely on people's systems that the VMA and LMA will either always be the same or always different, though I wouldn't want to guarantee it. The parsing issue is then only an issue if we have people sharing parsers between the two cases. I don't think it would be that hard to work-around though: take a typical regex parser for example, and just have an optional catching group for the extra column. Then use the number of captured groups to determine whether LMA was emitted or not.

FWIW, Rui's suggestion to drop leading zeroes also looks fine for me, it should make map file more readable with both VMA/LMA I think.

No problem with dropping leading zeroes, but I don't think that's really solving my issue. Less is more as they say (at least when the bit missing is useless info), and the LMA values are often redundant.

[jhenderson]

In D44899#1050204, @peter.smith wrote:

With respect to parsing, at a recent conference one of the main requirements embedded developers had on ld.bfd was a machine readable (xml, json, etc.) map file. If ease of parsing is a concern, could we separate those concerns and have an alternative way to output the necessary information?

FWIW, parsing the map file is not restricted to just embedded developers - we have certainly had customers who wanted to parse the map file.

[grimar]

• Addressed Rui's comments.
• Simplified implementation a bit.

[grimar]

• Fixed path in the test.

[grimar]

One more suggestion: in case if VMA and LMA are the same, we could print - or another placeholder instead of LMA value. Will it help?

[ruiu]

I don't think we should emit LMA only when LMA is different from VMA. Consistent output format is not only better for tools that parses map file output, but also less confusing for people. I also don't think that we should display LMA as "-" when it's the same as VMA. That's I think just hard to interpret even for humans.

So I'm fine with this format.

[ruiu]

ELF/MapFile.cpp

50

Can you change this to

"%*llx %9llx %*llx %5lld "

? I think size 16^9 should be enough for any section.

[grimar]

• Addressed review comments.

ELF/MapFile.cpp

50

64Gb? Maybe. It's not 640kb at least.

I thought about dynamic column's width though.
I prepared a patch for that: D45018.

[ruiu]

ELF/MapFile.cpp

50

You are misunderstanding that %9llx clips numbers to 9 columns. That won't happen. It just says that the default width is 9.

If something is larger than that, the following fields are not vertically aligned, but that's not a big deal.

[grimar]

ELF/MapFile.cpp

50

Oh. OK then.

[ruiu]

LGTM

ELF/MapFile.cpp

 using namespace lld::elf;
 
 typedef DenseMap<const SectionBase *, SmallVector<Symbol *, 4>> SymbolMapTy;
 
 static const std::string Indent8 = "        ";          // 8 spaces
 static const std::string Indent16 = "                "; // 16 spaces
 
 // Print out the first three columns of a line.
-static void writeHeader(raw_ostream &OS, uint64_t Addr, uint64_t Size,
-                        uint64_t Align) {
+static void writeHeader(raw_ostream &OS, uint64_t VMA, uint64_t LMA,
+                        uint64_t Size, uint64_t Align) {
   int W = Config->Is64 ? 16 : 8;
-  OS << format("%0*llx %0*llx %5lld ", W, Addr, W, Size, Align);
+  OS << format("%*llx %*llx %*llx %5lld ", W, VMA, W, LMA, W, Size, Align);
 }
 
 // Returns a list of all symbols that we want to print out.
 static std::vector<Symbol *> getSymbols() {
   std::vector<Symbol *> V;
   for (InputFile *File : ObjectFiles) {
     for (Symbol *B : File->getSymbols()) {
       if (auto *SS = dyn_cast<SharedSymbol>(B))

 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
 getSymbolStrings(ArrayRef<Symbol *> Syms) {
   std::vector<std::string> Str(Syms.size());
   parallelForEachN(0, Syms.size(), [&](size_t I) {
     raw_string_ostream OS(Str[I]);
-    writeHeader(OS, Syms[I]->getVA(), Syms[I]->getSize(), 0);
+    OutputSection *OSec = Syms[I]->getOutputSection();
+    uint64_t VMA = Syms[I]->getVA();
+    uint64_t LMA = OSec ? OSec->getLMA() + VMA - OSec->getVA(0) : 0;
+    writeHeader(OS, VMA, LMA, Syms[I]->getSize(), 0);
     OS << Indent16 << toString(*Syms[I]);
   });
 
   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;
 }
static void printEhFrame(raw_ostream &OS, OutputSection *OSec) {
   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);
+    writeHeader(OS, OSec->Addr + P.OutputOff, OSec->getLMA() + 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) {
     error("cannot open " + Config->MapFile + ": " + EC.message());
     return;
   }
 
   // Collect symbol info that we want to print out.
   std::vector<Symbol *> Syms = getSymbols();
   SymbolMapTy SectionSyms = getSectionSyms(Syms);
   DenseMap<Symbol *, std::string> SymStr = getSymbolStrings(Syms);
 
   // Print out the header line.
   int W = Config->Is64 ? 16 : 8;
-  OS << left_justify("Address", W) << ' ' << left_justify("Size", W)
-     << " Align Out     In      Symbol\n";
+  OS << right_justify("VMA", W) << ' ' << right_justify("LMA", W) << ' '
+     << right_justify("Size", W) << " Align Out     In      Symbol\n";
 
   // Print out file contents.
   for (OutputSection *OSec : OutputSections) {
-    writeHeader(OS, OSec->Addr, OSec->Size, OSec->Alignment);
+    writeHeader(OS, OSec->Addr, OSec->getLMA(), OSec->Size, OSec->Alignment);
     OS << OSec->Name << '\n';
 
     // Dump symbols for each input section.
     for (BaseCommand *Base : OSec->SectionCommands) {
       if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
         for (InputSection *IS : ISD->Sections) {
           if (IS == InX::EhFrame) {
             printEhFrame(OS, OSec);
             continue;
           }
 
-          writeHeader(OS, IS->getVA(0), IS->getSize(), IS->Alignment);
+          writeHeader(OS, IS->getVA(0), OSec->getLMA() + IS->getOffset(0),
+                      IS->getSize(), IS->Alignment);
           OS << Indent8 << toString(IS) << '\n';
           for (Symbol *Sym : SectionSyms[IS])
             OS << SymStr[Sym] << '\n';
         }
         continue;
       }
 
       if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
-        writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, 1);
+        writeHeader(OS, OSec->Addr + Cmd->Offset, OSec->getLMA() + Cmd->Offset,
+                    Cmd->Size, 1);
         OS << Indent8 << Cmd->CommandString << '\n';
         continue;
       }
 
       if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
-        writeHeader(OS, OSec->Addr + Cmd->Offset, Cmd->Size, 1);
+        writeHeader(OS, OSec->Addr + Cmd->Offset, OSec->getLMA() + Cmd->Offset,
+                    Cmd->Size, 1);
         OS << Indent8 << Cmd->CommandString << '\n';
         continue;
       }
     }
   }
 }
 
 static void print(StringRef A, StringRef B) {

test/ELF/linkerscript/Inputs/map-file2.s

+.global _start
+_start:
+.global _Z1fi
+_Z1fi:
+.cfi_startproc
+nop
+.cfi_endproc
+
+.section .aaa, "a";
+.quad 1;
+
+.section .bbb, "a";
+.quad 2;
+
+.section .ccc, "a";
+.quad 3;
+
+.section .ddd, "a";
+.quad 4

test/ELF/linkerscript/map-file.test

.foo : {
     *(.foo.1)
     . += 0x123 *
          (1 + 1);
     foo = .;
     bar = 0x42 - 0x26;
   }
 }
 
-# CHECK:      Address          Size             Align Out     In      Symbol
-# CHECK-NEXT: 0000000000001000 000000000000125d     1 .foo
-# CHECK-NEXT: 0000000000001000 0000000000000001     1         BYTE ( 0x11 )
-# CHECK-NEXT: 0000000000001001 0000000000000002     1         SHORT ( 0x1122 )
-# CHECK-NEXT: 0000000000001003 0000000000000004     1         LONG ( 0x11223344 )
-# CHECK-NEXT: 0000000000001007 0000000000000008     1         QUAD ( 0x1122334455667788 )
-# CHECK-NEXT: 000000000000100f 0000000000001000     1         . += 0x1000
-# CHECK-NEXT: 000000000000200f 0000000000000008     1         {{.*}}{{/|\\}}map-file.test.tmp.o:(.foo.1)
-# CHECK-NEXT: 0000000000002017 0000000000000246     1         . += 0x123 * ( 1 + 1 )
-# CHECK-NEXT: 000000000000225d 0000000000000000     1         foo = .
-# CHECK-NEXT: 000000000000225d 0000000000000000     1         bar = 0x42 - 0x26
-# CHECK-NEXT: 0000000000002260 0000000000000000     4 .text
-# CHECK-NEXT: 0000000000002260 0000000000000000     4         {{.*}}{{/|\\}}map-file.test.tmp.o:(.text)
+# CHECK:        VMA              LMA             Size Align Out     In      Symbol
+# CHECK-NEXT:  1000             1000             125d     1 .foo
+# CHECK-NEXT:  1000             1000                1     1         BYTE ( 0x11 )
+# CHECK-NEXT:  1001             1001                2     1         SHORT ( 0x1122 )
+# CHECK-NEXT:  1003             1003                4     1         LONG ( 0x11223344 )
+# CHECK-NEXT:  1007             1007                8     1         QUAD ( 0x1122334455667788 )
+# CHECK-NEXT:  100f             100f             1000     1         . += 0x1000
+# CHECK-NEXT:  200f             200f                8     1         {{.*}}{{/|\\}}map-file.test.tmp.o:(.foo.1)
+# CHECK-NEXT:  2017             2017              246     1         . += 0x123 * ( 1 + 1 )
+# CHECK-NEXT:  225d             225d                0     1         foo = .
+# CHECK-NEXT:  225d             225d                0     1         bar = 0x42 - 0x26
+# CHECK-NEXT:  2260             2260                0     4 .text
+# CHECK-NEXT:  2260             2260                0     4         {{.*}}{{/|\\}}map-file.test.tmp.o:(.text)
+# CHECK-NEXT:     0                0                8     1 .comment
+# CHECK-NEXT:     0                0                8     1         <internal>:(.comment)
+# CHECK-NEXT:     0                0               48     8 .symtab
+# CHECK-NEXT:     0                0               48     8         <internal>:(.symtab)
+# CHECK-NEXT:     0                0               2f     1 .shstrtab
+# CHECK-NEXT:     0                0               2f     1         <internal>:(.shstrtab)
+# CHECK-NEXT:     0                0                9     1 .strtab
+# CHECK-NEXT:     0                0                9     1         <internal>:(.strtab)

test/ELF/linkerscript/map-file2.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/map-file2.s -o %t.o
+# RUN: ld.lld -o %t %t.o -Map=%t.map --script %s
+# RUN: FileCheck -strict-whitespace %s < %t.map
+
+SECTIONS {
+  . = 0x1000;
+  .aaa : { *(.aaa.*) }
+  .bbb : AT(0x2000) { *(.bbb.*) }
+  .ccc : AT(0x3000) { *(.ccc.*) }
+  .ddd : {
+    BYTE(0x11)
+    . += 0x100;
+    *(.ddd.*)
+  }
+  .text : { *(.text.*) }
+}
+
+# CHECK:             VMA              LMA             Size Align Out     In      Symbol
+# CHECK-NEXT:       1000             1000                8     1 .aaa
+# CHECK-NEXT:       1000             1000                8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.aaa)
+# CHECK-NEXT:       1008             2000                8     1 .bbb
+# CHECK-NEXT:       1008             2000                8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.bbb)
+# CHECK-NEXT:       1010             3000                8     1 .ccc
+# CHECK-NEXT:       1010             3000                8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.ccc)
+# CHECK-NEXT:       1018             3008              109     1 .ddd
+# CHECK-NEXT:       1018             3008                1     1         BYTE ( 0x11 )
+# CHECK-NEXT:       1019             3009              100     1         . += 0x100
+# CHECK-NEXT:       1119             3109                8     1         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.ddd)
+# CHECK-NEXT:       1124             3114                1     4 .text
+# CHECK-NEXT:       1124             3114                1     4         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.text)
+# CHECK-NEXT:       1124             3114                0     0                 f(int)
+# CHECK-NEXT:       1124             3114                0     0                 _start
+# CHECK-NEXT:       1128             3118               30     8 .eh_frame
+# CHECK-NEXT:       1128             3118               30     0         {{.*}}{{/|\\}}map-file2.test.tmp.o:(.eh_frame+0x0)
+# CHECK-NEXT:          0                0                8     1 .comment
+# CHECK-NEXT:          0                0                8     1         <internal>:(.comment)
+# CHECK-NEXT:          0                0               48     8 .symtab
+# CHECK-NEXT:          0                0               48     8         <internal>:(.symtab)
+# CHECK-NEXT:          0                0               48     1 .shstrtab
+# CHECK-NEXT:          0                0               48     1         <internal>:(.shstrtab)
+# CHECK-NEXT:          0                0                e     1 .strtab
+# CHECK-NEXT:          0                0                e     1         <internal>:(.strtab)

test/ELF/map-file.s

 .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 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
-// CHECK-NEXT: 000000000020102a 0000000000000000     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
-// CHECK-NEXT: 000000000020102a 0000000000000000     0                 zed
-// CHECK-NEXT: 000000000020102c 0000000000000000     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
-// CHECK-NEXT: 000000000020102c 0000000000000000     0                 bah
-// CHECK-NEXT: 000000000020102c 0000000000000001     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
-// CHECK-NEXT: 000000000020102c 0000000000000000     0                 baz
-// CHECK-NEXT: 0000000000201030 0000000000000030    16 .plt
-// CHECK-NEXT: 0000000000201030 0000000000000030    16         <internal>:(.plt)
-// CHECK-NEXT: 0000000000201040 0000000000000000     0                 sharedFunc1
-// CHECK-NEXT: 0000000000201050 0000000000000000     0                 sharedFunc2
-// CHECK-NEXT: 0000000000202000 0000000000000028     8 .got.plt
-// CHECK-NEXT: 0000000000202000 0000000000000028     8         <internal>:(.got.plt)
-// CHECK-NEXT: 0000000000203000 0000000000000100     8 .dynamic
-// CHECK-NEXT: 0000000000203000 0000000000000100     8         <internal>:(.dynamic)
-// CHECK-NEXT: 0000000000204000 0000000000000010    16 .bss
-// CHECK-NEXT: 0000000000204000 0000000000000004    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
-// CHECK-NEXT: 0000000000204000 0000000000000004     0                 common
-// CHECK-NEXT: 0000000000204004 0000000000000004     1         <internal>:(.bss)
-// CHECK-NEXT: 0000000000204004 0000000000000004     0                 sharedFoo
-// CHECK-NEXT: 0000000000204008 0000000000000008     1         <internal>:(.bss)
-// CHECK-NEXT: 0000000000204008 0000000000000008     0                 sharedBar
-// CHECK-NEXT: 0000000000000000 0000000000000008     1 .comment
-// CHECK-NEXT: 0000000000000000 0000000000000008     1         <internal>:(.comment)
-// CHECK-NEXT: 0000000000000000 0000000000000198     8 .symtab
-// CHECK-NEXT: 0000000000000000 0000000000000198     8         <internal>:(.symtab)
-// CHECK-NEXT: 0000000000000000 0000000000000084     1 .shstrtab
-// CHECK-NEXT: 0000000000000000 0000000000000084     1         <internal>:(.shstrtab)
-// CHECK-NEXT: 0000000000000000 000000000000006d     1 .strtab
-// CHECK-NEXT: 0000000000000000 000000000000006d     1         <internal>:(.strtab)
+// CHECK:         VMA              LMA             Size Align Out     In      Symbol
+// CHECK-NEXT: 2001c8           2001c8               78     8 .dynsym
+// CHECK-NEXT: 2001c8           2001c8               78     8         <internal>:(.dynsym)
+// CHECK-NEXT: 200240           200240               2c     8 .gnu.hash
+// CHECK-NEXT: 200240           200240               2c     8         <internal>:(.gnu.hash)
+// CHECK-NEXT: 20026c           20026c               30     4 .hash
+// CHECK-NEXT: 20026c           20026c               30     4         <internal>:(.hash)
+// CHECK-NEXT: 20029c           20029c               31     1 .dynstr
+// CHECK-NEXT: 20029c           20029c               31     1         <internal>:(.dynstr)
+// CHECK-NEXT: 2002d0           2002d0               30     8 .rela.dyn
+// CHECK-NEXT: 2002d0           2002d0               30     8         <internal>:(.rela.dyn)
+// CHECK-NEXT: 200300           200300               30     8 .rela.plt
+// CHECK-NEXT: 200300           200300               30     8         <internal>:(.rela.plt)
+// CHECK-NEXT: 200330           200330               60     8 .eh_frame
+// CHECK-NEXT: 200330           200330               2c     0         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
+// CHECK-NEXT: 200360           200360               14     0         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
+// CHECK-NEXT: 200378           200378               18     0         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
+// CHECK-NEXT: 201000           201000               2d     4 .text
+// CHECK-NEXT: 201000           201000               28     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
+// CHECK-NEXT: 201000           201000                0     0                 _start
+// CHECK-NEXT: 20101f           20101f                0     0                 f(int)
+// CHECK-NEXT: 201028           201028                0     0                 local
+// CHECK-NEXT: 201028           201028                2     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
+// CHECK-NEXT: 201028           201028                0     0                 foo
+// CHECK-NEXT: 201029           201029                0     0                 bar
+// CHECK-NEXT: 20102a           20102a                0     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
+// CHECK-NEXT: 20102a           20102a                0     0                 zed
+// CHECK-NEXT: 20102c           20102c                0     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
+// CHECK-NEXT: 20102c           20102c                0     0                 bah
+// CHECK-NEXT: 20102c           20102c                1     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
+// CHECK-NEXT: 20102c           20102c                0     0                 baz
+// CHECK-NEXT: 201030           201030               30    16 .plt
+// CHECK-NEXT: 201030           201030               30    16         <internal>:(.plt)
+// CHECK-NEXT: 201040                0                0     0                 sharedFunc1
+// CHECK-NEXT: 201050                0                0     0                 sharedFunc2
+// CHECK-NEXT: 202000           202000               28     8 .got.plt
+// CHECK-NEXT: 202000           202000               28     8         <internal>:(.got.plt)
+// CHECK-NEXT: 203000           203000              100     8 .dynamic
+// CHECK-NEXT: 203000           203000              100     8         <internal>:(.dynamic)
+// CHECK-NEXT: 204000           204000               10    16 .bss
+// CHECK-NEXT: 204000           204000                4    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
+// CHECK-NEXT: 204000           204000                4     0                 common
+// CHECK-NEXT: 204004           204004                4     1         <internal>:(.bss)
+// CHECK-NEXT: 204004           204004                4     0                 sharedFoo
+// CHECK-NEXT: 204008           204008                8     1         <internal>:(.bss)
+// CHECK-NEXT: 204008           204008                8     0                 sharedBar
+// CHECK-NEXT:      0                0                8     1 .comment
+// CHECK-NEXT:      0                0                8     1         <internal>:(.comment)
+// CHECK-NEXT:      0                0              198     8 .symtab
+// CHECK-NEXT:      0                0              198     8         <internal>:(.symtab)
+// CHECK-NEXT:      0                0               84     1 .shstrtab
+// CHECK-NEXT:      0                0               84     1         <internal>:(.shstrtab)
+// CHECK-NEXT:      0                0               6d     1 .strtab
+// CHECK-NEXT:      0                0               6d     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 /