[llvm-symbolizer] Recognize AIX big archive

llvm/docs/CommandGuide/llvm-symbolizer.rst

@@ -547,8 +547,8 @@ MACH-O SPECIFIC OPTIONS
     $ cat addr.txt
     /tmp/mach_universal_binary:i386 0x1f84
     /tmp/mach_universal_binary:x86_64 0x100000f24
-    /tmp/archive.a(member.o):ppc 0x1000
-    /tmp/archive.a(member.o):ppc64 0x2000
+    /tmp/big-archive.a(member.o):ppc 0x1000
+    /tmp/big-archive.a(member.o):ppc64 0x2000
 
     $ llvm-symbolizer < addr.txt
     _main
@@ -559,7 +559,7 @@ MACH-O SPECIFIC OPTIONS
 
     _foo
     /tmp/source_ppc.cc:12
-    
+
     _foo
     /tmp/source_ppc64.cc:12
 

llvm/include/llvm/DebugInfo/Symbolize/Symbolize.h

@@ -29,12 +29,6 @@
 #include <utility>
 #include <vector>
 
-#if defined(_AIX)
-#  define SYMBOLIZE_AIX 1
-#else
-#  define SYMBOLIZE_AIX 0
-#endif
-
 namespace llvm {
 namespace object {
 class ELFObjectFileBase;
@@ -205,14 +199,14 @@ class LLVMSymbolizer {
   /// Return a pointer to object file at specified path, for a specified
   /// architecture (e.g. if path refers to a Mach-O universal binary, only one
   /// object file from it will be returned).
-  Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
-                                           const std::string &ArchName);
+  Expected<ObjectFile *> getOrCreateObject(const std::string &InputPath,
+                                           const std::string &DefaultArchName);
 
   /// Return a pointer to object file at specified path, for a specified
   /// architecture that is present inside an archive file
   Expected<ObjectFile *> getOrCreateObjectFromArchive(StringRef ArchivePath,
                                                       StringRef MemberName,
-                                                      const std::string &ArchName);   
+                                                      StringRef ArchName);
 
   /// Update the LRU cache order when a binary is accessed.
   void recordAccess(CachedBinary &Bin);
@@ -239,19 +233,20 @@ class LLVMSymbolizer {
       ObjectForUBPathAndArch;
 
   struct ArchiveCacheKey {
-    std::string ArchivePath;  // Storage for StringRef
-    std::string MemberName;   // Storage for StringRef
-    std::string ArchName;     // Storage for StringRef
+    std::string ArchivePath; // Storage for StringRef
+    std::string MemberName;  // Storage for StringRef
+    std::string ArchName;    // Storage for StringRef
 
     // Required for map comparison
     bool operator<(const ArchiveCacheKey &Other) const {
-      return std::tie(ArchivePath, MemberName, ArchName) < 
+      return std::tie(ArchivePath, MemberName, ArchName) <
              std::tie(Other.ArchivePath, Other.MemberName, Other.ArchName);
     }
   };
 
-  std::map<ArchiveCacheKey, std::unique_ptr<ObjectFile>> ObjectForArchivePathAndArch;
-
+  std::map<ArchiveCacheKey, std::unique_ptr<ObjectFile>>
+      ObjectForArchivePathAndArch;
+
   Options Opts;
 
   std::unique_ptr<BuildIDFetcher> BIDFetcher;

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

@@ -21,6 +21,7 @@
 #include "llvm/DebugInfo/PDB/PDBContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableObjectFile.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Object/BuildID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
@@ -33,7 +34,6 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Object/Archive.h"
 #include <cassert>
 #include <cstring>
 
@@ -323,7 +323,7 @@ bool checkFileCRC(StringRef Path, uint32_t CRCHash) {
 
 bool getGNUDebuglinkContents(const ObjectFile *Obj, std::string &DebugName,
                              uint32_t &CRCHash) {
-  if (!Obj || !isa<ObjectFile>(Obj))
+  if (!Obj)
     return false;
   for (const SectionRef &Section : Obj->sections()) {
     StringRef Name;
@@ -564,26 +564,23 @@ LLVMSymbolizer::getOrCreateObjectPair(const std::string &Path,
   std::string DbgObjPath = DbgObj->getFileName().str();
   auto BinIter = BinaryForPath.find(DbgObjPath);
   if (BinIter != BinaryForPath.end()) {
-    BinIter->second.pushEvictor([this, I = Pair.first]() {
-    ObjectPairForPathArch.erase(I);
-    });
+    BinIter->second.pushEvictor(
+        [this, I = Pair.first]() { ObjectPairForPathArch.erase(I); });
   }
   return Res;
 }
 
-Expected<ObjectFile *> LLVMSymbolizer::getOrCreateObjectFromArchive(StringRef ArchivePath, 
-                                                                    StringRef MemberName, 
-                                                                    const std::string &ArchName) {
+Expected<ObjectFile *> LLVMSymbolizer::getOrCreateObjectFromArchive(
+    StringRef ArchivePath, StringRef MemberName, StringRef ArchName) {
   Binary *Bin = nullptr;
   auto Pair = BinaryForPath.emplace(ArchivePath.str(), OwningBinary<Binary>());
   if (!Pair.second) {
     Bin = Pair.first->second->getBinary();
     recordAccess(Pair.first->second);
   } else {
     Expected<OwningBinary<Binary>> ArchiveOrErr = createBinary(ArchivePath);
-    if (!ArchiveOrErr) {
+    if (!ArchiveOrErr)
       return ArchiveOrErr.takeError();
-    }
 
     CachedBinary &CachedBin = Pair.first->second;
     CachedBin = std::move(ArchiveOrErr.get());
@@ -593,43 +590,46 @@ Expected<ObjectFile *> LLVMSymbolizer::getOrCreateObjectFromArchive(StringRef Ar
     Bin = CachedBin->getBinary();
   }
 
-  if (!Bin || !isa<object::Archive>(Bin))
+  object::Archive *Archive = dyn_cast_if_present<object::Archive>(Bin);
+  if (!Archive)
     return errorCodeToError(object_error::invalid_file_type);
 
-  object::Archive *Archive = cast<object::Archive>(Bin);
   Error Err = Error::success();
-
-  // On AIX, archives can contain multiple members with same name but different types
-  // We need to check all matches and find one that matches both name and architecture
+
+  // On AIX, archives can contain multiple members with same name but different
+  // types. We need to check all matches and find one that matches both name and
+  // architecture.
   for (auto &Child : Archive->children(Err, /*SkipInternal=*/true)) {
     Expected<StringRef> NameOrErr = Child.getName();
     if (!NameOrErr)
-      continue; 
-    if (*NameOrErr == llvm::sys::path::filename(MemberName)) {
-      Expected<std::unique_ptr<object::Binary>> MemberOrErr = Child.getAsBinary();
+      continue;
+    if (*NameOrErr == sys::path::filename(MemberName)) {
+      Expected<std::unique_ptr<object::Binary>> MemberOrErr =
+          Child.getAsBinary();
       if (!MemberOrErr)
-        continue; 
-      
+        continue;
+
       std::unique_ptr<object::Binary> Binary = std::move(*MemberOrErr);
       if (auto *Obj = dyn_cast<object::ObjectFile>(Binary.get())) {
-#if defined(_AIX)
         Triple::ArchType ObjArch = Obj->makeTriple().getArch();
         Triple RequestedTriple;
         RequestedTriple.setArch(Triple::getArchTypeForLLVMName(ArchName));
         if (ObjArch != RequestedTriple.getArch())
           continue;
-#endif
-        ArchiveCacheKey CacheKey{ArchivePath.str(), MemberName.str(), ArchName};
+        ArchiveCacheKey CacheKey{ArchivePath.str(), MemberName.str(),
+                                 ArchName.str()};
         auto I = ObjectForArchivePathAndArch.find(CacheKey);
         if (I != ObjectForArchivePathAndArch.end())
           return I->second.get();
 
         auto CachedObj = std::unique_ptr<ObjectFile>(Obj);
-        auto NewEntry = ObjectForArchivePathAndArch.emplace(
-            CacheKey, std::move(CachedObj));
+        auto NewEntry =
+            ObjectForArchivePathAndArch.emplace(CacheKey, std::move(CachedObj));
         Binary.release();
-        BinaryForPath.find(ArchivePath.str())->second.pushEvictor(
-            [this, Iter = NewEntry.first]() { ObjectForArchivePathAndArch.erase(Iter); });
+        BinaryForPath.find(ArchivePath.str())
+            ->second.pushEvictor([this, Iter = NewEntry.first]() {
+              ObjectForArchivePathAndArch.erase(Iter);
+            });
         return NewEntry.first->second.get();
       }
     }
@@ -642,13 +642,15 @@ Expected<ObjectFile *> LLVMSymbolizer::getOrCreateObjectFromArchive(StringRef Ar
 Expected<ObjectFile *>
 LLVMSymbolizer::getOrCreateObject(const std::string &Path,
                                   const std::string &ArchName) {
-  // First check for archive(member) format - more efficient to check closing paren first
+  // First check for archive(member) format - more efficient to check closing
+  // paren first.
   size_t CloseParen = Path.rfind(')');
   if (CloseParen != std::string::npos && CloseParen == Path.length() - 1) {
     size_t OpenParen = Path.rfind('(', CloseParen);
     if (OpenParen != std::string::npos) {
       StringRef ArchivePath = StringRef(Path).substr(0, OpenParen);
-      StringRef MemberName = StringRef(Path).substr(OpenParen + 1, CloseParen - OpenParen - 1);
+      StringRef MemberName =
+          StringRef(Path).substr(OpenParen + 1, CloseParen - OpenParen - 1);
       return getOrCreateObjectFromArchive(ArchivePath, MemberName, ArchName);
     }
   }
@@ -803,10 +805,8 @@ LLVMSymbolizer::getOrCreateModuleInfo(StringRef ModuleName) {
   if (ModuleOrErr) {
     auto I = Modules.find(ModuleName);
     auto BinIter = BinaryForPath.find(BinaryName);
-    if (BinIter != BinaryForPath.end()) 
-      BinIter->second.pushEvictor([this, I]() {
-      Modules.erase(I);
-    });
+    if (BinIter != BinaryForPath.end())
+      BinIter->second.pushEvictor([this, I]() { Modules.erase(I); });
   }
   return ModuleOrErr;
 }

llvm/test/DebugInfo/symbolize-big-archive-elf.test

@@ -1,5 +1,5 @@
 // Test archive member recognition by name (ELF format)
-// UNSUPPORTED: target={{.*}}-aix{{.*}}
+// REQUIRES: system-linux || system-aix
 
 // Generate object files from YAML
 // RUN: yaml2obj -o %t-1.o %S/Inputs/big-archive-elf-1.yaml
@@ -9,14 +9,13 @@
 // RUN: rm -f %t.a
 // RUN: llvm-ar crv %t.a %t-1.o %t-2.o
 
-// Verify archive contents
-// RUN: llvm-ar tv %t.a | FileCheck %s --check-prefix=CHECK-ARCHIVE
-// CHECK-ARCHIVE: {{.*}}-1.o
-// CHECK-ARCHIVE: {{.*}}-2.o
-
 // Test symbolization by member name (using just base names)
-// RUN: llvm-symbolizer --default-arch=ppc64 --obj="%t.a(%t-1.o)" 0x0 | FileCheck %s --check-prefix=CHECK-1
-// RUN: llvm-symbolizer --default-arch=ppc64 --obj="%t.a(%t-2.o)" 0x0 | FileCheck %s --check-prefix=CHECK-2
+// RUN: MEMBER1=$(basename %t-1.o)
+// RUN: llvm-symbolizer --default-arch=ppc64le --obj="%t.a($MEMBER1)" 0x0 | FileCheck %s --check-prefix=CHECK-1
+// RUN: llvm-symbolizer --obj="%t.a($MEMBER1):ppc64le" 0x0 | FileCheck %s --check-prefix=CHECK-1
+// RUN: MEMBER2=$(basename %t-2.o)
+// RUN: llvm-symbolizer --default-arch=ppc64le --obj="%t.a($MEMBER2)" 0x0 | FileCheck %s --check-prefix=CHECK-2
+// RUN: llvm-symbolizer --obj="%t.a($MEMBER2):ppc64le" 0x0 | FileCheck %s --check-prefix=CHECK-2
 // CHECK-1: foo1
 // CHECK-2: foo2
 

llvm/test/DebugInfo/symbolize-big-archive-xcoff.test

@@ -1,27 +1,31 @@
 // Test big archive recognition and error handling in llvm-symbolizer
-// REQUIRES: system-aix, target={{.*}}-aix{{.*}}
+// REQUIRES: system-linux || system-aix
 
 // Generate object files
 // RUN: yaml2obj -o %t-32.o %S/Inputs/big-archive-32.yaml
 // RUN: yaml2obj -o %t-64.o %S/Inputs/big-archive-64.yaml
 
 // Create archive with same-named members using different modes
 // RUN: rm -f %t.a
-// RUN: cp %t-32.o %t.o && llvm-ar -X32 crv %t.a %t.o
-// RUN: cp %t-64.o %t.o && llvm-ar -X64 qv %t.a %t.o
-
+// RUN: cp %t-32.o %t.o
+// RUN: llvm-ar %if system-aix %{-X32%} crv %t.a %t.o
+// RUN: cp %t-64.o %t.o
+// RUN: llvm-ar %if system-aix %{-X64 rv%} %else %{qv%} %t.a %t.o
+
 // Verify archive contains two members with same name
-// RUN: llvm-ar tv -X32_64 %t.a | FileCheck %s --check-prefix=CHECK-ARCHIVE
+// RUN: llvm-ar tv %if system-aix %{-X32_64%} %t.a | FileCheck %s --check-prefix=CHECK-ARCHIVE
 // CHECK-ARCHIVE: {{.*}}symbolize-big-archive-xcoff.test.tmp.o{{$}}
 // CHECK-ARCHIVE: {{.*}}symbolize-big-archive-xcoff.test.tmp.o{{$}}
 
 // Test successful symbolization
-// RUN: llvm-symbolizer --default-arch=ppc --obj="%t.a(%t.o)" 0x0 | FileCheck %s --check-prefix=CHECK-32
-// RUN: llvm-symbolizer --default-arch=ppc64 --obj="%t.a(%t.o)" 0x0 | FileCheck %s --check-prefix=CHECK-64
+// RUN: MEMBER=$(basename %t.o)
+// RUN: llvm-symbolizer --default-arch=ppc --obj="%t.a($MEMBER)" 0x0 | FileCheck %s --check-prefix=CHECK-32
+// RUN: llvm-symbolizer --default-arch=ppc64 --obj="%t.a($MEMBER)" 0x0 | FileCheck %s --check-prefix=CHECK-64
+// RUN: llvm-symbolizer --obj="%t.a($MEMBER):ppc" 0x0 | FileCheck %s --check-prefix=CHECK-32
+// RUN: llvm-symbolizer --obj="%t.a($MEMBER):ppc64" 0x0 | FileCheck %s --check-prefix=CHECK-64
 // CHECK-32: foo
 // CHECK-64: foo
 
 // Test error cases
 // RUN: not llvm-symbolizer --obj="%t.a(nonexistent.o)" 0x1000 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
-
 // CHECK-ERROR: error: {{.*}}No object file for requested architecture