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/docs/CommandGuide/llvm-objdump.rst

.. option:: --universal-headers
 
   Display universal headers.
 
 .. option:: --weak-bind
 
   Display weak binding information.
 
 XCOFF ONLY OPTIONS AND COMMANDS
----------------------------------
+-------------------------------
 
 .. option:: --symbol-description
 
   Add symbol description to disassembly output.
 
+.. option:: --export-unique-symbol
+
+  Export symbol list for xcoff object file or archive. The option will suppress other options.
+
+.. option:: --exclude-weak
+
+  Exclude the weak symbol from export symbol list for xcoff files(requires --export-unique-symbol).
+
+.. option:: --exclude-rsrc
+
+  Exclude the rsrc symbol from export symbol list for xcoff files(requires --export-unique-symbol).  
+
+
 BUGS
 ----
 
 To report bugs, please visit <https://bugs.llvm.org/>.
 
 SEE ALSO
 --------
 
 :manpage:`llvm-nm(1)`, :manpage:`llvm-otool(1)`, :manpage:`llvm-readelf(1)`,
 :manpage:`llvm-readobj(1)`

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

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

llvm/lib/Object/XCOFFObjectFile.cpp

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));
 }

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/big-archive-libtest.a | FileCheck --check-prefixes=SYM %s
+
+; The archive file big-archive-libtest.a is created from test_xclang++.o and test1_gcc.o with command 
+; ar -v -q big-archive-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/tf-rsrc-gcc.o | FileCheck --check-prefixes=RSRC %s
+; RUN: llvm-objdump --export-unique-symbol --exclude-rsrc %p/Inputs/tf-rsrc-gcc.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/tf-rsrc-gcc.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: __rsrc 
+; TF1-NEXT: lue
+; TF1-NEXT: rc
+; TF1-NEXT: x
+
+; 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 xcoff (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;
   }