Implement -frecord-command-line for XCOFF integrated assembler path

[Jake-Egan]

Summary

The patch D153600 implemented -frecord-command-line for the XCOFF direct assembly path. This patch adds support for the XCOFF integrated assembly path.

[Jake-Egan]

Fix endianness of the padding.

[Jake-Egan]

Remove old comment

[scott.linder]

Thank you for the patch!

Again, I'm not a COFF expert, so I only really reviewed the code itself, not how it implements the (X)COFF format

I think some of my comments are really just extensions of my confusion/disagreement with the style of the whole translation unit, but "leave things better than you found them" and all

llvm/include/llvm/MC/MCObjectWriter.h

114

In some places this is called Data, in others Metadata; if there is no underlying reason I'm missing can they all be switched to one or the other?

llvm/lib/MC/XCOFFObjectWriter.cpp

259–260

It seems like the StringRef member is redundant; every use can just be of the std::string version. Constructing transient StringRefs where needed doesn't seem expensive enough to warrant caching it in this way, as it adds code complexity and bloats the struct at runtime somewhat. If you are OK with the larger struct you could also consider caching the values for paddingSize and size directly instead.

If you just want to avoid the potentially costly/inconsistent implementation of std::string methods then SmallString<0> is a better alternative

280

formatting

628–631

The direct access to Entry here combined with the abstracted check for hasCInfoSymSection feels awkward

If the section supports multiple entries I would suggest just embracing that and making the interface be an iterator or a collection. It doesn't seem like more work to support, considering a SmallVector<..., 1> should already implement everything. If the extra size in the case where no entry is present is a concern then a SmallVector<..., 0> would also work.

If you would rather not support multiple entries because there is no use-case for it yet and you don't want to test for the support, then I'd suggest just dropping the hasCInfoSymSection check in favor of directly checking the Entry member. Adding the partial abstraction just makes the result more complicated

1240–1274

This code is repeated in nearly identical form for every derivation of SectionEntry here; can it be made into a method on SectionEntry that is called here for each? Some of this can go in an NFC patch preceding this one

1322–1332

Is there a rationale for not making this a constructor? It is nice to have the name of the fields, but it is more verbose and means at least one extra move is possible in C++17 where CInfoSymSection.Entry = std::make_unique... is guaranteed to be in-place constructed IIUC.

And it seems like setting the entry without updating the section's size is never meaningful, so I would also suggest adding a method called setEntry or similar. I'm curious why the general style in this file seems to be to use struct for everything, and so hide nothing.

Overall I think my complaints center around places where verbosity is spread around and there is no single point where invariants are maintained

1608

StringRef is intended to be used by-value almost everywhere, see the last sentence in https://www.llvm.org/docs/ProgrammersManual.html#the-stringref-class

If you do want the lvalue reference here, it should at least be const qualified

[Jake-Egan]

Addressed comments

[Jake-Egan]

llvm/lib/MC/XCOFFObjectWriter.cpp

628–631

I went with checking the Entry member directly. Multiple entries can be supported if/when more use cases for the .info section is added.

1240–1274

I posted a patch for this here https://reviews.llvm.org/D155199

[Jake-Egan]

llvm/lib/MC/XCOFFObjectWriter.cpp

280

Do you mean that CInfoSymSectionEntry(StringRef N, int32_t Flags) : SectionEntry(N, Flags){}; should be split into two lines? It seems git-clang-format wants it on one line.

[scott.linder]

Thank you for making the changes!

One small nit: I prefer using the implicit conversion to bool rather than explicitly checking for nullptr

llvm/lib/MC/XCOFFObjectWriter.cpp

280

Ah, my eyes just kind of glazed over the ;, which is what seems to be causing clang-format to delete the space between the closing parens and the {. Sorry for the confusion!

I didn't realize it was even legal in this case (i.e. a semicolon after a method/constructor definition, not just a declaration), but it seems to just be an optional part of the grammar.

I'd suggest deleting the ; and re-running clang-format, but I don't actually know that there is any policy on it

628–630

1057

1115

1241

1323

1340

1603

[Jake-Egan]

Update patch

[stephenpeckham]

I reviewed this code with respect to XCOFF and I don't see any issues. As intended, this code only supports a single C_INFO symbol in the object file.

[scott.linder]

LGTM, thank you for the revisions!

[Jake-Egan]

Thanks for the reviews. Just made some small changes:

• Changed the write order of the info section to match XCOFF convention
• Use advanceFileOffset now that it has landed

llvm/include/llvm/MC/MCObjectWriter.h

public:
 
   std::vector<const MCSymbol *> &getAddrsigSyms() { return AddrsigSyms; }
 
   virtual void addExceptionEntry(const MCSymbol *Symbol, const MCSymbol *Trap,
                                  unsigned LanguageCode, unsigned ReasonCode,
                                  unsigned FunctionSize, bool hasDebug) {
     report_fatal_error("addExceptionEntry is only supported on XCOFF targets");
   }
+  virtual void addCInfoSymEntry(StringRef Name, StringRef Metadata) {
+    report_fatal_error("addCInfoSymEntry is only supported on XCOFF targets");
+  }
   /// Write the object file and returns the number of bytes written.
   ///
   /// This routine is called by the assembler after layout and relaxation is
   /// complete, fixups have been evaluated and applied, and relocations
   /// generated.
   virtual uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
 
   /// @}

llvm/include/llvm/MC/MCXCOFFStreamer.h

public:
   void emitXCOFFRenameDirective(const MCSymbol *Name,
                                 StringRef Rename) override {
     report_fatal_error("emitXCOFFRenameDirective is not implemented yet on "
                        "object generation path");
   }
   void emitXCOFFExceptDirective(const MCSymbol *Symbol, const MCSymbol *Trap,
                                 unsigned Lang, unsigned Reason,
                                 unsigned FunctionSize, bool hasDebug) override;
-  void emitXCOFFCInfoSym(StringRef Name, StringRef Metadata) override {
-    report_fatal_error("emitXCOFFCInfoSym is not implemented yet on "
-                       "object generation path");
-  }
+  void emitXCOFFCInfoSym(StringRef Name, StringRef Metadata) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCXCOFFSTREAMER_H

llvm/lib/MC/MCXCOFFStreamer.cpp

void MCXCOFFStreamer::emitXCOFFExceptDirective(const MCSymbol *Symbol,
                                                const MCSymbol *Trap,
                                                unsigned Lang, unsigned Reason,
                                                unsigned FunctionSize,
                                                bool hasDebug) {
   getAssembler().getWriter().addExceptionEntry(Symbol, Trap, Lang, Reason,
                                                FunctionSize, hasDebug);
 }
 
+void MCXCOFFStreamer::emitXCOFFCInfoSym(StringRef Name, StringRef Metadata) {
+  getAssembler().getWriter().addCInfoSymEntry(Name, Metadata);
+}
+
 void MCXCOFFStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        Align ByteAlignment) {
   getAssembler().registerSymbol(*Symbol);
   Symbol->setExternal(cast<MCSymbolXCOFF>(Symbol)->getStorageClass() !=
                       XCOFF::C_HIDEXT);
   Symbol->setCommon(Size, ByteAlignment);
 
   // Default csect align is 4, but common symbols have explicit alignment values

llvm/lib/MC/XCOFFObjectWriter.cpp

ExceptionSectionEntry(StringRef N, int32_t Flags)
       : SectionEntry(N, Flags | XCOFF::STYP_EXCEPT) {
     assert(N.size() <= XCOFF::NameSize && "Section too long.");
     memcpy(Name, N.data(), N.size());
   }
 
   virtual ~ExceptionSectionEntry() = default;
 };
 
+struct CInfoSymInfo {
+  // Name of the C_INFO symbol associated with the section
+  std::string Name;
+  std::string Metadata;
+  // Offset into the start of the metadata in the section
+  uint64_t Offset;
+
+  CInfoSymInfo(std::string Name, std::string Metadata)
+      : Name(Name), Metadata(Metadata) {}
+  // Metadata needs to be padded out to an even word size.
+  uint32_t paddingSize() const {
+    return alignTo(Metadata.size(), sizeof(uint32_t)) - Metadata.size();
+  };
+
+  // Total size of the entry, including the 4 byte length
+  uint32_t size() const {
+    return Metadata.size() + paddingSize() + sizeof(uint32_t);
+  };
+};
+
+struct CInfoSymSectionEntry : public SectionEntry {
+  std::unique_ptr<CInfoSymInfo> Entry;
+
+  CInfoSymSectionEntry(StringRef N, int32_t Flags) : SectionEntry(N, Flags) {}
+  virtual ~CInfoSymSectionEntry() = default;
+  void addEntry(std::unique_ptr<CInfoSymInfo> NewEntry) {
+    Entry = std::move(NewEntry);
+    Entry->Offset = sizeof(uint32_t);
+    Size += Entry->size();
+  }
+  void reset() override {
+    SectionEntry::reset();
+    Entry.reset();
+  }
+};
+
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint32_t PaddingsBeforeDwarf = 0;
   std::vector<std::pair<std::string, size_t>> FileNames;
   bool HasVisibility = false;
class XCOFFObjectWriter : public MCObjectWriter {
   // table.
   std::array<CsectSectionEntry *const, 5> Sections{
       {&Text, &Data, &BSS, &TData, &TBSS}};
 
   std::vector<DwarfSectionEntry> DwarfSections;
   std::vector<SectionEntry> OverflowSections;
 
   ExceptionSectionEntry ExceptionSection;
+  CInfoSymSectionEntry CInfoSymSection;
 
   CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
 
   void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
void writeSectionForControlSectionEntry(const MCAssembler &Asm,
                                           uint64_t &CurrentAddressLocation);
   void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const DwarfSectionEntry &DwarfEntry,
                                         uint64_t &CurrentAddressLocation);
   void writeSectionForExceptionSectionEntry(
       const MCAssembler &Asm, const MCAsmLayout &Layout,
       ExceptionSectionEntry &ExceptionEntry, uint64_t &CurrentAddressLocation);
+  void writeSectionForCInfoSymSectionEntry(const MCAssembler &Asm,
+                                           const MCAsmLayout &Layout,
+                                           CInfoSymSectionEntry &CInfoSymEntry,
+                                           uint64_t &CurrentAddressLocation);
   void writeSymbolTable(const MCAsmLayout &Layout);
   void writeSymbolAuxDwarfEntry(uint64_t LengthOfSectionPortion,
                                 uint64_t NumberOfRelocEnt = 0);
   void writeSymbolAuxCsectEntry(uint64_t SectionOrLength,
                                 uint8_t SymbolAlignmentAndType,
                                 uint8_t StorageMappingClass);
   void writeSymbolAuxFunctionEntry(uint32_t EntryOffset, uint32_t FunctionSize,
                                    uint64_t LineNumberPointer,
void addExceptionEntry(const MCSymbol *Symbol, const MCSymbol *Trap,
                          unsigned LanguageCode, unsigned ReasonCode,
                          unsigned FunctionSize, bool hasDebug) override;
   bool hasExceptionSection() {
     return !ExceptionSection.ExceptionTable.empty();
   }
   unsigned getExceptionSectionSize();
   unsigned getExceptionOffset(const MCSymbol *Symbol);
 
+  void addCInfoSymEntry(StringRef Name, StringRef Metadata) override;
   size_t auxiliaryHeaderSize() const {
     // 64-bit object files have no auxiliary header.
     return HasVisibility && !is64Bit() ? XCOFF::AuxFileHeaderSizeShort : 0;
   }
 
 public:
   XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                     raw_pwrite_stream &OS);
: W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
       Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false,
            CsectGroups{&DataCsects, &FuncDSCsects, &TOCCsects}),
       BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true,
           CsectGroups{&BSSCsects}),
       TData(".tdata", XCOFF::STYP_TDATA, /* IsVirtual */ false,
             CsectGroups{&TDataCsects}),
       TBSS(".tbss", XCOFF::STYP_TBSS, /* IsVirtual */ true,
            CsectGroups{&TBSSCsects}),
-      ExceptionSection(".except", XCOFF::STYP_EXCEPT) {}
+      ExceptionSection(".except", XCOFF::STYP_EXCEPT),
+      CInfoSymSection(".info", XCOFF::STYP_INFO) {}
 
 void XCOFFObjectWriter::reset() {
   // Clear the mappings we created.
   SymbolIndexMap.clear();
   SectionMap.clear();
 
   UndefinedCsects.clear();
   // Reset any sections we have written to, and empty the section header table.
   for (auto *Sec : Sections)
     Sec->reset();
   for (auto &DwarfSec : DwarfSections)
     DwarfSec.reset();
   for (auto &OverflowSec : OverflowSections)
     OverflowSec.reset();
   ExceptionSection.reset();
+  CInfoSymSection.reset();
 
   // Reset states in XCOFFObjectWriter.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   SectionCount = 0;
   PaddingsBeforeDwarf = 0;
   Strings.clear();
 
for (const MCSymbol &S : Asm.symbols()) {
     Csect->Syms.emplace_back(XSym);
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(XSym->getSymbolTableName()))
       Strings.add(XSym->getSymbolTableName());
   }
 
+  std::unique_ptr<CInfoSymInfo> &CISI = CInfoSymSection.Entry;
+  if (CISI && nameShouldBeInStringTable(CISI->Name))
+    Strings.add(CISI->Name);
+
   FileNames = Asm.getFileNames();
   // Emit ".file" as the source file name when there is no file name.
   if (FileNames.empty())
     FileNames.emplace_back(".file", 0);
   for (const std::pair<std::string, size_t> &F : FileNames) {
     if (nameShouldBeInStringTable(F.first))
       Strings.add(F.first);
   }
void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
   for (const auto *Section : Sections)
     writeSectionForControlSectionEntry(Asm, Layout, *Section,
                                        CurrentAddressLocation);
   for (const auto &DwarfSection : DwarfSections)
     writeSectionForDwarfSectionEntry(Asm, Layout, DwarfSection,
                                      CurrentAddressLocation);
   writeSectionForExceptionSectionEntry(Asm, Layout, ExceptionSection,
                                        CurrentAddressLocation);
+  writeSectionForCInfoSymSectionEntry(Asm, Layout, CInfoSymSection,
+                                      CurrentAddressLocation);
 }
 
 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
if (is64Bit()) {
     W.write<uint16_t>((IsOvrflo || Sec->RelocationCount == XCOFF::RelocOverflow)
                           ? Sec->RelocationCount
                           : 0); // NumberOfLineNumbers. Not supported yet.
     W.write<int32_t>(Sec->Flags);
   }
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
   for (const auto *CsectSec : Sections)
     writeSectionHeader(CsectSec);
   for (const auto &DwarfSec : DwarfSections)
     writeSectionHeader(&DwarfSec);
   for (const auto &OverflowSec : OverflowSections)
     writeSectionHeader(&OverflowSec);
   if (hasExceptionSection())
     writeSectionHeader(&ExceptionSection);
+  if (CInfoSymSection.Entry)
+    writeSectionHeader(&CInfoSymSection);
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const XCOFFSection &Section) {
   if (Section.MCSec->isCsect())
     writeWord(Section.Address + Reloc.FixupOffsetInCsect);
   else {
     // DWARF sections' address is set to 0.
void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   // The n_name of a C_FILE symbol is the source file's name when no auxiliary
   // entries are present.
   for (const std::pair<std::string, size_t> &F : FileNames) {
     writeSymbolEntry(F.first, /*Value=*/0, XCOFF::ReservedSectionNum::N_DEBUG,
                      /*SymbolType=*/0, XCOFF::C_FILE,
                      /*NumberOfAuxEntries=*/0);
   }
 
+  if (CInfoSymSection.Entry)
+    writeSymbolEntry(CInfoSymSection.Entry->Name, CInfoSymSection.Entry->Offset,
+                     CInfoSymSection.Index,
+                     /*SymbolType=*/0, XCOFF::C_INFO,
+                     /*NumberOfAuxEntries=*/0);
+
   for (const auto &Csect : UndefinedCsects) {
     writeSymbolEntryForControlSection(Csect, XCOFF::ReservedSectionNum::N_UNDEF,
                                       Csect.MCSec->getStorageClass());
   }
 
   for (const auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
void XCOFFObjectWriter::finalizeSectionInfo() {
   // Calculate the RawPointer value for all headers.
   uint64_t RawPointer =
       (is64Bit() ? (XCOFF::FileHeaderSize64 +
                     SectionCount * XCOFF::SectionHeaderSize64)
                  : (XCOFF::FileHeaderSize32 +
                     SectionCount * XCOFF::SectionHeaderSize32)) +
       auxiliaryHeaderSize();
 
   // Calculate the file offset to the section data.
   for (auto *Sec : Sections) {
     if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
       continue;
 
     RawPointer = Sec->advanceFileOffset(MaxRawDataSize, RawPointer);
   }
 
   if (!DwarfSections.empty()) {
     RawPointer += PaddingsBeforeDwarf;
     for (auto &DwarfSection : DwarfSections) {
       RawPointer = DwarfSection.advanceFileOffset(MaxRawDataSize, RawPointer);
     }
   }
 
   if (hasExceptionSection())
     RawPointer = ExceptionSection.advanceFileOffset(MaxRawDataSize, RawPointer);
 
+  if (CInfoSymSection.Entry)
+    RawPointer = CInfoSymSection.advanceFileOffset(MaxRawDataSize, RawPointer);
+
   for (auto *Sec : Sections) {
     if (Sec->Index != SectionEntry::UninitializedIndex)
       calcOffsetToRelocations(Sec, RawPointer);
   }
 
   for (auto &DwarfSec : DwarfSections)
     calcOffsetToRelocations(&DwarfSec, RawPointer);
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::addExceptionEntry(
     const MCSymbol *Symbol, const MCSymbol *Trap, unsigned LanguageCode,
     unsigned ReasonCode, unsigned FunctionSize, bool hasDebug) {
   // If a module had debug info, debugging is enabled and XCOFF emits the
   // exception auxilliary entry.
   if (hasDebug)
     ExceptionSection.isDebugEnabled = true;
   auto Entry = ExceptionSection.ExceptionTable.find(Symbol->getName());
for (auto it = ExceptionSection.ExceptionTable.begin();
     if (Symbol == it->second.FunctionSymbol)
       break;
     EntryNum += it->second.Entries.size() + 1;
   }
   return EntryNum * (is64Bit() ? XCOFF::ExceptionSectionEntrySize64
                                : XCOFF::ExceptionSectionEntrySize32);
 }
 
+void XCOFFObjectWriter::addCInfoSymEntry(StringRef Name, StringRef Metadata) {
+  assert(!CInfoSymSection.Entry && "Multiple entries are not supported");
+  CInfoSymSection.addEntry(
+      std::make_unique<CInfoSymInfo>(Name.str(), Metadata.str()));
+}
+
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The symbol table starts with all the C_FILE symbols.
   uint32_t SymbolTableIndex = FileNames.size();
 
+  if (CInfoSymSection.Entry)
+    SymbolTableIndex++;
+
   // Calculate indices for undefined symbols.
   for (auto &Csect : UndefinedCsects) {
     Csect.Size = 0;
     Csect.Address = 0;
     Csect.SymbolTableIndex = SymbolTableIndex;
     SymbolIndexMap[Csect.MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
     // 1 main and 1 auxiliary symbol table entry for each contained symbol.
     SymbolTableIndex += 2;
   }
 
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint64_t Address = 0;
if (hasExceptionSection()) {
     ExceptionSection.Index = SectionIndex++;
     SectionCount++;
     ExceptionSection.Address = 0;
     ExceptionSection.Size = getExceptionSectionSize();
     Address += ExceptionSection.Size;
     Address = alignTo(Address, DefaultSectionAlign);
   }
 
+  if (CInfoSymSection.Entry) {
+    CInfoSymSection.Index = SectionIndex++;
+    SectionCount++;
+    CInfoSymSection.Address = 0;
+    Address += CInfoSymSection.Size;
+    Address = alignTo(Address, DefaultSectionAlign);
+  }
+
   SymbolTableEntryCount = SymbolTableIndex;
 }
 
 void XCOFFObjectWriter::writeSectionForControlSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,
     const CsectSectionEntry &CsectEntry, uint64_t &CurrentAddressLocation) {
   // Nothing to write for this Section.
   if (CsectEntry.Index == SectionEntry::UninitializedIndex)
for (auto &TrapEntry : it->second.Entries) {
       W.write<uint8_t>(TrapEntry.Lang);
       W.write<uint8_t>(TrapEntry.Reason);
     }
   }
 
   CurrentAddressLocation += getExceptionSectionSize();
 }
 
+void XCOFFObjectWriter::writeSectionForCInfoSymSectionEntry(
+    const MCAssembler &Asm, const MCAsmLayout &Layout,
+    CInfoSymSectionEntry &CInfoSymEntry, uint64_t &CurrentAddressLocation) {
+  if (!CInfoSymSection.Entry)
+    return;
+
+  constexpr int WordSize = sizeof(uint32_t);
+  std::unique_ptr<CInfoSymInfo> &CISI = CInfoSymEntry.Entry;
+  const std::string &Metadata = CISI->Metadata;
+
+  // Emit the 4-byte length of the metadata.
+  W.write<uint32_t>(Metadata.size());
+
+  if (Metadata.size() == 0)
+    return;
+
+  // Write out the payload one word at a time.
+  size_t Index = 0;
+  while (Index + WordSize <= Metadata.size()) {
+    uint32_t NextWord =
+        llvm::support::endian::read32be(Metadata.data() + Index);
+    W.write<uint32_t>(NextWord);
+    Index += WordSize;
+  }
+
+  // If there is padding, we have at least one byte of payload left to emit.
+  if (CISI->paddingSize()) {
+    std::array<uint8_t, WordSize> LastWord = {0};
+    ::memcpy(LastWord.data(), Metadata.data() + Index, Metadata.size() - Index);
+    W.write<uint32_t>(llvm::support::endian::read32be(LastWord.data()));
+  }
+
+  CurrentAddressLocation += CISI->size();
+}
+
 // Takes the log base 2 of the alignment and shifts the result into the 5 most
 // significant bits of a byte, then or's in the csect type into the least
 // significant 3 bits.
 uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
   unsigned Log2Align = Log2(Sec->getAlign());
   // Result is a number in the range [0, 31] which fits in the 5 least
   // significant bits. Shift this value into the 5 most significant bits, and
   // bitwise-or in the csect type.

llvm/test/CodeGen/PowerPC/aix-command-line-metadata.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck --check-prefix=ASM %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck --check-prefix=ASM %s
 
-; RUN: not --crash llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj  < %s 2>&1 | \
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj  -o %t.o < %s
+; RUN: llvm-objdump --full-contents --section=.info %t.o | \
 ; RUN: FileCheck --check-prefix=OBJ %s
-; RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj  < %s 2>&1 | \
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj  -o %t.o < %s
+; RUN: llvm-objdump --full-contents --section=.info %t.o | \
 ; RUN: FileCheck --check-prefix=OBJ %s
 
 ; Verify that llvm.commandline metadata is emitted to .info sections and that the
 ; metadata is padded if necessary.
 
-; OBJ: LLVM ERROR: emitXCOFFCInfoSym is not implemented yet on object generation path
-
 ; ASM: .info ".GCC.command.line", 0x0000003a,
 ; ASM: .info , 0x40282329, 0x6f707420, 0x636c616e, 0x67202d63, 0x6f6d6d61, 0x6e64202d
 ; ASM: .info , 0x6c696e65, 0x0a004028, 0x23296f70, 0x7420736f, 0x6d657468, 0x696e6720
 ; ASM: .info , 0x656c7365, 0x20313233, 0x0a000000
 
+; OBJ: Contents of section .info:
+; OBJ: 0000 0000003a 40282329 6f707420 636c616e  ...:@(#)opt clan
+; OBJ: 0010 67202d63 6f6d6d61 6e64202d 6c696e65  g -command -line
+; OBJ: 0020 0a004028 23296f70 7420736f 6d657468  ..@(#)opt someth
+; OBJ: 0030 696e6720 656c7365 20313233 0a000000  ing else 123....
+
 !llvm.commandline = !{!0, !1}
 !0 = !{!"clang -command -line"}
 !1 = !{!"something else 123"}