export unique symbol list for xcoff with llvm-objdump new option "--export-unique-symbol"

[DiggerLin]

Summary

the patch implement of following functionality.

1. export the symbols of the xcoff archive or object files. (export the extern and extern weak symbol)
2. delete the duplicate export symbols (which has same symbol name and visibility)
3. sort the export symbols.
4. print out the unique and sorted export symbols (print the symbol name and visibility).

there new options are add in the patch

1. --export-unique-symbol (enable the functionality of export unique symbol for xcoff)
2. --exclude-weak (exclude the weak symbol from be exporting)
3. --exclude-rsrc (exclude the symbol name begin with "__rsrc" from be exporting.

The patch has the same functionality as
IBM CreateExportList
The patch has copied same code from patch https://reviews.llvm.org/D82549[AIX][XCOFF] parsing xcoff object file auxiliary header

after the patch D82549 approved, I will rebase the patch.

[DiggerLin]

@jhenderson , if you have time , can you help to reviewed the patch . we target the patch at November 12 . thank in advance.

[DiggerLin]

sorry for clicking approve the patch by myself.

[DiggerLin]

rebase the code after the decode auxiliary header landed.

[DiggerLin]

since I approved the patch myself by accident and the patch do not have comments on it since I posted. I closed the patch and open a new one https://reviews.llvm.org/D112735 export unique symbol list for xcoff with llvm-objdump new option "--export-unique-symbol"

llvm/include/llvm/BinaryFormat/XCOFF.h

 constexpr size_t RelocationSerializationSize32 = 10;
 constexpr size_t RelocationSerializationSize64 = 14;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 };
+enum XCOFFInterpret : uint16_t {
+  OLD_XCOFF_INTERPRET = 1,
+  NEW_XCOFF_INTERPRET = 2
+};
+
+enum FileFlag : uint16_t {
+  F_RELFLG = 0x0001,    ///< relocation info stripped from file
+  F_EXEC = 0x0002,      ///< file is executable (i.e., it
+                        ///< has a loader section)
+  F_LNNO = 0x0004,      ///< line numbers stripped from file
+  F_LSYMS = 0x0008,     ///< local symbols stripped from file
+  F_FDPR_PROF = 0x0010, ///< file was profiled with FDPR
+  F_FDPR_OPTI = 0x0020, ///< file was reordered with FDPR
+  F_DSA = 0x0040,       ///< file uses Dynamic Segment Allocation (32-bit
+                        ///< only)
+  F_DEP_1 = 0x0080,     ///< data Execution Protection bit 1
+  F_VARPG = 0x0100,     ///< executable requests using variable size pages
+  F_LPTEXT = 0x0400,    ///<  executable requires large pages for text
+  F_LPDATA = 0x0800,    ///< executable requires large pages for data
+  F_DYNLOAD = 0x1000,   ///< file is dynamically loadable and
+                        ///< executable (equivalent to F_EXEC on AIX)
+  F_SHROBJ = 0x2000,    ///<  file is a shared object
+  F_LOADONLY =
+      0x4000,      ///<  file can be loaded by the system loader, but it is
+                   ///<  ignored by the linker if it is a member of an archive.
+  F_DEP_2 = 0x8000 ///<  Data Execution Protection bit 2
+};
 
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
 enum StorageMappingClass : uint8_t {
   //     READ ONLY CLASSES
   XMC_PR = 0,      ///< Program Code
   XMC_RO = 1,      ///< Read Only Constant
   XMC_DB = 2,      ///< Debug Dictionary Table

 enum VisibilityType : uint16_t {
   SYM_V_UNSPECIFIED = 0x0000,
   SYM_V_INTERNAL = 0x1000,
   SYM_V_HIDDEN = 0x2000,
   SYM_V_PROTECTED = 0x3000,
   SYM_V_EXPORTED = 0x4000
 };
 
+static constexpr uint16_t VISIBILITY_MASK = 0x7000;
+
 // Relocation types, defined in `/usr/include/reloc.h`.
 enum RelocationType : uint8_t {
   R_POS = 0x00, ///< Positive relocation. Provides the address of the referenced
                 ///< symbol.
   R_RL = 0x0c,  ///< Positive indirect load relocation. Modifiable instruction.
   R_RLA = 0x0d, ///< Positive load address relocation. Modifiable instruction.
 
   R_NEG = 0x01, ///< Negative relocation. Provides the negative of the address

llvm/include/llvm/Object/SymbolicFile.h

enum Flags : unsigned {
     SF_Exported = 1U << 6,       // Symbol is visible to other DSOs
     SF_FormatSpecific = 1U << 7, // Specific to the object file format
                                  // (e.g. section symbols)
     SF_Thumb = 1U << 8,          // Thumb symbol in a 32-bit ARM binary
     SF_Hidden = 1U << 9,         // Symbol has hidden visibility
     SF_Const = 1U << 10,         // Symbol value is constant
     SF_Executable = 1U << 11,    // Symbol points to an executable section
                                  // (IR only)
+    SF_Protected = 1U << 12,     // Symbol has protected visibility
+    SF_Internal = 1U << 13       // Symbol has internal visibility
   };
 
   BasicSymbolRef() = default;
   BasicSymbolRef(DataRefImpl SymbolP, const SymbolicFile *Owner);
 
   bool operator==(const BasicSymbolRef &Other) const;
   bool operator<(const BasicSymbolRef &Other) const;
 

llvm/include/llvm/Object/XCOFFObjectFile.h

struct XCOFFFileHeader64 {
   support::big32_t TimeStamp;
 
   support::ubig64_t SymbolTableOffset; // File offset to symbol table.
   support::ubig16_t AuxHeaderSize;
   support::ubig16_t Flags;
   support::ubig32_t NumberOfSymTableEntries;
 };
 
+template <typename T> struct XCOFFAuxiliaryHeader {
+  static constexpr uint8_t AuxiHeaderFlagMask = 0xF0;
+  static constexpr uint8_t AuxiHeaderTDataAlignmentMask = 0x0F;
+
+public:
+  uint8_t getFlag() const {
+    return static_cast<const T *>(this)->FlagAndTDataAlignment &
+           AuxiHeaderFlagMask;
+  }
+  uint8_t getTDataAlignment() const {
+    return static_cast<const T *>(this)->FlagAndTDataAlignment &
+           AuxiHeaderTDataAlignmentMask;
+  }
+
+  uint16_t getVersion() const { return static_cast<const T *>(this)->Version; }
+};
+
+struct XCOFFAuxiliaryHeader32 : XCOFFAuxiliaryHeader<XCOFFAuxiliaryHeader32> {
+  support::ubig16_t
+      AuxMagic; ///< If the value of the o_vstamp field is greater than 1, the
+                ///< o_mflags field is reserved for future use and it should
+                ///< contain 0. Otherwise, this field is not used.
+  support::ubig16_t
+      Version; ///< The valid values are 1 and 2. When the o_vstamp field is 2
+               ///< in an XCOFF32 file, the new interpretation of the n_type
+               ///< field in the symbol table entry is used.
+  support::ubig32_t TextSize;
+  support::ubig32_t InitDataSize;
+  support::ubig32_t BssDataSize;
+  support::ubig32_t EntryPointAddr;
+  support::ubig32_t TextStartAddr;
+  support::ubig32_t DataStartAddr;
+  support::ubig32_t TOCAnchorAddr;
+  support::ubig16_t SecNumOfEntryPoint;
+  support::ubig16_t SecNumOfText;
+  support::ubig16_t SecNumOfData;
+  support::ubig16_t SecNumOfTOC;
+  support::ubig16_t SecNumOfLoader;
+  support::ubig16_t SecNumOfBSS;
+  support::ubig16_t MaxAlignOfText;
+  support::ubig16_t MaxAlignOfData;
+  support::ubig16_t ModuleType;
+  uint8_t CpuFlag;
+  uint8_t CpuType;
+  support::ubig32_t MaxStackSize; ///< If the value is 0, the system default
+                                  ///< maximum stack size is used.
+  support::ubig32_t MaxDataSize;  ///< If the value is 0, the system default
+                                  ///< maximum data size is used.
+  support::ubig32_t
+      ReservedForDebugger; ///< This field should contain 0. When a loaded
+                           ///< program is being debugged, the memory image of
+                           ///< this field may be modified by a debugger to
+                           ///< insert a trap instruction.
+  uint8_t TextPageSize;  ///< Specifies the size of pages for the exec text. The
+                         ///< default value is 0 (system-selected page size).
+  uint8_t DataPageSize;  ///< Specifies the size of pages for the exec data. The
+                         ///< default value is 0 (system-selected page size).
+  uint8_t StackPageSize; ///< Specifies the size of pages for the stack. The
+                         ///< default value is 0 (system-selected page size).
+  uint8_t FlagAndTDataAlignment;
+  support::ubig16_t SecNumOfTData;
+  support::ubig16_t SecNumOfTBSS;
+};
+
+struct XCOFFAuxiliaryHeader64 : XCOFFAuxiliaryHeader<XCOFFAuxiliaryHeader32> {
+  support::ubig16_t AuxMagic;
+  support::ubig16_t Version;
+  support::ubig32_t ReservedForDebugger;
+  support::ubig64_t TextStartAddr;
+  support::ubig64_t DataStartAddr;
+  support::ubig64_t TOCAnchorAddr;
+  support::ubig16_t SecNumOfEntryPoint;
+  support::ubig16_t SecNumOfText;
+  support::ubig16_t SecNumOfData;
+  support::ubig16_t SecNumOfTOC;
+  support::ubig16_t SecNumOfLoader;
+  support::ubig16_t SecNumOfBSS;
+  support::ubig16_t MaxAlignOfText;
+  support::ubig16_t MaxAlignOfData;
+  support::ubig16_t ModuleType;
+  uint8_t CpuFlag;
+  uint8_t CpuType;
+  uint8_t TextPageSize;
+  uint8_t DataPageSize;
+  uint8_t StackPageSize;
+  uint8_t FlagAndTDataAlignment;
+  support::ubig64_t TextSize;
+  support::ubig64_t InitDataSize;
+  support::ubig64_t BssDataSize;
+  support::ubig64_t EntryPointAddr;
+  support::ubig64_t MaxStackSize;
+  support::ubig64_t MaxDataSize;
+  support::ubig16_t SecNumOfTData;
+  support::ubig16_t SecNumOfTBSS;
+  support::ubig16_t XCOFF64Flag;
+};
+
 template <typename T> struct XCOFFSectionHeader {
   // Least significant 3 bits are reserved.
   static constexpr unsigned SectionFlagsReservedMask = 0x7;
 
   // The low order 16 bits of section flags denotes the section type.
   static constexpr unsigned SectionFlagsTypeMask = 0xffffu;
 
 public:

 struct XCOFFRelocation32 : XCOFFRelocation<llvm::support::ubig32_t> {};
 struct XCOFFRelocation64 : XCOFFRelocation<llvm::support::ubig64_t> {};
 
 class XCOFFSymbolRef;
 
 class XCOFFObjectFile : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
+  const void *AuxiliaryHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const void *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 
   const XCOFFFileHeader32 *fileHeader32() const;
   const XCOFFFileHeader64 *fileHeader64() const;
 
public:
   SubtargetFeatures getFeatures() const override;
   Expected<uint64_t> getStartAddress() const override;
   StringRef mapDebugSectionName(StringRef Name) const override;
   bool isRelocatableObject() const override;
 
   // Below here is the non-inherited interface.
   bool is64Bit() const;
 
+  const XCOFFAuxiliaryHeader32 *auxiliaryHeader32() const;
+  const XCOFFAuxiliaryHeader64 *auxiliaryHeader64() const;
+
   const void *getPointerToSymbolTable() const { return SymbolTblPtr; }
 
   Expected<StringRef> getSymbolSectionName(XCOFFSymbolRef Ref) const;
   unsigned getSymbolSectionID(SymbolRef Sym) const;
   XCOFFSymbolRef toSymbolRef(DataRefImpl Ref) const;
 
   // File header related interfaces.
   uint16_t getMagic() const;

llvm/lib/Object/XCOFFObjectFile.cpp

const XCOFFFileHeader32 *XCOFFObjectFile::fileHeader32() const {
   return static_cast<const XCOFFFileHeader32 *>(FileHeader);
 }
 
 const XCOFFFileHeader64 *XCOFFObjectFile::fileHeader64() const {
   assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
   return static_cast<const XCOFFFileHeader64 *>(FileHeader);
 }
 
+const XCOFFAuxiliaryHeader32 *XCOFFObjectFile::auxiliaryHeader32() const {
+  assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
+  return static_cast<const XCOFFAuxiliaryHeader32 *>(AuxiliaryHeader);
+}
+
+const XCOFFAuxiliaryHeader64 *XCOFFObjectFile::auxiliaryHeader64() const {
+  assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
+  return static_cast<const XCOFFAuxiliaryHeader64 *>(AuxiliaryHeader);
+}
+
 template <typename T> const T *XCOFFObjectFile::sectionHeaderTable() const {
   return static_cast<const T *>(SectionHeaderTable);
 }
 
 const XCOFFSectionHeader32 *
 XCOFFObjectFile::sectionHeaderTable32() const {
   assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
   return static_cast<const XCOFFSectionHeader32 *>(SectionHeaderTable);
if (CsectAuxEntOrErr) {
         Result |= SymbolRef::SF_Common;
     } else
       return CsectAuxEntOrErr.takeError();
   }
 
   if (XCOFFSym.getSectionNumber() == XCOFF::N_UNDEF)
     Result |= SymbolRef::SF_Undefined;
 
+  // There is no visibility in old 32 bit XCOFF object file interpret.
+  if (is64Bit() || (auxiliaryHeader32() && (auxiliaryHeader32()->getVersion() ==
+                                            NEW_XCOFF_INTERPRET))) {
+
+    uint16_t SymType = XCOFFSym.getSymbolType();
+    if ((SymType & VISIBILITY_MASK) == SYM_V_INTERNAL)
+      Result |= SymbolRef::SF_Internal;
+    if ((SymType & VISIBILITY_MASK) == SYM_V_HIDDEN)
+      Result |= SymbolRef::SF_Hidden;
+    if ((SymType & VISIBILITY_MASK) == SYM_V_PROTECTED)
+      Result |= SymbolRef::SF_Protected;
+    if ((SymType & VISIBILITY_MASK) == SYM_V_EXPORTED)
+      Result |= SymbolRef::SF_Exported;
+  }
   return Result;
 }
 
 basic_symbol_iterator XCOFFObjectFile::symbol_begin() const {
   DataRefImpl SymDRI;
   SymDRI.p = reinterpret_cast<uintptr_t>(SymbolTblPtr);
   return basic_symbol_iterator(SymbolRef(SymDRI, this));
 }
XCOFFObjectFile::create(unsigned Type, MemoryBufferRef MBR) {
   // Parse file header.
   auto FileHeaderOrErr =
       getObject<void>(Data, Base + CurOffset, Obj->getFileHeaderSize());
   if (Error E = FileHeaderOrErr.takeError())
     return std::move(E);
   Obj->FileHeader = FileHeaderOrErr.get();
 
   CurOffset += Obj->getFileHeaderSize();
-  // TODO FIXME we don't have support for an optional header yet, so just skip
-  // past it.
+
+  if (Obj->getOptionalHeaderSize()) {
+    auto AuxiliaryHeaderOrErr =
+        getObject<void>(Data, Base + CurOffset, Obj->getOptionalHeaderSize());
+    if (Error E = AuxiliaryHeaderOrErr.takeError())
+      return std::move(E);
+    Obj->AuxiliaryHeader = AuxiliaryHeaderOrErr.get();
+  }
+
   CurOffset += Obj->getOptionalHeaderSize();
 
   // Parse the section header table if it is present.
   if (Obj->getNumberOfSections()) {
     auto SecHeadersOrErr = getObject<void>(Data, Base + CurOffset,
                                            Obj->getNumberOfSections() *
                                                Obj->getSectionHeaderSize());
     if (Error E = SecHeadersOrErr.takeError())

llvm/test/tools/llvm-objdump/XCOFF/export_sym_list_ar.test

+; Test the functionality of the llvm-objdump --export-unique-symbol  exporting  symbol list of aix archive file. 
+
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/libtest.a | FileCheck --check-prefixes=SYM %s
+
+; The archive file libtest.a is created from test_xclang++.o and test1_gcc.o with command 
+; ar -v -q libtest.a test_xclang++.o test1_gcc.o 
+
+; test_xclang++.o is generated from following source code compiled with IBM xlclang with option -qvisibilty 
+
+; int v = 0;
+;
+; __attribute__((visibility ("protected"))) int  vp = 1;
+; __attribute__((visibility ("hidden"))) int  vh = 2;
+; __attribute__((visibility ("default"))) int  vd = 3;
+; __attribute__ ((weak)) __attribute__((visibility ("hidden"))) int vwh = 4;
+; __attribute__ ((weak)) __attribute__((visibility ("protected"))) int vwp = 5;
+;
+; class C {
+; public:
+;  int c;
+;  C(int v):c(v) {}
+; };
+;
+; C cc(2);
+;
+; static int si = 6;
+;
+; static int func0 () {
+;   return vp+si;
+; }
+;
+; int func1 (int i) {
+;   return func0() * i;
+; }
+;
+; __attribute__ ((weak)) __attribute__((visibility ("hidden")))
+; int fwh() {
+;   return si+1;
+; }
+;
+; __attribute__ ((weak)) __attribute__((visibility ("protected")))
+; int fwp() {
+;   return si+2;
+; }
+
+; test1_gcc.o is generated from following source code with compiled with gcc
+; const char* con= "Test for --symbols";
+; const char myString[]="my string.";
+;  int i;
+;  char c ;
+;  char c1;
+;  char c2;
+;  char *ap;
+;  float f;
+;  long long ll;
+;  static int si;
+;  extern int ei;
+; int  bar(const char *v) {
+;    si = 1;
+;    return (int)v[0] + (int)v[2] + si + ei;
+; }
+;
+; void foo() {
+;    bar(con);
+; }
+;
+; int vd=2;
+
+
+SYM:      _Z3fwpv protected
+SYM-NEXT: _Z5func1i
+SYM-NEXT: _ZN1CC2Ei
+SYM-NEXT: ap
+SYM-NEXT: bar
+SYM-NEXT: c
+SYM-NEXT: c1
+SYM-NEXT: c2
+SYM-NEXT: cc
+SYM-NEXT: con
+SYM-NEXT: f
+SYM-NEXT: foo
+SYM-NEXT: i
+SYM-NEXT: ll
+SYM-NEXT: myString
+SYM-NEXT: v
+SYM-NEXT: vd
+SYM-NEXT: vd export
+SYM-NEXT: vp protected
+SYM-NEXT: vwp protected
+
+

llvm/test/tools/llvm-objdump/XCOFF/export_sym_list_obj.test

+; Test the functionality of the llvm-objdump --export-unique-symbol  exporting  symbol list of xcoff object file. 
+; Test 1: Not export the symbol begin with "__sinit" and "__sterm" and "."
+; Test 2: Not export weak symbol with option "exclude-weak".
+; Test 3: Export format: symbol_name  symbol_visibility(if there is).
+; Test 4: Not export __rsrc symbol name with option "exclude-rsrc".
+; Test 5: Not export symbol which start with "__tf1".
+; Test 6: Not export any symobl for shared object file.
+; Test 7: Only keep unique symbol in the export list.
+
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/exp_sym.o | FileCheck --check-prefixes=SYM %s
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/exp_sym.o %p/Inputs/exp_sym.o | FileCheck --check-prefixes=SYM %s
+; RUN: llvm-objdump --export-unique-symbol --exclude-weak %p/Inputs/exp_sym.o | FileCheck --check-prefix=EXCLUDE-WEAK %s
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/rsrc.o | FileCheck --check-prefixes=RSRC %s
+; RUN: llvm-objdump --export-unique-symbol --exclude-rsrc %p/Inputs/rsrc.o  | FileCheck --check-prefixes=EXCLUDE-RSRC --allow-empty %s
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/libtest_sharedobj.a | FileCheck --check-prefixes=ANY --allow-empty %s
+; RUN: llvm-objdump --export-unique-symbol %p/Inputs/ilosolution.o | FileCheck --check-prefixes=TF1 %s
+
+; The object file Inputs/exp_sym.o is generated from following source code with IBM xlclang with option -qvisibilty 
+ 
+;; int v = 0;
+;; __attribute__((visibility ("protected"))) int  vp = 1;
+;; __attribute__((visibility ("hidden"))) int  vh = 2;
+;; __attribute__((visibility ("default"))) int  vd = 3;
+;; __attribute__ ((weak)) __attribute__((visibility ("hidden"))) int vwh = 4;
+;; __attribute__ ((weak)) __attribute__((visibility ("protected"))) int vwp = 5;
+;; 
+;; class C {
+;; public:
+;;  int c;
+;;  C(int v):c(v) {}
+;; };
+;; 
+;; C cc(2);
+;; 
+;; static int si = 6;
+;; 
+;; static int func0 () {
+;;   return vp+si;
+;; }
+;; 
+;; int func1 (int i) {
+;;   return func0() * i;
+;; }
+;; 
+;; __attribute__ ((weak)) __attribute__((visibility ("hidden")))
+;; int fwh() {
+;;   return si+1;
+;; }
+;; 
+;; __attribute__ ((weak)) __attribute__((visibility ("protected")))
+;; int fwp() {
+;;   return si+2;
+;; }
+
+
+; SYM:      _Z3fwpv protected
+; SYM-NEXT: _Z5func1i
+; SYM-NEXT: _ZN1CC2Ei
+; SYM-NEXT: cc
+; SYM-NEXT: v
+; SYM-NEXT: vd export
+; SYM-NEXT: vp protected
+; SYM-NEXT: vwp protected
+
+; EXCLUDE-WEAK:      _Z5func1i
+; EXCLUDE-WEAK-NEXT: cc
+; EXCLUDE-WEAK-NEXT: v
+; EXCLUDE-WEAK-NEXT: vd export
+; EXCLUDE-WEAK-NEXT: vp protected
+
+; RSRC: __rsrc
+; EXCLUDE-RSRC-NOT: __rsrc
+
+; TF1-NOT: display__19IloSolutionElementICFR7ostream
+; TF1-NOT: end__12IloExceptionFv
+
+; ANY-NOT: .*

llvm/tools/llvm-objdump/ObjdumpOpts.td

def unwind_info : Flag<["--"], "unwind-info">,
   HelpText<"Display unwind information">;
 def : Flag<["-"], "u">, Alias<unwind_info>,
   HelpText<"Alias for --unwind-info">;
 
 def wide : Flag<["--"], "wide">,
   HelpText<"Ignored for compatibility with GNU objdump">;
 def : Flag<["-"], "w">, Alias<wide>;
 
+def export_unique_symbol : Flag<["--"], "export-unique-symbol">,
+  HelpText<"Export symbol list for xcoff object file or archive">;
+
 defm prefix : Eq<"prefix", "Add prefix to absolute paths">,
               MetaVarName<"prefix">;
 defm prefix_strip
     : Eq<"prefix-strip", "Strip out initial directories from absolute "
                          "paths. No effect without --prefix">,
       MetaVarName<"prefix">;
 
 def debug_vars_EQ : Joined<["--"], "debug-vars=">,
def no_symbolic_operands : Flag<["--"], "no-symbolic-operands">,
   Group<grp_mach_o>;
 
 def arch_EQ : Joined<["--"], "arch=">,
   HelpText<"architecture(s) from a Mach-O file to dump">,
   Group<grp_mach_o>;
 def : Separate<["--"], "arch">,
   Alias<arch_EQ>,
   Group<grp_mach_o>;
+
+def grp_xcoff_o : OptionGroup<"kind">, HelpText<"llvm-objdump XCOFF Specific Options">;
+
+def exclude_rsrc : Flag<["--"], "exclude-rsrc">,
+  HelpText<"Exclude the rsrc symbol from export symbol list"
+           "for xocff (requires --export-unique-symbol)">,
+  Group<grp_xcoff_o>;
+
+def exclude_weak : Flag<["--"], "exclude-weak">,
+  HelpText<"Exclude the weak symbol from export symbol list"
+           "for xcoff files (requires --export-unique-symbol)">,
+  Group<grp_xcoff_o>;
+

llvm/tools/llvm-objdump/XCOFFDump.h

 #define LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H
 
 #include "llvm/Object/XCOFFObjectFile.h"
 
 namespace llvm {
 
 struct SymbolInfoTy;
 
+namespace opt {
+class InputArgList;
+} // namespace opt
+
 namespace objdump {
+
 Optional<XCOFF::StorageMappingClass>
 getXCOFFSymbolCsectSMC(const object::XCOFFObjectFile *Obj,
                        const object::SymbolRef &Sym);
 
 Optional<object::SymbolRef>
 getXCOFFSymbolContainingSymbolRef(const object::XCOFFObjectFile *Obj,
                                   const object::SymbolRef &Sym);
 
 bool isLabel(const object::XCOFFObjectFile *Obj, const object::SymbolRef &Sym);
 
 std::string getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
                                       StringRef SymbolName);
 
 Error getXCOFFRelocationValueString(const object::XCOFFObjectFile *Obj,
                                     const object::RelocationRef &RelRef,
                                     llvm::SmallVectorImpl<char> &Result);
+
+void parseXCOFFOptions(const llvm::opt::InputArgList &InputArgs);
+void exportSymbolInfoFromFile(StringRef InputFile);
+void printExportSymboList(raw_fd_ostream &OS);
+
 } // namespace objdump
 } // namespace llvm
 #endif

llvm/tools/llvm-objdump/XCOFFDump.cpp

 //===-- XCOFFDump.cpp - XCOFF-specific dumper -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the XCOFF-specific dumper for llvm-objdump.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "XCOFFDump.h"
-
+#include "ObjdumpOptID.h"
 #include "llvm-objdump.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/Regex.h"
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::objdump;
+
+static bool ExcludeRsrc;
+static bool ExcludeWeak;
+
+void objdump::parseXCOFFOptions(const llvm::opt::InputArgList &InputArgs) {
+  ExcludeRsrc = InputArgs.hasArg(OBJDUMP_exclude_rsrc);
+  ExcludeWeak = InputArgs.hasArg(OBJDUMP_exclude_weak);
+}
 
 Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile *Obj,
                                              const RelocationRef &Rel,
                                              SmallVectorImpl<char> &Result) {
   symbol_iterator SymI = Rel.getSymbol();
   if (SymI == Obj->symbol_end())
     return make_error<GenericBinaryError>(
         "invalid symbol reference in relocation entry",
if (SymbolInfo.XCOFFSymInfo.StorageMappingClass &&
       !SymbolInfo.XCOFFSymInfo.IsLabel) {
     const XCOFF::StorageMappingClass Smc =
         SymbolInfo.XCOFFSymInfo.StorageMappingClass.getValue();
     Result.append(("[" + XCOFF::getMappingClassString(Smc) + "]").str());
   }
 
   return Result;
 }
+
+struct SymNameVisibilityTy {
+  std::string SymName;
+  StringRef Visibility;
+  SymNameVisibilityTy(StringRef Name, StringRef Vis)
+      : SymName(Name.str()), Visibility(Vis){};
+  SymNameVisibilityTy(StringRef Name) : SymName(Name.str()){};
+
+private:
+  friend bool operator<(const SymNameVisibilityTy &SNV1,
+                        const SymNameVisibilityTy SNV2) {
+    int NameRes = SNV1.SymName.compare(SNV2.SymName);
+    if (NameRes < 0)
+      return true;
+    if (NameRes > 0)
+      return false;
+
+    return SNV1.Visibility.compare(SNV2.Visibility) == -1;
+  }
+
+  friend bool operator==(const SymNameVisibilityTy &SNV1,
+                         const SymNameVisibilityTy SNV2) {
+    return SNV1.SymName.compare(SNV2.SymName) == 0 &&
+           SNV1.Visibility.compare(SNV2.Visibility) == 0;
+  }
+};
+
+std::vector<SymNameVisibilityTy> ExportSymbols;
+
+static void exportSymbolInfoFromObjectFile(const ObjectFile *O,
+                                           StringRef ObjectName,
+                                           StringRef ArchiveName) {
+
+  if (!O->isXCOFF())
+    return;
+
+  // Skip Shared object file.
+  if (O->isXCOFF()) {
+    if (dyn_cast<const XCOFFObjectFile>(O)->getFlags() & XCOFF::F_SHROBJ)
+      return;
+  }
+
+  for (const SymbolRef &Sym : O->symbols()) {
+    Expected<StringRef> NameOrErr = Sym.getName();
+    if (!NameOrErr) {
+      reportError(NameOrErr.takeError(), ObjectName, ArchiveName);
+      continue;
+    }
+    StringRef SymName = NameOrErr.get();
+
+    Expected<uint32_t> FlagsOrErr = Sym.getFlags();
+    if (!FlagsOrErr) {
+      reportError(FlagsOrErr.takeError(), ObjectName, ArchiveName);
+    }
+    uint32_t Flags = FlagsOrErr.get();
+    bool Global = Flags & SymbolRef::SF_Global;
+    bool Weak = Flags & SymbolRef::SF_Weak;
+
+    // if the symbol is not ext or weak, not be exported.
+    if (!Global)
+      continue;
+
+    // if the symbol is weak and exclude-weak is enable, not be exported.
+    if (Weak && ExcludeWeak)
+      continue;
+
+    if (Flags & SymbolRef::SF_Hidden || Flags & SymbolRef::SF_Internal)
+      continue;
+
+    Expected<section_iterator> SymSecOrErr = Sym.getSection();
+    if (!SymSecOrErr) {
+      reportError(SymSecOrErr.takeError(), ObjectName, ArchiveName);
+    }
+
+    section_iterator SecIter = SymSecOrErr.get();
+
+    // if the symbol is not text or data section, not be exported.
+    if (SecIter == O->section_end())
+      continue;
+
+    if (!(SecIter->isText() || SecIter->isData() || SecIter->isBSS()))
+      continue;
+
+    if (O->isXCOFF()) {
+      Regex r("^__[0-9]+__");
+      if (SymName.startswith("__sinit") || SymName.startswith("__sterm") ||
+          SymName.front() == '.' || SymName.front() == '(' || r.match(SymName))
+        continue;
+
+      if (SymName.startswith("__tf1")) {
+        SymName = SymName.substr(6);
+      } else if (SymName.startswith("__tf9")) {
+        SymName = SymName.substr(14);
+      }
+
+      if (SymName == "__rsrc" && ExcludeRsrc)
+        continue;
+    }
+
+    if (Flags & SymbolRef::SF_Exported) {
+      ExportSymbols.push_back(SymNameVisibilityTy(SymName, "export"));
+      continue;
+    }
+
+    if (Flags & SymbolRef::SF_Protected) {
+      ExportSymbols.push_back(SymNameVisibilityTy(SymName, "protected"));
+      continue;
+    }
+
+    ExportSymbols.push_back(SymName);
+  }
+}
+
+/// Export symbols list from  each object file in \a a;
+static void dumpArchive(const Archive *A) {
+  Error Err = Error::success();
+  unsigned I = -1;
+  for (auto &C : A->children(Err)) {
+    ++I;
+    std::string ChildName = getFileNameForError(C, I);
+
+    Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
+    if (!ChildOrErr) {
+      if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
+        reportError(std::move(E), ChildName, A->getFileName());
+      continue;
+    }
+    if (ObjectFile *O = dyn_cast<ObjectFile>(&*ChildOrErr.get())) {
+      exportSymbolInfoFromObjectFile(O, ChildName, A->getFileName());
+    } else
+      reportError(errorCodeToError(object_error::invalid_file_type), ChildName,
+                  A->getFileName());
+  }
+  if (Err)
+    reportError(std::move(Err), A->getFileName());
+}
+
+void objdump::exportSymbolInfoFromFile(StringRef InputFile) {
+  // Attempt to open the binary.
+  OwningBinary<Binary> OBinary =
+      unwrapOrError(createBinary(InputFile), InputFile);
+  Binary &Binary = *OBinary.getBinary();
+
+  if (Archive *A = dyn_cast<Archive>(&Binary)) {
+    dumpArchive(A);
+  } else if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary))
+    exportSymbolInfoFromObjectFile(O, InputFile, std::string());
+  else
+    reportError(errorCodeToError(object_error::invalid_file_type), InputFile);
+}
+
+void objdump::printExportSymboList(raw_fd_ostream &OS) {
+  if (ExportSymbols.size() == 0)
+    return;
+
+  llvm::sort(ExportSymbols);
+
+  std::vector<SymNameVisibilityTy>::const_iterator Iter = ExportSymbols.begin();
+  std::vector<SymNameVisibilityTy>::const_iterator PreIter = Iter;
+
+  OS << Iter->SymName;
+  if (!Iter->Visibility.empty())
+    OS << " " << Iter->Visibility;
+  OS << "\n";
+
+  PreIter = Iter;
+  while (++Iter < ExportSymbols.end()) {
+    if (!(*PreIter == *Iter)) {
+      OS << Iter->SymName;
+      if (!Iter->Visibility.empty())
+        OS << " " << Iter->Visibility << "\n";
+      else
+        OS << "\n";
+    }
+    PreIter = Iter;
+  }
+}

llvm/tools/llvm-objdump/llvm-objdump.h

 extern bool Relocations;
 extern bool SectionHeaders;
 extern bool SectionContents;
 extern bool ShowRawInsn;
 extern bool SymbolDescription;
 extern bool SymbolTable;
 extern std::string TripleName;
 extern bool UnwindInfo;
+extern bool ExportUniqueSymbol;
 
 extern StringSet<> FoundSectionSet;
 
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
 
 /// A filtered iterator for SectionRefs that skips sections based on some given
 /// predicate.
 class SectionFilterIterator {

llvm/tools/llvm-objdump/llvm-objdump.cpp

 static bool SymbolizeOperands;
 static bool DynamicSymbolTable;
 std::string objdump::TripleName;
 bool objdump::UnwindInfo;
 static bool Wide;
 std::string objdump::Prefix;
 uint32_t objdump::PrefixStrip;
 
+bool objdump::ExportUniqueSymbol;
+
 DebugVarsFormat objdump::DbgVariables = DVDisabled;
 
 int objdump::DbgIndent = 52;
 
 static StringSet<> DisasmSymbolSet;
 StringSet<> objdump::FoundSectionSet;
 static StringRef ToolName;
 
static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
   if (Rebase)
     printRebaseTable(O);
   if (Bind)
     printBindTable(O);
   if (LazyBind)
     printLazyBindTable(O);
   if (WeakBind)
     printWeakBindTable(O);
-
   // Other special sections:
   if (RawClangAST)
     printRawClangAST(O);
   if (FaultMapSection)
     printFaultMaps(O);
 }
 
 static void dumpObject(const COFFImportFile *I, const Archive *A,
static void dumpInput(StringRef file) {
   // If we are using the Mach-O specific object file parser, then let it parse
   // the file and process the command line options.  So the -arch flags can
   // be used to select specific slices, etc.
   if (MachOOpt) {
     parseInputMachO(file);
     return;
   }
 
+  if (ExportUniqueSymbol) {
+    exportSymbolInfoFromFile(file);
+    printExportSymboList(outs());
+    return;
+  }
+
   // Attempt to open the binary.
   OwningBinary<Binary> OBinary = unwrapOrError(createBinary(file), file);
   Binary &Binary = *OBinary.getBinary();
 
   if (Archive *A = dyn_cast<Archive>(&Binary))
     dumpArchive(A);
   else if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary))
     dumpObject(O);
static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
   parseIntArg(InputArgs, OBJDUMP_stop_address_EQ, StopAddress);
   HasStopAddressFlag = InputArgs.hasArg(OBJDUMP_stop_address_EQ);
   SymbolTable = InputArgs.hasArg(OBJDUMP_syms);
   SymbolizeOperands = InputArgs.hasArg(OBJDUMP_symbolize_operands);
   DynamicSymbolTable = InputArgs.hasArg(OBJDUMP_dynamic_syms);
   TripleName = InputArgs.getLastArgValue(OBJDUMP_triple_EQ).str();
   UnwindInfo = InputArgs.hasArg(OBJDUMP_unwind_info);
   Wide = InputArgs.hasArg(OBJDUMP_wide);
+  ExportUniqueSymbol = InputArgs.hasArg(OBJDUMP_export_unique_symbol);
   Prefix = InputArgs.getLastArgValue(OBJDUMP_prefix).str();
   parseIntArg(InputArgs, OBJDUMP_prefix_strip, PrefixStrip);
   if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_debug_vars_EQ)) {
     DbgVariables = StringSwitch<DebugVarsFormat>(A->getValue())
                        .Case("ascii", DVASCII)
                        .Case("unicode", DVUnicode);
   }
   parseIntArg(InputArgs, OBJDUMP_debug_vars_indent_EQ, DbgIndent);
 
   parseMachOOptions(InputArgs);
+  parseXCOFFOptions(InputArgs);
 
   // Parse -M (--disassembler-options) and deprecated
   // --x86-asm-syntax={att,intel}.
   //
   // Note, for x86, the asm dialect (AssemblerDialect) is initialized when the
   // MCAsmInfo is constructed. MCInstPrinter::applyTargetSpecificCLOption is
   // called too late. For now we have to use the internal cl::opt option.
   const char *AsmSyntax = nullptr;
int main(int argc, char **argv) {
   if (DisassembleAll || PrintSource || PrintLines ||
       !DisassembleSymbols.empty())
     Disassemble = true;
 
   if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
       !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
       !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
       !DynamicSymbolTable && !UnwindInfo && !FaultMapSection &&
+      !ExportUniqueSymbol &&
       !(MachOOpt &&
         (Bind || DataInCode || DylibId || DylibsUsed || ExportsTrie ||
          FirstPrivateHeader || FunctionStarts || IndirectSymbols || InfoPlist ||
          LazyBind || LinkOptHints || ObjcMetaData || Rebase || Rpaths ||
          UniversalHeaders || WeakBind || !FilterSections.empty()))) {
     T->printHelp(ToolName);
     return 2;
   }