[llvm-nm] Print EC symbol map.

[jacek]

Summary

This is useful for examining ARM64EC static libraries and allows better llvm-lib testing. Changes to Archive class will also be useful for LLD to support ARM64EC, where it will need to use one map or the other, depending on linking target (or both, in case of ARM64X, but separately as they are in different namespaces).

[efriedma]

This code seems like it isn't being careful to ensure calls to read16le/read32le/etc. don't read past the end of a buffer. Maybe it makes sense to add some sort of bounds-checked read helper? Maybe could leave it for a followup, though, if it's confusing to mix it in with this patch.

llvm/lib/Object/Archive.cpp

951

This could use a comment explaining what it's doing... I assume it's looking for the EC symbol table, but it's not obvious how the member ordering here works.

1007

The math with the symbol indexes all over is confusing... maybe consider adding a helper to check "does this symbol index refer to an EC symbol"?

1116

What happens if find() fails?

[jhenderson]

What are "ECSymbols"? Is there a spec I can read for them, so that I can review this change?

[jacek]

In D146534#4212353, @jhenderson wrote:

What are "ECSymbols"?

Those are "emulation compatible" symbols used for ARM64EC support:
https://learn.microsoft.com/en-us/cpp/build/arm64ec-windows-abi-conventions?view=msvc-170
ARM64EC allows linking a special ARM64 object files together with x86_64 object files. It's also possible to build ARM64X binaries containing both pure ARM64 and ARM64EC code, in which case both have separated namespaces and, depending on process loading the module, only one variant is used in runtime.

For static libraries, it's allowed to have both ARM64 and ARM64EC in a single library. Since they need separated namespaces, they can't share symbol map. ARM64EC uses <ECSYMBOLS> instead of the usual map.

Is there a spec I can read for them, so that I can review this change?

No, there is no scpec that I'm aware of. I figured the format by inspecting libraries produced by MSVC lib.exe. I will add more comments to the code, but the format is very similar to usual COFF symbol map:

• 32-bit LE number of symbols
• followed by an array of 16-bit member index for each symbol. This is an index in offset table from the regular COFF symbol table (it there is no separated offset table)
• followed by null-terminated strings names for each symbol in the same order as indexes above

See also writeECSymbols from https://reviews.llvm.org/D143541

[jacek]

Thanks for review. The new version adds more comments, validates EC symbol map and introduces isECSymbol helper.

[jacek]

In D146534#4210803, @efriedma wrote:

This code seems like it isn't being careful to ensure calls to read16le/read32le/etc. don't read past the end of a buffer. Maybe it makes sense to add some sort of bounds-checked read helper? Maybe could leave it for a followup, though, if it's confusing to mix it in with this patch.

I originally followed how current code does, which just assumes that symbol table is valid. The problem with bounds-checked helper is that we don't really have a good way of propagating errors from things like iterators. In the new version, I added an early validation of EC symbols map so that if it's present, we know that all those reads are safe. I wasn't sure what to do when the map is invalid. We could treat it as an error in Archive constructor, but I decided to just ignore the map instead assuming that the archive may still be useful.

[efriedma]

llvm/lib/Object/Archive.cpp

986

StringRef::find() returns npos (i.e. -1) on failure, so I don't think this does what you want.

[jacek]

I misinterpreted docs, sorry. Fixed in the new version.

[efriedma]

LGTM

[efriedma]

I wasn't sure what to do when the map is invalid. We could treat it as an error in Archive constructor, but I decided to just ignore the map instead assuming that the archive may still be useful.

Actually, hmm... maybe we should reject in this case. I mean, the archive might be "useful" in the sense that it contains interesting object files someone might want to use, but what's the linker supposed to do if symbol map is malformed? If we eat the error, it'll just assume there just aren't any symbols, so it'll produce weird link errors or an invalid executable.

[jacek]

In D146534#4217452, @efriedma wrote:

I wasn't sure what to do when the map is invalid. We could treat it as an error in Archive constructor, but I decided to just ignore the map instead assuming that the archive may still be useful.

Actually, hmm... maybe we should reject in this case. I mean, the archive might be "useful" in the sense that it contains interesting object files someone might want to use, but what's the linker supposed to do if symbol map is malformed? If we eat the error, it'll just assume there just aren't any symbols, so it'll produce weird link errors or an invalid executable.

My thinking was that things like llvm-lib -extract or merging with llvm-lib (which would generate a new map) could still work. Linker could do whole archive import and build pure ARM64 binaries (although I guess we should also have validation for regular map, which has similar consequences). I think we could move validation to ec_symbols() so that callers that need it may handle error.

[jacek]

New version with fallible ec_symbols(), fixed member index check (it's 1-based) and a test for malformed EC symbols.

[efriedma]

There's only one tool in existence that produces archives with an ecsymbols section; with your patch to llvm, there will be two. Corrupted sections aren't actually a thing anyone is likely to run into, outside of random data corruption. Certainly not as part of a normal build process.

But I guess delaying the error check until we actually try to query the table doesn't really do any harm. Sure, this is fine.

[jhenderson]

Looks to me like you should have test cases for your EC Map validation.

llvm/lib/Object/Archive.cpp

952–955

1193

The LLVM coding standards state you should give additional context in error messages that would help diagnose the issue better (see https://llvm.org/docs/CodingStandards.html#error-and-warning-messages) In this case, you could say "invalid EC symbol table size (<ECSymTable.size()>)".

1197

As above, more context could be included, e.g. "invalid EC symbols size. Size was <ECSymbolTable.size()>, but expected <sizeof(uint32_t) + Count * sizeof(uint16_t))>" (obviously expanding the bits in "<>").

1201

If you moved this variable definition before the previous error check, you'd be able to reuse it in that error check, rather than duplicating the calculation.

1206

As above, include the index and member count in the message for additional context.

1209

Perhaps: "malformed EC symbol names: not null-terminated" to clarify to the user why it appears malformed? Also, note "symbols" -> "symbol" regardless of the additional context.

[jacek]

Thanks! The new version adds more context to error messages and more validation tests.

[jhenderson]

llvm/lib/Object/Archive.cpp

952–955

Looks like this comment was ignored?

[jacek]

llvm/lib/Object/Archive.cpp

952–955

Sorry about that (I looked mostly at mail form of the comment, in which it looked like a context). I will prepare a new version.

[jacek]

Fixed comment.

[jhenderson]

LGTM. FWIW, you didn't need to post a review for this sort of minor fix.

[TWeaver]

Hello and good afternoon from the UK,

I believe this is 2 of 3 patches that may have caused the following build bot to begin failing, are you able to take a look?

https://lab.llvm.org/buildbot/#/builders/216/builds/20269

Warm regards,
Tom W

[thurston]

It's also causing an error on the MemorySanitizer build (https://lab.llvm.org/buildbot/#/builders/74/builds/18749/steps/14/logs/stdio), which shows the uninitialized memory usage.

[jacek]

I think I can see what's happening. Child::StartOfFile is unintialized in this case, but it should be harmless because it's not actually used (I think the same would happen without the patch when listing an empty archive). I will submit a fix after a bit more testing.

[jacek]

I created https://reviews.llvm.org/D148955

llvm/include/llvm/Object/Archive.h

public:
 
     bool operator==(const Symbol &other) const {
       return (Parent == other.Parent) && (SymbolIndex == other.SymbolIndex);
     }
 
     StringRef getName() const;
     Expected<Child> getMember() const;
     Symbol getNext() const;
+    bool isECSymbol() const;
   };
 
   class symbol_iterator {
     Symbol symbol;
 
   public:
     symbol_iterator(const Symbol &s) : symbol(s) {}
 
public:
   }
 
   symbol_iterator symbol_begin() const;
   symbol_iterator symbol_end() const;
   iterator_range<symbol_iterator> symbols() const {
     return make_range(symbol_begin(), symbol_end());
   }
 
+  Expected<iterator_range<symbol_iterator>> ec_symbols() const;
+
   static bool classof(Binary const *v) { return v->isArchive(); }
 
   // check if a symbol is in the archive
   Expected<std::optional<Child>> findSym(StringRef name) const;
 
   virtual bool isEmpty() const;
   bool hasSymbolTable() const;
   StringRef getSymbolTable() const { return SymbolTable; }
   StringRef getStringTable() const { return StringTable; }
   uint32_t getNumberOfSymbols() const;
+  uint32_t getNumberOfECSymbols() const;
   virtual uint64_t getFirstChildOffset() const { return getArchiveMagicLen(); }
 
   std::vector<std::unique_ptr<MemoryBuffer>> takeThinBuffers() {
     return std::move(ThinBuffers);
   }
 
   std::unique_ptr<AbstractArchiveMemberHeader>
   createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size,
                             Error *Err) const;
 
 protected:
   uint64_t getArchiveMagicLen() const;
   void setFirstRegular(const Child &C);
 
   StringRef SymbolTable;
+  StringRef ECSymbolTable;
   StringRef StringTable;
 
 private:
   StringRef FirstRegularData;
   uint16_t FirstRegularStartOfFile = -1;
 
   unsigned Format : 3;
   unsigned IsThin : 1;

llvm/lib/Object/Archive.cpp

if (Name == "//") {
     Expected<StringRef> BufOrErr = C->getBuffer();
     if (!BufOrErr) {
       Err = BufOrErr.takeError();
       return;
     }
     StringTable = BufOrErr.get();
     if (Increment())
       return;
+
+    if (I == E) {
+      setFirstRegular(*C);
+      Err = Error::success();
+      return;
+    }
+
+    NameOrErr = C->getRawName();
+    if (!NameOrErr) {
+      Err = NameOrErr.takeError();
+      return;
+    }
+    Name = NameOrErr.get();
+  }
+
+  if (Name == "/<ECSYMBOLS>/") {
+    // ARM64EC-aware libraries contain an additional special member with
+    // an EC symbol map after the string table. Its format is similar to a
+    // regular symbol map, except it doesn't contain member offsets. Its indexes
+    // refer to member offsets from the regular symbol table instead.
+    Expected<StringRef> BufOrErr = C->getBuffer();
+    if (!BufOrErr) {
+      Err = BufOrErr.takeError();
+      return;
+    }
+    ECSymbolTable = BufOrErr.get();
+    if (Increment())
+      return;
   }
 
   setFirstRegular(*C);
   Err = Error::success();
 }
 
 object::Archive::Kind Archive::getDefaultKindForHost() {
   Triple HostTriple(sys::getProcessTriple());
   return HostTriple.isOSDarwin()
              ? object::Archive::K_DARWIN
              : (HostTriple.isOSAIX() ? object::Archive::K_AIXBIG
                                      : object::Archive::K_GNU);
 }
 
 Archive::child_iterator Archive::child_begin(Error &Err,
                                              bool SkipInternal) const {
   if (isEmpty())
     return child_end();
 
   if (SkipInternal)
     return child_iterator::itr(
         Child(this, FirstRegularData, FirstRegularStartOfFile), Err);
 
   const char *Loc = Data.getBufferStart() + getFirstChildOffset();
   Child C(this, Loc, &Err);
   if (Err)
     return child_end();
   return child_iterator::itr(C, Err);
 }
 
 Archive::child_iterator Archive::child_end() const {
   return child_iterator::end(Child(nullptr, nullptr, nullptr));
 }
 
+bool Archive::Symbol::isECSymbol() const {
+  // Symbols use SymbolCount..SymbolCount+getNumberOfECSymbols() for EC symbol
+  // indexes.
+  uint32_t SymbolCount = Parent->getNumberOfSymbols();
+  return SymbolCount <= SymbolIndex &&
+         SymbolIndex < SymbolCount + Parent->getNumberOfECSymbols();
+}
+
 StringRef Archive::Symbol::getName() const {
+  if (isECSymbol())
+    return Parent->ECSymbolTable.begin() + StringIndex;
   return Parent->getSymbolTable().begin() + StringIndex;
 }
 
 Expected<Archive::Child> Archive::Symbol::getMember() const {
   const char *Buf = Parent->getSymbolTable().begin();
   const char *Offsets = Buf;
   if (Parent->kind() == K_GNU64 || Parent->kind() == K_DARWIN64 ||
       Parent->kind() == K_AIXBIG)
if (Parent->kind() == K_GNU) {
     // is needed here.
     Offset = read64le(Offsets + SymbolIndex * 16 + 8);
   } else {
     // Skip offsets.
     uint32_t MemberCount = read32le(Buf);
     Buf += MemberCount * 4 + 4;
 
     uint32_t SymbolCount = read32le(Buf);
-    if (SymbolIndex >= SymbolCount)
-      return errorCodeToError(object_error::parse_failed);
-
+    uint16_t OffsetIndex;
+    if (SymbolIndex < SymbolCount) {
       // Skip SymbolCount to get to the indices table.
       const char *Indices = Buf + 4;
 
       // Get the index of the offset in the file member offset table for this
       // symbol.
-    uint16_t OffsetIndex = read16le(Indices + SymbolIndex * 2);
+      OffsetIndex = read16le(Indices + SymbolIndex * 2);
+    } else if (isECSymbol()) {
+      // Skip SymbolCount to get to the indices table.
+      const char *Indices = Parent->ECSymbolTable.begin() + 4;
+
+      // Get the index of the offset in the file member offset table for this
+      // symbol.
+      OffsetIndex = read16le(Indices + (SymbolIndex - SymbolCount) * 2);
+    } else {
+      return errorCodeToError(object_error::parse_failed);
+    }
     // Subtract 1 since OffsetIndex is 1 based.
     --OffsetIndex;
 
     if (OffsetIndex >= MemberCount)
       return errorCodeToError(object_error::parse_failed);
 
     Offset = read32le(Offsets + OffsetIndex * 4);
   }
if (t.SymbolIndex + 1 < RanlibCount) {
       const char *Ranlibs = Buf + 4;
       uint32_t CurRanStrx = 0;
       uint32_t NextRanStrx = 0;
       CurRanStrx = read32le(Ranlibs + t.SymbolIndex * 8);
       NextRanStrx = read32le(Ranlibs + (t.SymbolIndex + 1) * 8);
       t.StringIndex -= CurRanStrx;
       t.StringIndex += NextRanStrx;
     }
+  } else if (t.isECSymbol()) {
+    // Go to one past next null.
+    t.StringIndex = Parent->ECSymbolTable.find('\0', t.StringIndex) + 1;
   } else {
     // Go to one past next null.
     t.StringIndex = Parent->getSymbolTable().find('\0', t.StringIndex) + 1;
   }
   ++t.SymbolIndex;
   return t;
 }
 
 Archive::symbol_iterator Archive::symbol_begin() const {
Archive::symbol_iterator Archive::symbol_begin() const {
   uint32_t string_start_offset = buf - getSymbolTable().begin();
   return symbol_iterator(Symbol(this, 0, string_start_offset));
 }
 
 Archive::symbol_iterator Archive::symbol_end() const {
   return symbol_iterator(Symbol(this, getNumberOfSymbols(), 0));
 }
 
+Expected<iterator_range<Archive::symbol_iterator>> Archive::ec_symbols() const {
+  uint32_t Count = 0;
+
+  // Validate EC symbol table.
+  if (!ECSymbolTable.empty()) {
+    if (ECSymbolTable.size() < sizeof(uint32_t))
+      return malformedError("invalid EC symbols size (" +
+                            Twine(ECSymbolTable.size()) + ")");
+    if (SymbolTable.size() < sizeof(uint32_t))
+      return malformedError("invalid symbols size (" +
+                            Twine(ECSymbolTable.size()) + ")");
+
+    Count = read32le(ECSymbolTable.begin());
+    size_t StringIndex = sizeof(uint32_t) + Count * sizeof(uint16_t);
+    if (ECSymbolTable.size() < StringIndex)
+      return malformedError("invalid EC symbols size. Size was " +
+                            Twine(ECSymbolTable.size()) + ", but expected " +
+                            Twine(StringIndex));
+
+    uint32_t MemberCount = read32le(SymbolTable.begin());
+    const char *Indexes = ECSymbolTable.begin() + sizeof(uint32_t);
+
+    for (uint32_t i = 0; i < Count; ++i) {
+      uint16_t Index = read16le(Indexes + i * sizeof(uint16_t));
+      if (!Index)
+        return malformedError("invalid EC symbol index 0");
+      if (Index > MemberCount)
+        return malformedError("invalid EC symbol index " + Twine(Index) +
+                              " is larger than member count " +
+                              Twine(MemberCount));
+
+      StringIndex = ECSymbolTable.find('\0', StringIndex);
+      if (StringIndex == StringRef::npos)
+        return malformedError("malformed EC symbol names: not null-terminated");
+      ++StringIndex;
+    }
+  }
+
+  uint32_t SymbolCount = getNumberOfSymbols();
+  return make_range(
+      symbol_iterator(Symbol(this, SymbolCount,
+                             sizeof(uint32_t) + Count * sizeof(uint16_t))),
+      symbol_iterator(Symbol(this, SymbolCount + Count, 0)));
+}
+
 uint32_t Archive::getNumberOfSymbols() const {
   if (!hasSymbolTable())
     return 0;
   const char *buf = getSymbolTable().begin();
   if (kind() == K_GNU)
     return read32be(buf);
   if (kind() == K_GNU64 || kind() == K_AIXBIG)
     return read64be(buf);
   if (kind() == K_BSD)
     return read32le(buf) / 8;
   if (kind() == K_DARWIN64)
     return read64le(buf) / 16;
   uint32_t member_count = 0;
   member_count = read32le(buf);
   buf += 4 + (member_count * 4); // Skip offsets.
   return read32le(buf);
 }
 
+uint32_t Archive::getNumberOfECSymbols() const {
+  if (ECSymbolTable.size() < sizeof(uint32_t))
+    return 0;
+  return read32le(ECSymbolTable.begin());
+}
+
 Expected<std::optional<Archive::Child>> Archive::findSym(StringRef name) const {
   Archive::symbol_iterator bs = symbol_begin();
   Archive::symbol_iterator es = symbol_end();
 
   for (; bs != es; ++bs) {
     StringRef SymName = bs->getName();
     if (SymName == name) {
       if (auto MemberOrErr = bs->getMember())

llvm/test/tools/llvm-lib/ecsymbols.test

-# Check that llvm-lib can list the members of an archive which contains the
+# Check that llvm-lib doesn't list the members of an archive which contains the
 # special member /<ECSYMBOLS>/.
 
 # RUN: yaml2obj %s -o %t.lib
-# RUN: llvm-lib /list %t.lib | FileCheck %s
-
-# CHECK: /<ECSYMBOLS>/
+# RUN: llvm-lib /list %t.lib | FileCheck --check-prefix=NOEC --allow-empty %s
+# NOEC-NOT: ECSYMBOLS
 
 --- !Arch
 Members:
   - Name:            '/'
     Size:            '0'
   - Name:            '/'
     Size:            '0'
   - Name:            '/<ECSYMBOLS>/'
     Size:            '0'
 ...
 
 # Check that llvm-lib produces /<ECSYMBOLS>/ members for ARM64EC libraries.
 # RUN: rm -rf %t && mkdir -p %t && cd %t
 # RUN: llvm-mc -triple=arm64ec-pc-windows-msvc -filetype=obj -o arm64ec-foo.o %S/Inputs/a.s
 # RUN: llvm-mc -triple=aarch64-pc-windows-msvc -filetype=obj -o arm64-foo.o %S/Inputs/a.s
 # RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o x64-foo.o %S/Inputs/b.s
 # RUN: llvm-lib -machine:arm64ec -out:foo.lib arm64-foo.o arm64ec-foo.o x64-foo.o
 # RUN: grep -q '/<ECSYMBOLS>/' foo.lib
+
+# RUN: llvm-nm --print-armap foo.lib | FileCheck %s
+# CHECK: Archive map
+# CHECK-NEXT: a in arm64-foo.o
+# CHECK-EMPTY:
+# CHECK-NEXT: Archive EC map
+# CHECK-NEXT: a in arm64ec-foo.o
+# CHECK-NEXT: b in x64-foo.o
+# CHECK-EMPTY:

llvm/test/tools/llvm-nm/ecsymbols.test

+# Check that llvm-lib doesn't list the members of an archive which contains the
+# special member /<ECSYMBOLS>/.
+
+# RUN: yaml2obj --docnum=1 %s -o %t.lib
+# RUN: llvm-nm --print-armap %t.lib 2>&1 | FileCheck --check-prefix=NM1 %s
+# NM1: truncated or malformed archive (invalid EC symbols size (3))
+
+--- !Arch
+Members:
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/<ECSYMBOLS>/'
+    Size:            '3'
+    Content:         010203
+    PaddingByte:     0
+...
+
+# RUN: yaml2obj --docnum=2 %s -o %t.lib
+# RUN: llvm-nm --print-armap %t.lib 2>&1 | FileCheck --check-prefix=NM2 %s
+# NM2: truncated or malformed archive (invalid EC symbols size. Size was 7, but expected 8)
+
+--- !Arch
+Members:
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/'
+    Size:            '12'
+    Content:         010000001000000000000000
+  - Name:            '/<ECSYMBOLS>/'
+    Size:            '7'
+    Content:         02000000010001
+    PaddingByte:     0
+...
+
+# RUN: yaml2obj --docnum=3 %s -o %t.lib
+# RUN: llvm-nm --print-armap %t.lib 2>&1 | FileCheck --check-prefix=NM3 %s
+# NM3: truncated or malformed archive (invalid EC symbol index 2 is larger than member count 1)
+
+--- !Arch
+Members:
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/'
+    Size:            '12'
+    Content:         010000001000000000000000
+  - Name:            '/<ECSYMBOLS>/'
+    Size:            '8'
+    Content:         0100000002006100
+  - Name:            'a.obj'
+    Size:            '0'
+...
+
+
+# RUN: yaml2obj --docnum=4 %s -o %t.lib
+# RUN: llvm-nm --print-armap %t.lib 2>&1 | FileCheck --check-prefix=NM4 %s
+# NM4: truncated or malformed archive (invalid EC symbol index 0)
+
+--- !Arch
+Members:
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/'
+    Size:            '12'
+    Content:         010000001000000000000000
+  - Name:            '/<ECSYMBOLS>/'
+    Size:            '8'
+    Content:         0100000000006100
+  - Name:            'a.obj'
+    Size:            '0'
+...
+
+# RUN: yaml2obj --docnum=5 %s -o %t.lib
+# RUN: llvm-nm --print-armap %t.lib 2>&1 | FileCheck --check-prefix=NM5 %s
+# NM5: truncated or malformed archive (malformed EC symbol names: not null-terminated)
+
+--- !Arch
+Members:
+  - Name:            '/'
+    Size:            '0'
+  - Name:            '/'
+    Size:            '12'
+    Content:         010000001000000000000000
+  - Name:            '/<ECSYMBOLS>/'
+    Size:            '8'
+    Content:         0100000001006161
+  - Name:            'a.obj'
+    Size:            '0'
+...

llvm/tools/llvm-nm/llvm-nm.cpp

static bool checkMachOAndArchFlags(SymbolicFile *O, StringRef Filename) {
   const std::string ArchFlagName(ArchFlag);
   if (!llvm::is_contained(ArchFlags, ArchFlagName)) {
     error("No architecture specified", Filename);
     return false;
   }
   return true;
 }
 
-static void dumpArchiveMap(Archive *A, StringRef Filename) {
-  Archive::symbol_iterator I = A->symbol_begin();
-  Archive::symbol_iterator E = A->symbol_end();
-  if (I != E) {
-    outs() << "Archive map\n";
-    for (; I != E; ++I) {
-      Expected<Archive::Child> C = I->getMember();
-      if (!C) {
-        error(C.takeError(), Filename);
-        break;
-      }
-      Expected<StringRef> FileNameOrErr = C->getName();
-      if (!FileNameOrErr) {
-        error(FileNameOrErr.takeError(), Filename);
-        break;
-      }
-      StringRef SymName = I->getName();
-      outs() << SymName << " in " << FileNameOrErr.get() << "\n";
-    }
-    outs() << "\n";
-  }
+static void printArchiveMap(iterator_range<Archive::symbol_iterator> &map,
+                            StringRef Filename) {
+  for (auto I : map) {
+    Expected<Archive::Child> C = I.getMember();
+    StringRef SymName = I.getName();
+
+
+static void dumpArchiveMap(Archive *A, StringRef Filename) {
+  auto Map = A->symbols();
+  if (!Map.empty()) {
+    outs() << "Archive map\n";
+    printArchiveMap(Map, Filename);
+  }
+
+  auto ECMap = A->ec_symbols();
+  if (!ECMap) {
+    warn(ECMap.takeError(), Filename);
+  } else if (!ECMap->empty()) {
+    outs() << "Archive EC map\n";
+    printArchiveMap(*ECMap, Filename);
+  }
 }
 
 static void dumpArchive(Archive *A, std::vector<NMSymbol> &SymbolList,
                         StringRef Filename, LLVMContext *ContextPtr) {
   if (ArchiveMap)
     dumpArchiveMap(A, Filename);
 
   Error Err = Error::success();