implement the --syms and using "symbol index and qualname" for --sym --symbol--description for llvm-objdump for xcoff

[DiggerLin]

Summary

for xcoff :

1. implement the getSymbolFlag and getSymbolType() for option --syms.
2. llvm-objdump --sym , if the symbol is label, print the containing section for the symbol too.
3. when using llvm-objdump --sym --symbol--description, print the symbol index and qualname for symbol.

for example:
--symbol-description
00000000000000c0 l .text (csect: (idx: 2) .foov[PR]) (idx: 3) .foov

and without --symbol-description
00000000000000c0 l .text (csect: .foov) .foov

[jhenderson]

I'd like other XCOFF people to look at this and decide if the output is a good style for them.

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

Please add a brief comment explaining what this test is intended to test.

Also, this test won't succeed if the appropriate target is not configured for the person running the test. You need a REQUIRES statement.

I don't know much about llc, but I suspect it's likely that, based purely on the name, the -verify-machineinstrs option isn't needed?

3

When continuing run lines onto the next one, add spacing after the RUN: on the subsequent lines to indent the arguments a bit. This helps readability by tying it to the previous line.

28–29

Should there be a space after the first .text on each of these lines, before the parenthesis?

llvm/tools/llvm-objdump/XCOFFDump.cpp

69

Don't use auto if the type isn't clear (i.e. it isn't mentioned on the line already, in e.g. a cast or constructor). See the style guide.

72

It seems that if a case is necessary here, there's a problem with the function you're calling. At a guess, it should just be two functions, one returning a section, the other an index, with errors or assertions reported if using the wrong one for the type.

If a case is really necessary, use static_cast.

llvm/tools/llvm-objdump/XCOFFDump.h

25

This is a problem throughout this header file (and its cpp) already, so please make a small commit to fix it: SymbolRef is designed to be a lightweight struct and passed by value, not by reference (just like StringRef).

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

2066

2124–2129

2127

Seems to me like you're changing the name to add the description. But then the variable is no longer just the name, which could cause issues in the future.

How about you just print the name before this check, then print the description (inside the if), and finally the new line?

[hubert.reinterpretcast]

In D109452#2991032, @jhenderson wrote:

I'd like other XCOFF people to look at this and decide if the output is a good style for them.

Generally, yes. Having the containing csect information with the section information prevents confusion for developers making used of the GNU __section__ attribute in C/C++. The ability to differentiate symbols with the same "unqualified" name by means of adding the storage mapping class qualification in the style of the assembly syntax is also very helpful. Lastly, the index information is useful for cross-referencing purposes.

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

37

In keeping with "idx" being not capitalized, "csect" should not be either. Note also that the style used for prose text in the IBM documentation has the capitalized form of "csect" as "CSECT".

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

2056

The containing csect presents as an annotation "within" the section field. It may be friendlier if the delimiters of the section field were more explicit:

00000000000000c0 l [.text (csect: (idx: 2) .foov[PR])] (idx: 3) .foov

and without --symbol-description

00000000000000c0 l [.text (csect: .foov)] .foov

2073–2074

@DiggerLin, at least some XCOFF symbols have size fields. This could be handled in a separate patch if that is your preference (in which case, please add a TODO comment to the code).

@jhenderson, at least for XCOFF, I would prefer to always have the field (even if empty). I am not convinced that having it present only for "common" symbols for non-ELF formats is good.

2127

Maybe if the index was not prefixed, that would work: .foov[PR](idx: 3). --symbol-description already presents with the current ordering in conjunction with, e.g., -Dr.

[jhenderson]

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

2073–2074

At least for ELF format, we are tied by the need to match GNU objdump output as closely as practical. I've no issue it being different for other formats that don't have a GNU objdump implementation they are trying to mirror.

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

72

there is a description in the XCOFFObjectFile.h

// For getSectionOrLength(),
// If the symbol type is XTY_SD or XTY_CM, the csect length.
// If the symbol type is XTY_LD, the symbol table
// index of the containing csect.
// If the symbol type is XTY_ER, 0.
uint64_t getSectionOrLength() const {
  return Entry32 ? getSectionOrLength32() : getSectionOrLength64();
}

for the number of symbols in aix xcoff object file should not large than the max of uint32_t. so cast to unit32_t is safe.

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

2056

thanks

2066

thanks

2073–2074

@hubert.reinterpretcast , the size we mention here is section size?
in the https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format

XTY_SD x_scnlen contains the csect length.
XTY_CM x_scnlen contains the csect length.

so we want to display the size of the symbols of the XTY_SD symbols and XTY_CM symbols or only XTY_CM symbols?

2124–2129

thanks

[hubert.reinterpretcast]

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

2073–2074

For ELF, the common symbols are displayed with the alignment and the other symbols are displayed with the size. We could do the same as ELF (except sometimes we don't have a size or alignment).

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

llc is cross compile, I think llc can compiler success in other platform , we do not need REQUIRES.

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

2073–2074

for the "char c" in global variable, in the common, the x_scnlen of csect auxiliary symbol entry is 1, but the alignment will be 4, so we will show 4 bytes?

[hubert.reinterpretcast]

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

2073–2074

Just because the alignment given by the various compilers is surprising doesn't mean that we should avoid indicating the alignment.

[jhenderson]

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

llc may be able to cross compile, but it requires to be built with the specified target enabled in LLVM_TARGETS_TO_BUILD, otherwise it doesn't know how to generate the machine code for the appropriate target.

Try regenerating your LLVM build tree with LLVM_TARGETS_TO_BUILD=X86 (and nothing else), and I bet you this test will fail, due to llc not knowing about the powerpc target in this case. You need the REQUIRES.

Also, don't forget my other comments in this test.

3

This is marked as done, but has not been fixed. Please don't mark items as done until you upload a patch that addresses them. Same goes throughout.

llvm/tools/llvm-objdump/XCOFFDump.cpp

72

If I hand-edited (or crafted with yaml2obj) an object file, could I end up with an invalid index that is larger than uint32_t, or is the field size only uint32_t?

Regardless, just because it's safe doesn't mean you need to do it. As far as I can tell, you could change getSymbolByIndex to take a uint64_t without impact, and you wouldn't need the cast.

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

there is a file

llvm/test/tools/llvm-objdump/XCOFF/lit.local.cfg

which has following content

if not 'PowerPC' in config.root.targets:

config.unsupported = True

it protect the test case in the llvm/test/tools/llvm-objdump/XCOFF not run for no PowerPC.

llvm/tools/llvm-objdump/XCOFFDump.cpp

72

the field size only uint32_t

there is
support::ubig32_t NumberOfSymTableEntries;
in both "struct XCOFFFileHeader64" and "struct XCOFFFileHeader32"

if the hand-edited (or crafted with yaml2obj) an object file , the high order of 32bit will be ignored.

llvm/tools/llvm-objdump/XCOFFDump.h

25

I think we should make a separate patch do deal the problem after the patch upload.

[DiggerLin]

address comment and implement function getSymbolFlag() and getSymbolType() ,getSymbolAlignment() etc

[jhenderson]

This patch seems to have gained a lot of functionality that sounds like it belongs in separate patches? The patch description and summary talk about reporting the symbol index, the qualname, and the symbol section. Other fields should be done in another patch, I'd think. There's no need for a single patch to implement all necessary functionality needed for complete symbol table printing.

llvm/lib/Object/XCOFFObjectFile.cpp

230

consumeError is often a code smell. You should either 1) use cantFail instead, 2) add a TODO comment saying to report the message up the stack, 3) report the error somehow, or 4) add a comment explaining why the consumeError is justified here (e.g. "we don't care about invalid files for this purpose"). I suspect at this time 2) is the appropriate response.

Same comment applies for the other consumeError instances.

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

Thanks. Didn't realise that.

2

We usually describe what the test does (and why where necessary - not applicable here) not what the test is: all the files in this directory are for testing llvm-objdump, so the comment can be simplified somewhat.

8

llvm/tools/llvm-objdump/XCOFFDump.cpp

72

Thanks. Please clang-format.

llvm/tools/llvm-objdump/XCOFFDump.h

25

I'm happy as long as it gets down.

[DiggerLin]

In D109452#3003268, @jhenderson wrote:

This patch seems to have gained a lot of functionality that sounds like it belongs in separate patches? The patch description and summary talk about reporting the symbol index, the qualname, and the symbol section. Other fields should be done in another patch, I'd think. There's no need for a single patch to implement all necessary functionality needed for complete symbol table printing.

yes, this is a big patch. Since I have implemented all the functionality in one patch, I do not think it is a good ideal to separate the patch to two patches now. I changed the title of the patch and the summary of the patch as your suggestion. thanks.

llvm/lib/Object/XCOFFObjectFile.cpp

230

thanks

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

2

thanks

8

thanks

llvm/tools/llvm-objdump/XCOFFDump.h

25

thanks

[jhenderson]

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

3

Sorry, should have said this before.

112

Nit, don't have a completely empty blank line like this here (do keep the single '\n' at the end of the last line with text to avoid the "no new line at end of file" note).

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

3

thanks

112

thanks

[jhenderson]

Some mostly stylistic comments. Beyond that, I've got not much else to add. @hubert.reinterpretcast will need to review the actual XCOFF implementation and corresponding code coverage.

llvm/lib/Object/XCOFFObjectFile.cpp

280

"considerated" isn't a word. I assume you mean "considered", but I think "treated" would be better. Same applies before.

284

803

consumeError usage needs explanation/TODO etc, as before.

llvm/test/tools/llvm-objdump/XCOFF/print-linenumber.test

21

Mildly surprising there's a test change here. Why is there this change?

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

2042

1. Be consistent in your capitalization.
2. If an abbreviation is needed, "Sym" is the usual abbreviation, not "Symb".

Consequently, I'd rename this variable "XCOFFSym" or, if possible "XCOFFSymbol", depending on whether the latter clashes with a type somewhere or not.

2062–2063

This will result in a hard error, and stopping of any further dumping of the file, if there's a problem getting the name. It seems to me like this should actually be reported as a warning, and just keep going, using some placeholder string instead (e.g. "<?>") for the invalid name.

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

284

thanks

803

thanks

llvm/test/tools/llvm-objdump/XCOFF/print-linenumber.test

21

for we implement the getSymbolFlag() and getSymbolType() in the patch. after implement the getSymbolType() , the symbol ".main" is marked as function (it is correct to mark .main as function, the symbol "main" is function description in aix). so the here change to .main(), @Esme , can you help to confirm it ?

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

2042

thanks

2062–2063

I think we need to deal with the error as same as section name in the code

"

  if (!SegmentName.empty())
    outs() << SegmentName << ",";
  StringRef SectionName = unwrapOrError(Section->getName(), FileName);
  outs() << SectionName;
}

"

[jhenderson]

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

2042

Please make the same change throughout your changed code (there are several other places with the old variable name).

2062–2063

I'd suggest the SectionName is in a similar boat - a failure there shouldn't prevent dumping the rest, and should instead probably be printed as a warning. You could do something similar to what I've suggested for the symbol. You can change the section name error handling in a different patch.

[DiggerLin]

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

2042

done, thanks

[jhenderson]

I've got nothing else to add at this point. It needs an XCOFF developer to review the functional behaviour for correctness.

[Esme]

LGTM. Thanks for doing this.

llvm/test/tools/llvm-objdump/XCOFF/print-linenumber.test

21

Yes, I think the change is reasonable.
I'm trying to figure out why the output function name changed. By tracing the output of line ;.main():, I found that after applying this patch, we override the default LineInfo.FunctionName with the name from symbol table (see function SymbolizableObjectFile::symbolizeCode() ). And I believe it was correct to do so.

llvm/include/llvm/Object/XCOFFObjectFile.h

public:
   void moveSymbolNext(DataRefImpl &Symb) const override;
   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
 
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
+  uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
public:
 
   uint32_t getNumberOfSymbolTableEntries64() const;
 
   // Return getLogicalNumberOfSymbolTableEntries32 or
   // getNumberOfSymbolTableEntries64 depending on the object mode.
   uint32_t getNumberOfSymbolTableEntries() const;
 
   uint32_t getSymbolIndex(uintptr_t SymEntPtr) const;
+  uint64_t getSymbolSize(DataRefImpl Symb) const;
+  uintptr_t getSymbolByIndex(uint32_t Idx) const {
+    return reinterpret_cast<uintptr_t>(SymbolTblPtr) +
+           XCOFF::SymbolTableEntrySize * Idx;
+  }
   uintptr_t getSymbolEntryAddressByIndex(uint32_t SymbolTableIndex) const;
   Expected<StringRef> getSymbolNameByIndex(uint32_t SymbolTableIndex) const;
 
   Expected<StringRef> getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const;
   uint16_t getOptionalHeaderSize() const;
   uint16_t getFlags() const;
 
   // Section header table related interfaces.

llvm/lib/Object/XCOFFObjectFile.cpp

 Expected<uint64_t> XCOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   return toSymbolRef(Symb).getValue();
 }
 
 uint64_t XCOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   return toSymbolRef(Symb).getValue();
 }
 
+uint32_t XCOFFObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
+  uint64_t Result = 0;
+  XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
+  if (XCOFFSym.isCsectSymbol()) {
+    Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
+        XCOFFSym.getXCOFFCsectAuxRef();
+    if (!CsectAuxRefOrError)
+      // TODO: report the error up the stack.
+      consumeError(CsectAuxRefOrError.takeError());
+    else
+      Result = 1 << CsectAuxRefOrError.get().getAlignmentLog2();
+  }
+  return Result;
+}
+
 uint64_t XCOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
   uint64_t Result = 0;
-  llvm_unreachable("Not yet implemented!");
+  XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
+  if (XCOFFSym.isCsectSymbol()) {
+    Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
+        XCOFFSym.getXCOFFCsectAuxRef();
+    if (!CsectAuxRefOrError)
+      // TODO: report the error up the stack.
+      consumeError(CsectAuxRefOrError.takeError());
+    else {
+      XCOFFCsectAuxRef CsectAuxRef = CsectAuxRefOrError.get();
+      assert(CsectAuxRef.getSymbolType() == XCOFF::XTY_CM);
+      Result = CsectAuxRef.getSectionOrLength();
+    }
+  }
   return Result;
 }
 
 Expected<SymbolRef::Type>
 XCOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
-  // TODO: Return the correct symbol type.
+  XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
+
+  if (XCOFFSym.isFunction())
+    return SymbolRef::ST_Function;
+
+  if (XCOFF::C_FILE == XCOFFSym.getStorageClass())
+    return SymbolRef::ST_File;
+
+  int16_t SecNum = XCOFFSym.getSectionNumber();
+  if (SecNum <= 0)
+    return SymbolRef::ST_Other;
+
+  Expected<DataRefImpl> SecDRIOrErr =
+      getSectionByNum(XCOFFSym.getSectionNumber());
+
+  if (!SecDRIOrErr)
+    return SecDRIOrErr.takeError();
+
+  DataRefImpl SecDRI = SecDRIOrErr.get();
+
+  Expected<StringRef> SymNameOrError = XCOFFSym.getName();
+  if (SymNameOrError) {
+    // The "TOC" symbol is treated as SymbolRef::ST_Other.
+    if (SymNameOrError.get() == "TOC")
+      return SymbolRef::ST_Other;
+
+    // The symbol for a section name is treated as SymbolRef::ST_Other.
+    StringRef SecName;
+    if (is64Bit())
+      SecName = XCOFFObjectFile::toSection64(SecDRIOrErr.get())->getName();
+    else
+      SecName = XCOFFObjectFile::toSection32(SecDRIOrErr.get())->getName();
+
+    if (SecName == SymNameOrError.get())
+      return SymbolRef::ST_Other;
+  } else
+    return SymNameOrError.takeError();
+
+  if (isSectionData(SecDRI) || isSectionBSS(SecDRI))
+    return SymbolRef::ST_Data;
+
+  if (isDebugSection(SecDRI))
+    return SymbolRef::ST_Debug;
+
   return SymbolRef::ST_Other;
 }
 
 Expected<section_iterator>
 XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
   const int16_t SectNum = toSymbolRef(Symb).getSectionNumber();
 
   if (isReservedSectionNumber(SectNum))
void XCOFFObjectFile::getRelocationTypeName(
   } else {
     const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
     Res = XCOFF::getRelocationTypeString(Reloc->Type);
   }
   Result.append(Res.begin(), Res.end());
 }
 
 Expected<uint32_t> XCOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
-  uint32_t Result = 0;
-  // TODO: Return correct symbol flags.
+  XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
+  uint32_t Result = SymbolRef::SF_None;
+
+  if (XCOFFSym.getSectionNumber() == XCOFF::N_ABS)
+    Result |= SymbolRef::SF_Absolute;
+
+  XCOFF::StorageClass SC = XCOFFSym.getStorageClass();
+  if (XCOFF::C_EXT == SC || XCOFF::C_WEAKEXT == SC)
+    Result |= SymbolRef::SF_Global;
+
+  if (XCOFF::C_WEAKEXT == SC)
+    Result |= SymbolRef::SF_Weak;
+
+  if (XCOFFSym.isCsectSymbol()) {
+    Expected<XCOFFCsectAuxRef> CsectAuxEntOrErr =
+        XCOFFSym.getXCOFFCsectAuxRef();
+    if (CsectAuxEntOrErr) {
+      if (CsectAuxEntOrErr.get().getSymbolType() == XCOFF::XTY_CM)
+        Result |= SymbolRef::SF_Common;
+    } else
+      return CsectAuxEntOrErr.takeError();
+  }
+
+  if (XCOFFSym.getSectionNumber() == XCOFF::N_UNDEF)
+    Result |= SymbolRef::SF_Undefined;
+
   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));
 }

 }
 
 uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr) const {
   return (reinterpret_cast<const char *>(SymbolEntPtr) -
           reinterpret_cast<const char *>(SymbolTblPtr)) /
          XCOFF::SymbolTableEntrySize;
 }
 
+uint64_t XCOFFObjectFile::getSymbolSize(DataRefImpl Symb) const {
+  uint64_t Result = 0;
+  XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
+  if (XCOFFSym.isCsectSymbol()) {
+    Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
+        XCOFFSym.getXCOFFCsectAuxRef();
+    if (!CsectAuxRefOrError)
+      // TODO: report the error up the stack.
+      consumeError(CsectAuxRefOrError.takeError());
+    else {
+      XCOFFCsectAuxRef CsectAuxRef = CsectAuxRefOrError.get();
+      uint8_t SymType = CsectAuxRef.getSymbolType();
+      if (SymType == XCOFF::XTY_SD || SymType == XCOFF::XTY_CM)
+        Result = CsectAuxRef.getSectionOrLength();
+    }
+  }
+  return Result;
+}
+
 uintptr_t XCOFFObjectFile::getSymbolEntryAddressByIndex(uint32_t Index) const {
   return getAdvancedSymbolEntryAddress(
       reinterpret_cast<uintptr_t>(getPointerToSymbolTable()), Index);
 }
 
 Expected<StringRef>
 XCOFFObjectFile::getSymbolNameByIndex(uint32_t Index) const {
   const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();

llvm/test/tools/llvm-objdump/XCOFF/print-linenumber.test

 ## int main(void)
 ## {
 ##   return 0;
 ## }
 
 # LINES32:       Inputs/basic32.o:  file format aixcoff-rs6000
 # LINES32:       Disassembly of section .text:
 # LINES32:       00000000 <.text>:
-# LINES32:       ; main():
+# LINES32:       ; .main():
 # LINES32-NEXT:  ; /basic.c:1
 # LINES32-NEXT:         0: 38 60 00 00    li 3, 0
 # LINES32-NEXT:  ; /basic.c:3
 # LINES32-NEXT:         4: 48 00 00 04    b 0x8
 # LINES32-NEXT:  ; /basic.c:4
 # LINES32-NEXT:         8: 4e 80 00 20    blr
 # LINES32-NEXT:         c: 00 00 00 00    <unknown>
 # LINES32-NEXT:        10: 00 00 20 40    <unknown>
 # LINES32-NEXT:        14: 00 00 00 01    <unknown>
 # LINES32-NEXT:        18: 00 00 00 0c    <unknown>
 # LINES32-NEXT:        1c: 00 04 6d 61    <unknown>
 # LINES32-NEXT:        20: 69 6e 00 00    xori 14, 11, 0
 
 # LINES64:       Inputs/basic64.o:  file format aix5coff64-rs6000
 # LINES64:       Disassembly of section .text:
 # LINES64:       0000000000000000 <.main>:
-# LINES64:       ; main():
+# LINES64:       ; .main():
 # LINES64-NEXT:  ; /basic.c:1
 # LINES64-NEXT:         0: 38 60 00 00    li 3, 0
 # LINES64-NEXT:  ; /basic.c:3
 # LINES64-NEXT:         4: 48 00 00 04    b 0x8
 # LINES64-NEXT:  ; /basic.c:4
 # LINES64-NEXT:         8: 4e 80 00 20    blr
 # LINES64-NEXT:         c: 00 00 00 00    <unknown>
 # LINES64-NEXT:        10: 00 00 20 40    <unknown>
 # LINES64-NEXT:        14: 00 00 00 01    <unknown>
 # LINES64-NEXT:        18: 00 00 00 0c    <unknown>
 # LINES64-NEXT:        1c: 00 04 6d 61    <unknown>
 # LINES64-NEXT:        20: 69 6e 00 00    xori 14, 11, 0

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

+; Test the --syms option for xcoff object files. 
+; Also test the --symbol-description option for xcoff object files, when specified with --syms. 
+; RUN: llc -mtriple powerpc-ibm-aix -mcpu=pwr4 -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump --syms %t.o | FileCheck --check-prefix=SYM %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=SYM-DES %s
+
+;; The IR below is generated by the following source code.
+;; bash> cat test.c
+;; const char* con= "Test for --symbols";
+;;  int i;
+;;  char c ;
+;;  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);
+;; }
+;;
+;; __attribute__ ((weak)) int wi=2;
+
+
+@.str = private unnamed_addr constant [19 x i8] c"Test for --symbols\00", align 1
+@con = global i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), align 4
+@si = internal global i32 0, align 4
+@ei = external global i32, align 4
+@wi = weak global i32 2, align 4
+@i = global i32 0, align 4
+@c = global i8 0, align 1
+@ap = global i8* null, align 4
+@f = global float 0.000000e+00, align 4
+@ll = global i64 0, align 8
+
+define i32 @bar(i8* %v)  {
+entry:
+  %v.addr = alloca i8*, align 4
+  store i8* %v, i8** %v.addr, align 4
+  store i32 1, i32* @si, align 4
+  %0 = load i8*, i8** %v.addr, align 4
+  %arrayidx = getelementptr inbounds i8, i8* %0, i32 0
+  %1 = load i8, i8* %arrayidx, align 1
+  %conv = zext i8 %1 to i32
+  %2 = load i8*, i8** %v.addr, align 4
+  %arrayidx1 = getelementptr inbounds i8, i8* %2, i32 2
+  %3 = load i8, i8* %arrayidx1, align 1
+  %conv2 = zext i8 %3 to i32
+  %add = add nsw i32 %conv, %conv2
+  %4 = load i32, i32* @si, align 4
+  %add3 = add nsw i32 %add, %4
+  %5 = load i32, i32* @ei, align 4
+  %add4 = add nsw i32 %add3, %5
+  ret i32 %add4
+}
+
+define void @foo()  {
+entry:
+  %0 = load i8*, i8** @con, align 4
+  %call = call i32 @bar(i8* %0)
+  ret void
+}
+
+; SYM:      SYMBOL TABLE:
+; SYM-NEXT: 00000000      df *DEBUG*    00000000 .file
+; SYM-NEXT: 00000000         *UND*      00000000 ei
+; SYM-NEXT: 00000000 l       .text      00000091 .text
+; SYM-NEXT: 00000000 g     F .text (csect: .text)       00000000 .bar
+; SYM-NEXT: 00000050 g     F .text (csect: .text)       00000000 .foo
+; SYM-NEXT: 00000094 l       .text      00000013 .rodata.str1.1L...str
+; SYM-NEXT: 000000a8 g     O .data      00000004 con
+; SYM-NEXT: 000000ac  w    O .data      00000004 wi
+; SYM-NEXT: 000000b0 g     O .data      00000004 i
+; SYM-NEXT: 000000b4 g     O .data      00000001 c
+; SYM-NEXT: 000000b8 g     O .data      00000004 ap
+; SYM-NEXT: 000000bc g     O .data      00000004 f
+; SYM-NEXT: 000000c0 g     O .data      00000008 ll
+; SYM-NEXT: 000000c8 g     O .data      0000000c bar
+; SYM-NEXT: 000000d4 g     O .data      0000000c foo
+; SYM-NEXT: 000000e0 l       .data      00000000 TOC
+; SYM-NEXT: 000000e0 l     O .data      00000004 si
+; SYM-NEXT: 000000e4 l     O .data      00000004 ei
+; SYM-NEXT: 000000e8 l     O .data      00000004 con
+; SYM-NEXT: 000000ec l     O *COM*      00000004 si
+
+; SYM-DES:      SYMBOL TABLE:
+; SYM-DES-NEXT: 00000000      df *DEBUG*    00000000 (idx: 0) .file
+; SYM-DES-NEXT: 00000000         *UND*      00000000 (idx: 1) ei[UA]
+; SYM-DES-NEXT: 00000000 l       .text      00000091 (idx: 3) .text[PR]
+; SYM-DES-NEXT: 00000000 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 5) .bar
+; SYM-DES-NEXT: 00000050 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 7) .foo
+; SYM-DES-NEXT: 00000094 l       .text      00000013 (idx: 9) .rodata.str1.1L...str[RO]
+; SYM-DES-NEXT: 000000a8 g     O .data      00000004 (idx: 11) con[RW]
+; SYM-DES-NEXT: 000000ac  w    O .data      00000004 (idx: 13) wi[RW]
+; SYM-DES-NEXT: 000000b0 g     O .data      00000004 (idx: 15) i[RW]
+; SYM-DES-NEXT: 000000b4 g     O .data      00000001 (idx: 17) c[RW]
+; SYM-DES-NEXT: 000000b8 g     O .data      00000004 (idx: 19) ap[RW]
+; SYM-DES-NEXT: 000000bc g     O .data      00000004 (idx: 21) f[RW]
+; SYM-DES-NEXT: 000000c0 g     O .data      00000008 (idx: 23) ll[RW]
+; SYM-DES-NEXT: 000000c8 g     O .data      0000000c (idx: 25) bar[DS]
+; SYM-DES-NEXT: 000000d4 g     O .data      0000000c (idx: 27) foo[DS]
+; SYM-DES-NEXT: 000000e0 l       .data      00000000 (idx: 29) TOC[TC0]
+; SYM-DES-NEXT: 000000e0 l     O .data      00000004 (idx: 31) si[TC]
+; SYM-DES-NEXT: 000000e4 l     O .data      00000004 (idx: 33) ei[TC]
+; SYM-DES-NEXT: 000000e8 l     O .data      00000004 (idx: 35) con[TC]
+; SYM-DES-NEXT: 000000ec l     O *COM*      00000004 (idx: 37) si[BS]

llvm/tools/llvm-objdump/XCOFFDump.h

 
 struct SymbolInfoTy;
 
 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);
 } // namespace objdump
 } // namespace llvm
 #endif

llvm/tools/llvm-objdump/XCOFFDump.cpp

objdump::getXCOFFSymbolCsectSMC(const XCOFFObjectFile *Obj,
 
   auto CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef();
   if (!CsectAuxEntOrErr)
     return None;
 
   return CsectAuxEntOrErr.get().getStorageMappingClass();
 }
 
+Optional<object::SymbolRef>
+objdump::getXCOFFSymbolContainingSymbolRef(const XCOFFObjectFile *Obj,
+                                           const SymbolRef &Sym) {
+
+  const XCOFFSymbolRef SymRef = Obj->toSymbolRef(Sym.getRawDataRefImpl());
+  if (!SymRef.isCsectSymbol())
+    return None;
+
+  Expected<XCOFFCsectAuxRef> CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef();
+  if (!CsectAuxEntOrErr || !CsectAuxEntOrErr.get().isLabel())
+    return None;
+  uint32_t Idx =
+      static_cast<uint32_t>(CsectAuxEntOrErr.get().getSectionOrLength());
+  DataRefImpl DRI;
+  DRI.p = Obj->getSymbolByIndex(Idx);
+  return SymbolRef(DRI, Obj);
+}
+
 bool objdump::isLabel(const XCOFFObjectFile *Obj, const SymbolRef &Sym) {
 
   const XCOFFSymbolRef SymRef = Obj->toSymbolRef(Sym.getRawDataRefImpl());
 
   if (!SymRef.isCsectSymbol())
     return false;
 
   auto CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef();

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

outs() << format(Fmt, Address) << " "
          << Debug              // Debugging (d) or dynamic (D) symbol.
          << FileFunc           // Name of function (F), file (f) or object (O).
          << ' ';
   if (Absolute) {
     outs() << "*ABS*";
   } else if (Common) {
     outs() << "*COM*";
   } else if (Section == O->section_end()) {
+    if (O->isXCOFF()) {
+      XCOFFSymbolRef XCOFFSym = dyn_cast<const XCOFFObjectFile>(O)->toSymbolRef(
+          Symbol.getRawDataRefImpl());
+      if (XCOFF::N_DEBUG == XCOFFSym.getSectionNumber())
+        outs() << "*DEBUG*";
+      else
+        outs() << "*UND*";
+    } else
       outs() << "*UND*";
   } else {
     StringRef SegmentName = getSegmentName(MachO, *Section);
     if (!SegmentName.empty())
       outs() << SegmentName << ",";
     StringRef SectionName = unwrapOrError(Section->getName(), FileName);
     outs() << SectionName;
-  }
+    if (O->isXCOFF()) {
+      Optional<SymbolRef> SymRef = getXCOFFSymbolContainingSymbolRef(
+          dyn_cast<const XCOFFObjectFile>(O), Symbol);
+      if (SymRef) {
+
+        Expected<StringRef> NameOrErr = SymRef.getValue().getName();
+
+        if (NameOrErr) {
+          outs() << " (csect:";
+          std::string SymName(NameOrErr.get());
 
-  if (Common || O->isELF()) {
-    uint64_t Val =
-        Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
-    outs() << '\t' << format(Fmt, Val);
+          if (Demangle)
+            SymName = demangle(SymName);
+
+          if (SymbolDescription)
+            SymName = getXCOFFSymbolDescription(
+                createSymbolInfo(O, SymRef.getValue()), SymName);
+
+          outs() << ' ' << SymName;
+          outs() << ") ";
+        } else
+          reportWarning(toString(NameOrErr.takeError()), FileName);
+      }
     }
+  }
+
+  if (Common)
+    outs() << '\t' << format(Fmt, Symbol.getAlignment());
+  else if (O->isXCOFF())
+    outs() << '\t'
+           << format(Fmt, dyn_cast<const XCOFFObjectFile>(O)->getSymbolSize(
+                              Symbol.getRawDataRefImpl()));
+  else if (O->isELF())
+    outs() << '\t' << format(Fmt, ELFSymbolRef(Symbol).getSize());
 
   if (O->isELF()) {
     if (!SymbolVersions.empty()) {
       const VersionEntry &Ver =
           SymbolVersions[Symbol.getRawDataRefImpl().d.b - 1];
       std::string Str;
       if (!Ver.Name.empty())
         Str = Ver.IsVerDef ? ' ' + Ver.Name : '(' + Ver.Name + ')';
if (O->isELF()) {
     default:
       outs() << format(" 0x%02x", Other);
       break;
     }
   } else if (Hidden) {
     outs() << " .hidden";
   }
 
+  std::string SymName(Name);
   if (Demangle)
-    outs() << ' ' << demangle(std::string(Name)) << '\n';
-  else
-    outs() << ' ' << Name << '\n';
+    SymName = demangle(SymName);
+
+  if (O->isXCOFF() && SymbolDescription)
+    SymName = getXCOFFSymbolDescription(createSymbolInfo(O, Symbol), SymName);
+
+  outs() << ' ' << SymName << '\n';
 }
 
 static void printUnwindInfo(const ObjectFile *O) {
   outs() << "Unwind info:\n\n";
 
   if (const COFFObjectFile *Coff = dyn_cast<COFFObjectFile>(O))
     printCOFFUnwindInfo(Coff);
   else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O))