[XCOFF] support writing sections, relocations and symbols for XCOFF64.

[Esme]

Summary

This is the second patch to enable the XCOFF64 object writer.

[jhenderson]

My only real comment on this is patch ordering. An XCOFF/AIX person should review too.

llvm/lib/MC/XCOFFObjectWriter.cpp

769

The non-zero value plus "not supported yet" comment doesn't quite work. Perhaps "Only source file symbol supported"?

828–829

I'd have thought implementing the symbol table before relocations makes more sense.

866–869

Same comment as above: support the symtab first?

[Esme]

Thanks for your comments! @jhenderson
It seems inappropriate to support the symbol table before the sections and relocations, due to their offset order, or some other reasons. So I enabled all these fields in this patch and also modified related test cases.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

203

I do not think we will change ".file" . change to const StringRef SourceFileName = ".file" ?

771

SymbolTableEntryCount+1 for ".file" symbol.

828–829

agree with James

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

82

I am not sure, whether I understand correct or not ?

1. fixup_ppc_half16ds: A 14-bit fixup corresponding to lo16(_foo) with implied 2 zero bits for instrs like 'std'.
2. fixup_ppc_half16dq: A 16-bit fixup corresponding to lo16(_foo) with implied 3 zero bits for instrs like 'lxv'.
3. fixup_ppc_half16 : A 16-bit fixup corresponding to lo16(_foo) or ha16(_foo) for instrs like 'li' or 'addis'.

in the https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__sua3i125jbau
r_rsize: 0x3F(6 bits)
Specifies the bit length of the relocatable reference minus one. The current architecture allows for fields of up to 32 bits (XCOFF32) or 64 bits (XCOFF64) to be relocated.

so for the
case PPC::fixup_ppc_half16ds:

{XCOFF::RelocationType::R_TOC, EncodedSignednessIndicator | 13 }

[Esme]

Addressed @DiggerLin 's comments.

llvm/lib/MC/XCOFFObjectWriter.cpp

203

If the file auxiliary entry is not used, the symbol name is the name of the source file. If the file auxiliary entry is used, then the symbol name should be .file, and the first file auxiliary entry (by convention) contains the source file name.

Our current approach is to write a symbol without the auxiliary entry, with .file as the source file's name, but in fact we should write a symbol with the real source file's name. And we commented a todo for this.

// FIXME: add the real source file's name.

So I think the SourceFileName may be changed.

771

void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
  // The first symbol table entry (at index 0) is for the file name.
  uint32_t SymbolTableIndex = 1;
...
  SymbolTableEntryCount = SymbolTableIndex;
}

The ".file" symbol has been counted.

828–829

Thanks, since it's hard to separate the symbol table and relocation into 2 patches, I prefer to enable both of them in this patch.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

82

Thanks for your catch!

[jhenderson]

Nothing much else to add apart from a stylistic comment.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

2–4

I have a personal preference for this syntax: from the first line, it makes it clear that the next line is a new command, whilst from the second line, the indentation followed by an executable name makes it clear that this is a continuation of the previous line.

Same applies elsewhere.

[Esme]

Improved the format of run lines in tests.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

203

thanks.

723

maybe this is more readable , even there is duplication code of writeWord(NumberOfRelocEnt);

if (!is64Bit()) {
     W.OS.write_zeros(4); // Reserved
     writeWord(NumberOfRelocEnt);
     W.OS.write_zeros(6); // Reserved
  else {
     writeWord(NumberOfRelocEnt);
     W.OS.write_zeros(1); // Reserved
     W.write<uint8_t>(XCOFF::AUX_SECT);
  }

771

thanks.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

82

PPC::fixup_ppc_half16dq: is a A 16-bit fixup corresponding to lo16(_foo) with implied 3 zero bits for instrs like 'lxv'.
for PPC::fixup_ppc_half16dq
it should be
{XCOFF::RelocationType::R_TOC, EncodedSignednessIndicator | 15 } ?

[DiggerLin]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

82

I am not a expert on the relocation, I just put my question and we may be need someone who is expert on the relocation to review the code.

[Esme]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

82

/// A 16-bit fixup corresponding to lo16(_foo) with implied 3 zero bits for
/// instrs like 'lxv'. Produces the same relocation as fixup_ppc_half16ds.
PPC::fixup_ppc_half16dq

Thanks, I thinks I need more investigation about this, the comment says it produces the same relocation as fixup_ppc_half16ds.

[Esme]

Hi @DiggerLin, Sorry for the late update, I have verified that the SignAndSize value should be 15 for both fixup_ppc_half16ds and fixup_ppc_half16dq. Although there are zeros being implied, the totally size should be a 16-bit fixup. I confirmed this by testing LIT and test-suite, and the test-suite passes only if the value is 15, otherwise there will be an error like this

Relocation overflow in reference to: L..CPI168_7 (entry 3199)
        Address: 0x00082c12; RLD type: R_TOC; RLD length: 14

[jhenderson]

llvm/test/CodeGen/PowerPC/basic-toc-data-def.ll

4–10

FWIW, I'd actually keep the old style here, as it makes it clear which commands the options apply to, whilst still indicating FileCheck is a continuation. Same applies in similar cases.

[shchenz]

Looks almost good to me. Thanks for adding this support.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

74

Is it possible to add some tests to verify the new relocation types added here for 64-bit objects, especially the ones the existing case changes do not contain?

82

Hmm, yes, I also think this is a little confuse. From 64bit OpenPower ABI, section 3.5.1, it says:

In the following figure, half16ds is similar to half16, but is really just 14 bits because the two least significant bits must be zero and are not really part of the field. (Used by, for example, the ldu instruction.) In addition to the use of this relocation field with the DS forms, half16ds relocations are also used in conjunction with DQ forms. In those instances, the linker and assembler collaborate to create valid DQ forms. They raise an error if the specified offset does not meet the constraints of a valid DQ instruction form displacement.

I think it clearly indicates that fixup_ppc_half16ds and fixup_ppc_half16dq should use same relocation infos.

For the bit length, it does not give a clear answer, it says is similar to half16, but is really just 14 bits. I checked the source code of commercial XLC, it gives 15. So I think it should be good to use 15 here.

84

Should we handle RelocationType::R_TOCU? I guess it may be generated in large code model(-mcmodel=large).

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

376

Use relative index like above Index: [[#Index+25]]?

llvm/test/CodeGen/PowerPC/aix-extern.ll

510

Same here.

[Esme]

Addressed comments and improved tests.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

84

fixup_ppc_half16ds and fixup_ppc_half16dq may only correspond to lo16 of instrs, not ha16, so we shouldn't deal with RelocationType::R_TOCU here.

I have added the corresponding large code model test in llvm/test/CodeGen/PowerPC/aix-xcoff-reloc-large.ll.

[Esme]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

74

Tests in ppc64-abs-reloc.s, aix-xcoff-reloc.ll, aix-xcoff-reloc-large.ll etc. cover the new relocation types.

[shchenz]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

84

Yes, right. When large code model is in effect, the higher 16 bit is relocated by addis which will not use fixup kind fixup_ppc_half16dq or fixup_ppc_half16ds

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

50

Except this field Auxiliary Type, all other fields for the symbol table are the same with XCOFF32, should we reuse them? I prefer to reuse them as we can get a better view about the difference between XCOFF32/XCOFF64.

And many others test files too.

llvm/test/MC/PowerPC/ppc64-abs-reloc.s

4

triple should be 64 bit.

27

Exactly the same with above checks, can we reuse?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

723

I think we also need a test case for dwarf 64 too.

[Esme]

1. Simplify tests.
2. Test dwarf64.

[shchenz]

LGTM! Thanks for adding this amazing support.

Maybe we can wait for some days in case @DiggerLin or @jhenderson has some further comments.

[jhenderson]

Actually, according to the pre-merge checks, one of the tests is failing, and I suspect it might be related to this patch?

[Esme]

Rebase.
Clean the failure in test llvm/test/CodeGen/PowerPC/aix-xcoff-visibility.ll.

llvm/lib/MC/XCOFFObjectWriter.cpp

 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint64_t RelocationEntryOffset = 0;
+  StringRef SourceFileName = ".file";
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   const uint64_t MaxRawDataSize =
       TargetObjectWriter->is64Bit() ? UINT64_MAX : UINT32_MAX;
 
class XCOFFObjectWriter : public MCObjectWriter {
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
   uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
 
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
-  static bool nameShouldBeInStringTable(const StringRef &);
+  bool nameShouldBeInStringTable(const StringRef &);
   void writeSymbolName(const StringRef &);
 
   void writeSymbolEntryForCsectMemberLabel(const Symbol &SymbolRef,
                                            const XCOFFSection &CSectionRef,
                                            int16_t SectionIndex,
                                            uint64_t SymbolOffset);
   void writeSymbolEntryForControlSection(const XCOFFSection &CSectionRef,
                                          int16_t SectionIndex,
                                          XCOFF::StorageClass StorageClass);
   void writeSymbolEntryForDwarfSection(const XCOFFSection &DwarfSectionRef,
                                        int16_t SectionIndex);
   void writeFileHeader();
   void writeSectionHeaderTable();
   void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSectionForControlSectionEntry(const MCAssembler &Asm,
                                           const MCAsmLayout &Layout,
                                           const CsectSectionEntry &CsectEntry,
-                                          uint32_t &CurrentAddressLocation);
+                                          uint64_t &CurrentAddressLocation);
   void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const DwarfSectionEntry &DwarfEntry,
-                                        uint32_t &CurrentAddressLocation);
+                                        uint64_t &CurrentAddressLocation);
   void writeSymbolTable(const MCAsmLayout &Layout);
-  void writeSymbolAuxDwarfEntry(uint32_t LengthOfSectionPortion,
-                                uint32_t NumberOfRelocEnt = 0);
-  void writeSymbolAuxCsectEntry(uint32_t SectionOrLength,
+  void writeSymbolAuxDwarfEntry(uint64_t LengthOfSectionPortion,
+                                uint64_t NumberOfRelocEnt = 0);
+  void writeSymbolAuxCsectEntry(uint64_t SectionOrLength,
                                 uint8_t SymbolAlignmentAndType,
                                 uint8_t StorageMappingClass);
-  void writeSymbolEntry(StringRef SymbolName, uint32_t Value,
+  void writeSymbolEntry(StringRef SymbolName, uint64_t Value,
                         int16_t SectionNumber, uint16_t SymbolType,
                         uint8_t StorageClass, uint8_t NumberOfAuxEntries = 1);
   void writeRelocations();
   void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &Section);
 
   // Called after all the csects and symbols have been processed by
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
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());
   }
 
+  // The first symbol entry is for the source file's name.
+  if (nameShouldBeInStringTable(SourceFileName))
+    Strings.add(SourceFileName);
+
   Strings.finalize();
   assignAddressesAndIndices(Layout);
 }
 
 void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
                                          const MCAsmLayout &Layout,
                                          const MCFragment *Fragment,
                                          const MCFixup &Fixup, MCValue Target,
void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
   SectionMap[RelocationSec]->Relocations.push_back(RelocB);
   // We already folded "SymbolA + imm64" above when Type is R_POS for SymbolA,
   // now we just need to fold "- SymbolB" here.
   FixedValue -= getVirtualAddress(SymB, SymBSec);
 }
 
 void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
-  assert(!is64Bit() && "Writing 64-bit sections is not yet supported.");
-  uint32_t CurrentAddressLocation = 0;
+  uint64_t CurrentAddressLocation = 0;
   for (const auto *Section : Sections)
     writeSectionForControlSectionEntry(Asm, Layout, *Section,
                                        CurrentAddressLocation);
   for (const auto &DwarfSection : DwarfSections)
     writeSectionForDwarfSectionEntry(Asm, Layout, DwarfSection,
                                      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())
     report_fatal_error("Incremental linking not supported for XCOFF.");
 
   finalizeSectionInfo();
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
-
-  if (!is64Bit()) {
-    writeSections(Asm, Layout);
-    writeRelocations();
-
-    writeSymbolTable(Layout);
-    // Write the string table.
-    Strings.write(W.OS);
-  }
 
   return W.OS.tell() - StartOffset;
 }
 
 bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
-  return SymbolName.size() > XCOFF::NameSize;
+  return SymbolName.size() > XCOFF::NameSize || is64Bit();
 }
 
 void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
   // Magic, Offset or SymbolName.
   if (nameShouldBeInStringTable(SymbolName)) {
     W.write<int32_t>(0);
     W.write<uint32_t>(Strings.getOffset(SymbolName));
   } else {
     char Name[XCOFF::NameSize + 1];
     std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
     ArrayRef<char> NameRef(Name, XCOFF::NameSize);
     W.write(NameRef);
   }
 }
 
-void XCOFFObjectWriter::writeSymbolEntry(StringRef SymbolName, uint32_t Value,
+void XCOFFObjectWriter::writeSymbolEntry(StringRef SymbolName, uint64_t Value,
                                          int16_t SectionNumber,
                                          uint16_t SymbolType,
                                          uint8_t StorageClass,
                                          uint8_t NumberOfAuxEntries) {
+  if (is64Bit()) {
+    W.write<uint64_t>(Value);
+    W.write<uint32_t>(Strings.getOffset(SymbolName));
+  } else {
     writeSymbolName(SymbolName);
     W.write<uint32_t>(Value);
+  }
   W.write<int16_t>(SectionNumber);
   // Basic/Derived type. See the description of the n_type field for symbol
   // table entries for a detailed description. Since we don't yet support
   // visibility, and all other bits are either optionally set or reserved, this
   // is always zero.
   if (SymbolType != 0)
     report_fatal_error("Emitting non-zero visibilities is not supported yet.");
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
   W.write<uint16_t>(SymbolType);
   W.write<uint8_t>(StorageClass);
   W.write<uint8_t>(NumberOfAuxEntries);
 }
 
-void XCOFFObjectWriter::writeSymbolAuxCsectEntry(uint32_t SectionOrLength,
+void XCOFFObjectWriter::writeSymbolAuxCsectEntry(uint64_t SectionOrLength,
                                                  uint8_t SymbolAlignmentAndType,
                                                  uint8_t StorageMappingClass) {
-  W.write<uint32_t>(SectionOrLength);
+  W.write<uint32_t>(is64Bit() ? Lo_32(SectionOrLength) : SectionOrLength);
   W.write<uint32_t>(0); // ParameterHashIndex
   W.write<uint16_t>(0); // TypeChkSectNum
   W.write<uint8_t>(SymbolAlignmentAndType);
   W.write<uint8_t>(StorageMappingClass);
+  if (is64Bit()) {
+    W.write<uint32_t>(Hi_32(SectionOrLength));
+    W.OS.write_zeros(1); // Reserved
+    W.write<uint8_t>(XCOFF::AUX_CSECT);
+  } else {
     W.write<uint32_t>(0); // StabInfoIndex
     W.write<uint16_t>(0); // StabSectNum
   }
+}
 
 void XCOFFObjectWriter::writeSymbolAuxDwarfEntry(
-    uint32_t LengthOfSectionPortion, uint32_t NumberOfRelocEnt) {
-  W.write<uint32_t>(LengthOfSectionPortion);
+    uint64_t LengthOfSectionPortion, uint64_t NumberOfRelocEnt) {
+  writeWord(LengthOfSectionPortion);
+  if (!is64Bit())
     W.OS.write_zeros(4); // Reserved
-  W.write<uint32_t>(NumberOfRelocEnt);
+  writeWord(NumberOfRelocEnt);
+  if (is64Bit()) {
+    W.OS.write_zeros(1); // Reserved
+    W.write<uint8_t>(XCOFF::AUX_SECT);
+  } else {
     W.OS.write_zeros(6); // Reserved
   }
+}
 
 void XCOFFObjectWriter::writeSymbolEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const XCOFFSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
   assert(SymbolOffset <= MaxRawDataSize - CSectionRef.Address &&
          "Symbol address overflowed.");
 
   writeSymbolEntry(SymbolRef.getSymbolTableName(),
void XCOFFObjectWriter::writeFileHeader() {
   W.write<uint16_t>(is64Bit() ? XCOFF::XCOFF64 : XCOFF::XCOFF32);
   W.write<uint16_t>(SectionCount);
   W.write<int32_t>(0); // TimeStamp
   writeWord(SymbolTableOffset);
   if (is64Bit()) {
     W.write<uint16_t>(0); // AuxHeaderSize. No optional header for an object
                           // file that is not to be loaded.
     W.write<uint16_t>(0); // Flags
-    W.write<int32_t>(0);  // SymbolTableEntryCount. Not supported yet.
+    W.write<int32_t>(SymbolTableEntryCount);
   } else {
     W.write<int32_t>(SymbolTableEntryCount);
     W.write<uint16_t>(0); // AuxHeaderSize. No optional header for an object
                           // file that is not to be loaded.
     W.write<uint16_t>(0); // Flags
   }
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
   auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
     writeWord(IsDwarf ? 0 : Sec->Address);
 
     writeWord(Sec->Size);
     writeWord(Sec->FileOffsetToData);
     writeWord(Sec->FileOffsetToRelocations);
     writeWord(0); // FileOffsetToLineNumberInfo. Not supported yet.
 
     if (is64Bit()) {
-      W.write<uint32_t>(0); // NumberOfRelocations. Not yet supported in 64-bit.
+      W.write<uint32_t>(Sec->RelocationCount);
       W.write<uint32_t>(0); // NumberOfLineNumbers. Not supported yet.
       W.write<int32_t>(Sec->Flags);
       W.OS.write_zeros(4);
     } else {
       W.write<uint16_t>(Sec->RelocationCount);
       W.write<uint16_t>(0); // NumberOfLineNumbers. Not supported yet.
       W.write<int32_t>(Sec->Flags);
     }
 
     return true;
   };
 
   for (const auto *CsectSec : Sections)
     writeSectionHeader(CsectSec, /* IsDwarf */ false);
   for (const auto &DwarfSec : DwarfSections)
     writeSectionHeader(&DwarfSec, /* IsDwarf */ true);
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const XCOFFSection &Section) {
-  assert(!is64Bit() && "Writing 64-bit relocation is not yet supported.");
   if (Section.MCSec->isCsect())
-    W.write<uint32_t>(Section.Address + Reloc.FixupOffsetInCsect);
+    writeWord(Section.Address + Reloc.FixupOffsetInCsect);
   else {
     // DWARF sections' address is set to 0.
     assert(Section.MCSec->isDwarfSect() && "unsupport section type!");
-    W.write<uint32_t>(Reloc.FixupOffsetInCsect);
+    writeWord(Reloc.FixupOffsetInCsect);
   }
   W.write<uint32_t>(Reloc.SymbolTableIndex);
   W.write<uint8_t>(Reloc.SignAndSize);
   W.write<uint8_t>(Reloc.Type);
 }
 
 void XCOFFObjectWriter::writeRelocations() {
   for (const auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
void XCOFFObjectWriter::writeRelocations() {
   }
 
   for (const auto &DwarfSection : DwarfSections)
     for (const auto &Reloc : DwarfSection.DwarfSect->Relocations)
       writeRelocation(Reloc, *DwarfSection.DwarfSect);
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
-  assert(!is64Bit() && "Writing 64-bit symbol table is not yet supported.");
   // Write symbol 0 as C_FILE.
-  // FIXME: support 64-bit C_FILE symbol.
   // The n_name of a C_FILE symbol is the source file's name when no auxiliary
   // entries are present. The source file's name is alternatively provided by an
   // auxiliary entry, in which case the n_name of the C_FILE symbol is `.file`.
   // FIXME: add the real source file's name.
-  writeSymbolEntry(".file", /*Value=*/0, XCOFF::ReservedSectionNum::N_DEBUG,
+  writeSymbolEntry(SourceFileName, /*Value=*/0,
+                   XCOFF::ReservedSectionNum::N_DEBUG,
                    /*SymbolType=*/0, XCOFF::C_FILE,
                    /*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.
       continue;
 
     for (const auto *Group : Section->Groups) {
       if (Group->empty())
if (Section->Index == SectionEntry::UninitializedIndex)
       continue;
 
     for (const auto *Group : Section->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const size_t CsectRelocCount = Csect.Relocations.size();
-        if (CsectRelocCount >= XCOFF::RelocOverflow ||
-            Section->RelocationCount >= XCOFF::RelocOverflow - CsectRelocCount)
+        // An XCOFF64 file may not contain an overflow section header.
+        if (!is64Bit() && (CsectRelocCount >= XCOFF::RelocOverflow ||
+                           Section->RelocationCount >=
+                               XCOFF::RelocOverflow - CsectRelocCount))
           report_fatal_error(
               "relocation entries overflowed; overflow section is "
               "not implemented yet");
 
         Section->RelocationCount += CsectRelocCount;
       }
     }
   }
 
   for (auto &DwarfSection : DwarfSections)
     DwarfSection.RelocationCount = DwarfSection.DwarfSect->Relocations.size();
 
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
   auto calcOffsetToRelocations = [&](SectionEntry *Sec, bool IsDwarf) {
     if (!IsDwarf && Sec->Index == SectionEntry::UninitializedIndex)
       return false;
 
     if (!Sec->RelocationCount)
       return false;
 
     Sec->FileOffsetToRelocations = RawPointer;
-    const uint32_t RelocationSizeInSec =
-        Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
+    const uint64_t RelocationSizeInSec =
+        Sec->RelocationCount * (is64Bit()
+                                    ? XCOFF::RelocationSerializationSize64
+                                    : XCOFF::RelocationSerializationSize32);
     RawPointer += RelocationSizeInSec;
     if (RawPointer > MaxRawDataSize)
       report_fatal_error("Relocation data overflowed this object file.");
 
     return true;
   };
 
   for (auto *Sec : Sections)
for (auto &Csect : UndefinedCsects) {
     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.
-  uint32_t Address = 0;
+  uint64_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
   bool HasTDataSection = false;
 
   for (auto *Section : Sections) {
     const bool IsEmpty =
         llvm::all_of(Section->Groups,
                      [](const CsectGroup *Group) { return Group->empty(); });
assert(RawPointer <= MaxRawDataSize &&
            "Section raw data overflowed this object file.");
   }
 
   RelocationEntryOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::writeSectionForControlSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,
-    const CsectSectionEntry &CsectEntry, uint32_t &CurrentAddressLocation) {
+    const CsectSectionEntry &CsectEntry, uint64_t &CurrentAddressLocation) {
   // Nothing to write for this Section.
   if (CsectEntry.Index == SectionEntry::UninitializedIndex)
     return;
 
   // There could be a gap (without corresponding zero padding) between
   // sections.
   // There could be a gap (without corresponding zero padding) between
   // sections.
for (const auto &Csect : *Group) {
         Asm.writeSectionData(W.OS, Csect.MCSec, Layout);
       CurrentAddressLocation = Csect.Address + Csect.Size;
     }
   }
 
   // The size of the tail padding in a section is the end virtual address of
   // the current section minus the the end virtual address of the last csect
   // in that section.
-  if (uint32_t PaddingSize =
+  if (uint64_t PaddingSize =
           CsectEntry.Address + CsectEntry.Size - CurrentAddressLocation) {
     W.OS.write_zeros(PaddingSize);
     CurrentAddressLocation += PaddingSize;
   }
 }
 
 void XCOFFObjectWriter::writeSectionForDwarfSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,
-    const DwarfSectionEntry &DwarfEntry, uint32_t &CurrentAddressLocation) {
+    const DwarfSectionEntry &DwarfEntry, uint64_t &CurrentAddressLocation) {
   // There could be a gap (without corresponding zero padding) between
   // sections. For example DWARF section alignment is bigger than
   // DefaultSectionAlign.
   assert(CurrentAddressLocation <= DwarfEntry.Address &&
          "CurrentAddressLocation should be less than or equal to section "
          "address.");
 
-  if (uint32_t PaddingSize = DwarfEntry.Address - CurrentAddressLocation)
+  if (uint64_t PaddingSize = DwarfEntry.Address - CurrentAddressLocation)
     W.OS.write_zeros(PaddingSize);
 
   if (DwarfEntry.Size)
     Asm.writeSectionData(W.OS, DwarfEntry.DwarfSect->MCSec, Layout);
 
   CurrentAddressLocation = DwarfEntry.Address + DwarfEntry.Size;
 
   // DWARF section size is not aligned to DefaultSectionAlign.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

case PPC::fixup_ppc_half16: {
     case MCSymbolRefExpr::VK_None:
       return {XCOFF::RelocationType::R_TOC, SignAndSizeForHalf16};
     case MCSymbolRefExpr::VK_PPC_U:
       return {XCOFF::RelocationType::R_TOCU, SignAndSizeForHalf16};
     case MCSymbolRefExpr::VK_PPC_L:
       return {XCOFF::RelocationType::R_TOCL, SignAndSizeForHalf16};
     }
   } break;
+  case PPC::fixup_ppc_half16ds:
+  case PPC::fixup_ppc_half16dq: {
+    if (IsPCRel)
+      report_fatal_error("Invalid PC-relative relocation.");
+    switch (Modifier) {
+    default:
+      llvm_unreachable("Unsupported Modifier");
+    case MCSymbolRefExpr::VK_None:
+      return {XCOFF::RelocationType::R_TOC, 15};
+    case MCSymbolRefExpr::VK_PPC_L:
+      return {XCOFF::RelocationType::R_TOCL, 15};
+    }
+  } break;
   case PPC::fixup_ppc_br24:
     // Branches are 4 byte aligned, so the 24 bits we encode in
     // the instruction actually represents a 26 bit offset.
     return {XCOFF::RelocationType::R_RBR, EncodedSignednessIndicator | 25};
   case PPC::fixup_ppc_br24abs:
     return {XCOFF::RelocationType::R_RBA, EncodedSignednessIndicator | 25};
   case FK_Data_4:
+  case FK_Data_8:
+    const uint8_t SignAndSizeForFKData =
+        EncodedSignednessIndicator |
+        ((unsigned)Fixup.getKind() == FK_Data_4 ? 31 : 63);
     switch (Modifier) {
     default:
       report_fatal_error("Unsupported modifier");
     case MCSymbolRefExpr::VK_PPC_AIX_TLSGD:
-      return {XCOFF::RelocationType::R_TLS, EncodedSignednessIndicator | 31};
+      return {XCOFF::RelocationType::R_TLS, SignAndSizeForFKData};
     case MCSymbolRefExpr::VK_PPC_AIX_TLSGDM:
-      return {XCOFF::RelocationType::R_TLSM, EncodedSignednessIndicator | 31};
+      return {XCOFF::RelocationType::R_TLSM, SignAndSizeForFKData};
     case MCSymbolRefExpr::VK_None:
-      return {XCOFF::RelocationType::R_POS, EncodedSignednessIndicator | 31};
+      return {XCOFF::RelocationType::R_POS, SignAndSizeForFKData};
     }
   }
 }

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN:     -mattr=-altivec < %s | \
-; RUN:   FileCheck %s
+; RUN:     -mattr=-altivec < %s | FileCheck %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN:     -mattr=-altivec < %s | \
-; RUN:   FileCheck %s
+; RUN:     -mattr=-altivec < %s | FileCheck %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | \
-; RUN:   FileCheck --check-prefix=XCOFF32 %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=XCOFF,XCOFF32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=XCOFF,XCOFF64 %s
 
 @_ZN3Foo1aE = available_externally constant i32 -1
 
 ; CHECK: .extern  _ZN3Foo1aE[UA]
 
-; XCOFF32:          Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN3Foo1aE
-; XCOFF32-NEXT:     Value (RelocatableAddress): 0x0
-; XCOFF32-NEXT:     Section: N_UNDEF
-; XCOFF32-NEXT:     Type: 0x0
-; XCOFF32-NEXT:     StorageClass: C_EXT (0x2)
-; XCOFF32-NEXT:     NumberOfAuxEntries: 1
-; XCOFF32-NEXT:     CSECT Auxiliary Entry {
-; XCOFF32-NEXT:       Index: [[#Index+1]]
-; XCOFF32-NEXT:       SectionLen: 0
-; XCOFF32-NEXT:       ParameterHashIndex: 0x0
-; XCOFF32-NEXT:       TypeChkSectNum: 0x0
-; XCOFF32-NEXT:       SymbolAlignmentLog2: 0
-; XCOFF32-NEXT:       SymbolType: XTY_ER (0x0)
-; XCOFF32-NEXT:       StorageMappingClass: XMC_UA (0x4)
-; XCOFF32-NEXT:       StabInfoIndex: 0x0
-; XCOFF32-NEXT:       StabSectNum: 0x0
-; XCOFF32-NEXT:     }
+; XCOFF:       Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN3Foo1aE
+; XCOFF-NEXT:  Value (RelocatableAddress): 0x0
+; XCOFF-NEXT:  Section: N_UNDEF
+; XCOFF-NEXT:  Type: 0x0
+; XCOFF-NEXT:  StorageClass: C_EXT (0x2)
+; XCOFF-NEXT:  NumberOfAuxEntries: 1
+; XCOFF-NEXT:  CSECT Auxiliary Entry {
+; XCOFF-NEXT:    Index: [[#Index+1]]
+; XCOFF-NEXT:    SectionLen: 0
+; XCOFF-NEXT:    ParameterHashIndex: 0x0
+; XCOFF-NEXT:    TypeChkSectNum: 0x0
+; XCOFF-NEXT:    SymbolAlignmentLog2: 0
+; XCOFF-NEXT:    SymbolType: XTY_ER (0x0)
+; XCOFF-NEXT:    StorageMappingClass: XMC_UA (0x4)
+; XCOFF32:       StabInfoIndex: 0x0
+; XCOFF32-NEXT:  StabSectNum: 0x0
+; XCOFF64:       Auxiliary Type: AUX_CSECT (0xFB)

llvm/test/CodeGen/PowerPC/aix-dwarf.ll

 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --section-headers %t.o | FileCheck %s --check-prefix=SEC
-; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers %t.o | FileCheck %s --check-prefixes=SEC,SEC32
 ; RUN: llvm-objdump -r %t.o | FileCheck %s --check-prefix=RELO
 
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --section-headers %t64.o | FileCheck %s --check-prefixes=SEC,SEC64
+; RUN: llvm-objdump -r %t64.o | FileCheck %s --check-prefix=RELO64
+
 ; This file is copied from test/DebugInfo/XCOFF/empty.ll.
 ; In this test, we focus on XCOFF related formats, like section headers,
 ; relocation entries.
 
 source_filename = "1.c"
 target datalayout = "E-m:a-p:32:32-i64:64-n32"
 
 ; Function Attrs: noinline nounwind optnone

 !6 = !{i32 7, !"PIC Level", i32 2}
 !7 = !{!"clang version 12.0.0"}
 !8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !9, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !9 = !DISubroutineType(types: !10)
 !10 = !{!11}
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DILocation(line: 3, column: 3, scope: !8)
 
-; SEC:       AddressSize: 32bit
-; SEC-NEXT:  Sections [
+; SEC:       Sections [
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 1
 ; SEC-NEXT:      Name: .text
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC-NEXT:      Size: 0x28
-; SEC-NEXT:      RawDataOffset: 0xDC
+; SEC32-NEXT:    RawDataOffset: 0xDC
+; SEC64-NEXT:    RawDataOffset: 0x180
 ; SEC-NEXT:      RelocationPointer: 0x0
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 0
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_TEXT (0x20)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 2
 ; SEC-NEXT:      Name: .data
 ; SEC-NEXT:      PhysicalAddress: 0x28
 ; SEC-NEXT:      VirtualAddress: 0x28
-; SEC-NEXT:      Size: 0xC
-; SEC-NEXT:      RawDataOffset: 0x104
-; SEC-NEXT:      RelocationPointer: 0x1D8
+; SEC32-NEXT:    Size: 0xC
+; SEC32-NEXT:    RawDataOffset: 0x104
+; SEC32-NEXT:    RelocationPointer: 0x1D8
+; SEC64-NEXT:    Size: 0x18
+; SEC64-NEXT:    RawDataOffset: 0x1A8
+; SEC64-NEXT:    RelocationPointer: 0x2B0
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 2
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DATA (0x40)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 3
 ; SEC-NEXT:      Name: .dwabrev
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC-NEXT:      Size: 0x36
-; SEC-NEXT:      RawDataOffset: 0x110
+; SEC32-NEXT:    RawDataOffset: 0x110
+; SEC64-NEXT:    RawDataOffset: 0x1C0
 ; SEC-NEXT:      RelocationPointer: 0x0
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 0
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 4
 ; SEC-NEXT:      Name: .dwinfo
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
-; SEC-NEXT:      Size: 0x57
-; SEC-NEXT:      RawDataOffset: 0x148
-; SEC-NEXT:      RelocationPointer: 0x1EC
+; SEC32-NEXT:    Size: 0x57
+; SEC32-NEXT:    RawDataOffset: 0x148
+; SEC32-NEXT:    RelocationPointer: 0x1EC
+; SEC64-NEXT:    Size: 0x6F
+; SEC64-NEXT:    RawDataOffset: 0x1F8
+; SEC64-NEXT:    RelocationPointer: 0x2CC
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 4
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 5
 ; SEC-NEXT:      Name: .dwline
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
-; SEC-NEXT:      Size: 0x36
-; SEC-NEXT:      RawDataOffset: 0x1A0
-; SEC-NEXT:      RelocationPointer: 0x214
+; SEC32-NEXT:    Size: 0x36
+; SEC32-NEXT:    RawDataOffset: 0x1A0
+; SEC32-NEXT:    RelocationPointer: 0x214
+; SEC64-NEXT:    Size: 0x46
+; SEC64-NEXT:    RawDataOffset: 0x268
+; SEC64-NEXT:    RelocationPointer: 0x304
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 1
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:  ]
 
 ; RELO:      RELOCATION RECORDS FOR [.dwinfo]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
 ; RELO-NEXT:  00000006 R_POS                    .dwabrev
 ; RELO-NEXT:  00000027 R_POS                    .dwline
 ; RELO-NEXT:  00000009 R_POS                    .text
 ; RELO-NEXT:  0000003a R_POS                    .text
 ; RELO:       RELOCATION RECORDS FOR [.dwline]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
 ; RELO-NEXT:  00000000 R_POS                    .text
+
+; RELO64:      RELOCATION RECORDS FOR [.dwinfo]:
+; RELO64-NEXT: OFFSET           TYPE                     VALUE
+; RELO64-NEXT: 000000000000000e R_POS                    .dwabrev
+; RELO64-NEXT: 000000000000000b R_POS                    .dwline
+; RELO64-NEXT: 0000000000000041 R_POS                    .text
+; RELO64-NEXT: 000000000000004e R_POS                    .text
+; RELO64:      RELOCATION RECORDS FOR [.dwline]:
+; RELO64-NEXT: OFFSET           TYPE                     VALUE
+; RELO64-NEXT: 000000000000000c R_POS                    .text

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT32 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT64 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false \
+; RUN:   -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false \
+; RUN:   -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM64 %s
 
 @foo_ext_weak_p = global void (...)* bitcast (void ()* @foo_ext_weak_ref to void (...)*)
 @b_w = extern_weak global i32
 
 declare extern_weak void @foo_ext_weak_ref()
 
 define i32 @main() {
 entry:

 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+1]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+2]]
 ; CHECKSYM-NEXT:     Name: foo_ext_weak_ref
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+3]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+4]]
 ; CHECKSYM-NEXT:     Name: b_w
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+5]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_UA (0x4)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+6]]
 ; CHECKSYM-NEXT:     Name: .foo_ext_weak_ref
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+7]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+8]]
 ; CHECKSYM-NEXT:     Name: foo_ext_weak
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+9]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+10]]
 ; CHECKSYM-NEXT:     Name: .text
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
 ; CHECKSYM-NEXT:       SectionLen: 80
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+12]]
 ; CHECKSYM-NEXT:     Name: .main
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+13]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+10]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+14]]
 ; CHECKSYM-NEXT:     Name: .data
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+15]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+16]]
 ; CHECKSYM-NEXT:     Name: foo_ext_weak_p
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+17]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+14]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+18]]
 ; CHECKSYM-NEXT:     Name: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x54
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x54
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x58
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+19]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+20]]
 ; CHECKSYM-NEXT:     Name: TOC
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x60
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x60
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x70
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+21]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+22]]
 ; CHECKSYM-NEXT:     Name: foo_ext_weak_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x60
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x60
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x70
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+23]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+24]]
 ; CHECKSYM-NEXT:     Name: b_w
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x64
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x64
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x78
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+25]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-extern.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT32 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT64 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false \
+; RUN:   -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:   -mattr=-altivec -data-sections=false -xcoff-traceback-table=false \
+; RUN:   -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM64 %s
 
 @bar_p = global i32 (...)* @bar_ref, align 4
 @b_e = external global i32, align 4
 
 ; Function Attrs: noinline nounwind optnone
 define void @foo() {
 entry:
   ret void

 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+1]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+2]]
 ; CHECKSYM-NEXT:     Name: .bar_ref
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+3]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+4]]
 ; CHECKSYM-NEXT:     Name: bar_ref
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+5]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+6]]
 ; CHECKSYM-NEXT:     Name: b_e
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+7]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_UA (0x4)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+8]]
 ; CHECKSYM-NEXT:     Name: bar_extern
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: N_UNDEF
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+9]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+10]]
 ; CHECKSYM-NEXT:     Name: .text
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
 ; CHECKSYM-NEXT:       SectionLen: 112
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+12]]
 ; CHECKSYM-NEXT:     Name: .foo
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+13]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+10]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+14]]
 ; CHECKSYM-NEXT:     Name: .main
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x10
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+15]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+10]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+16]]
 ; CHECKSYM-NEXT:     Name: .data
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+17]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+18]]
 ; CHECKSYM-NEXT:     Name: bar_p
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+19]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+16]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+20]]
 ; CHECKSYM-NEXT:     Name: foo
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x74
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x74
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x78
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+21]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+22]]
 ; CHECKSYM-NEXT:     Name: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x80
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x80
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x90
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+23]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+24]]
 ; CHECKSYM-NEXT:     Name: TOC
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x8C
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xA8
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+25]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+26]]
 ; CHECKSYM-NEXT:     Name: b_e
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x8C
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xA8
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+27]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+28]]
 ; CHECKSYM-NEXT:     Name: bar_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x90
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xB0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+29]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-func-align.ll

 ; This test tries to verify if a csect containing code would have the correct alignment.
 
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -xcoff-traceback-table=false < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
 ; RUN:     -xcoff-traceback-table=false < %s | FileCheck %s
 
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -xcoff-traceback-table=false -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYMS,SYMS64 %s
 
 define i32 @foo()  align 32 {
 entry:
   ret i32 0
 }
 
 define i32 @bar()  align 64 {
 entry:

 ; SYMS-NEXT:    CSECT Auxiliary Entry {
 ; SYMS-NEXT:      Index: [[#INDX+1]]
 ; SYMS-NEXT:      SectionLen: 72
 ; SYMS-NEXT:      ParameterHashIndex: 0x0
 ; SYMS-NEXT:      TypeChkSectNum: 0x0
 ; SYMS-NEXT:      SymbolAlignmentLog2: 6
 ; SYMS-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:      StorageMappingClass: XMC_PR (0x0)
-; SYMS-NEXT:      StabInfoIndex: 0x0
-; SYMS-NEXT:      StabSectNum: 0x0
+; SYMS32-NEXT:    StabInfoIndex: 0x0
+; SYMS32-NEXT:    StabSectNum: 0x0
+; SYMS64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:    }
 ; SYMS-NEXT:  }

llvm/test/CodeGen/PowerPC/aix-internal.ll

 ; RUN: llc -mtriple powerpc-ibm-aix -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
-; RUN: -filetype=obj -o %t.o < %s
+; RUN:   -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mtriple powerpc64-ibm-aix -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
+; RUN:   -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck %s
 
 define internal i32 @foo() {
   ret i32 1
 }
 
-; CHECK:  Symbol {
-; CHECK:       Name: .foo
-; CHECK-NEXT:  Value (RelocatableAddress):
-; CHECK-NEXT:  Section: .text
-; CHECK-NEXT:  Type: 0x0
-; CHECK-NEXT:  StorageClass: C_HIDEXT (0x6B)
+; CHECK:      Symbol {
+; CHECK:        Name: .foo
+; CHECK-NEXT:   Value (RelocatableAddress):
+; CHECK-NEXT:   Section: .text
+; CHECK-NEXT:   Type: 0x0
+; CHECK-NEXT:   StorageClass: C_HIDEXT (0x6B)
 
-; CHECK:  Symbol {
-; CHECK-NEXT: Index: [[#INDX:]]
-; CHECK-NEXT: Name: foo
-; CHECK-NEXT: Value (RelocatableAddress):
-; CHECK-NEXT: Section: .data
-; CHECK-NEXT: Type: 0x0
-; CHECK-NEXT: StorageClass: C_HIDEXT (0x6B)
-; CHECK-NEXT: NumberOfAuxEntries: 1
-; CHECK-NEXT: CSECT Auxiliary Entry {
-; CHECK-NEXT:  Index: [[#INDX+1]]
-; CHECK-NEXT:  SectionLen: 12
-; CHECK-NEXT:  ParameterHashIndex:
-; CHECK-NEXT:  TypeChkSectNum:
-; CHECK-NEXT:  SymbolAlignmentLog2:
-; CHECK-NEXT:  SymbolType: XTY_SD (0x1)
-; CHECK-NEXT:  StorageMappingClass: XMC_DS (0xA)
+; CHECK:      Symbol {
+; CHECK-NEXT:   Index: [[#INDX:]]
+; CHECK-NEXT:   Name: foo
+; CHECK-NEXT:   Value (RelocatableAddress):
+; CHECK-NEXT:   Section: .data
+; CHECK-NEXT:   Type: 0x0
+; CHECK-NEXT:   StorageClass: C_HIDEXT (0x6B)
+; CHECK-NEXT:   NumberOfAuxEntries: 1
+; CHECK-NEXT:   CSECT Auxiliary Entry {
+; CHECK-NEXT:     Index: [[#INDX+1]]
+; CHECK-NEXT:     SectionLen:
+; CHECK-NEXT:     ParameterHashIndex:
+; CHECK-NEXT:     TypeChkSectNum:
+; CHECK-NEXT:     SymbolAlignmentLog2:
+; CHECK-NEXT:     SymbolType: XTY_SD (0x1)
+; CHECK-NEXT:     StorageMappingClass: XMC_DS (0xA)
 
 ; Make sure no label is emitted.
 ; CHECK-NOT: Name: foo

llvm/test/CodeGen/PowerPC/aix-llvm-intrinsic.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec < %s | \
 ; RUN:   FileCheck %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec < %s | \
 ; RUN:   FileCheck %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
-; RUN: llvm-objdump -r -d --symbol-description %t.o | FileCheck --check-prefix=CHECKRELOC %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM32 %s
+; RUN: llvm-objdump -r -d --symbol-description %t.o | FileCheck --check-prefixes=CHECKRELOC,CHECKRELOC32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM64 %s
+; RUN: llvm-objdump -r -d --symbol-description %t64.o | FileCheck --check-prefixes=CHECKRELOC,CHECKRELOC64 %s
 
 %struct.S = type { i32, i32 }
 
 @s = external global %struct.S, align 4
 
 define void @bar() {
 entry:
   %0 = load i32, i32* getelementptr inbounds (%struct.S, %struct.S* @s, i32 0, i32 1), align 4

 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: 2
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 
-; CHECKRELOC:      00000000 (idx: 7) .bar:
+; CHECKRELOC32:      00000000 (idx: 7) .bar:
+; CHECKRELOC64:      0000000000000000 (idx: 7) .bar:
 ; CHECKRELOC-NEXT:        0: 7c 08 02 a6                        mflr 0
-; CHECKRELOC-NEXT:        4: 90 01 00 08                        stw 0, 8(1)
-; CHECKRELOC-NEXT:        8: 94 21 ff c0                        stwu 1, -64(1)
-; CHECKRELOC-NEXT:        c: 80 62 00 00                        lwz 3, 0(2)
-; CHECKRELOC-NEXT:                      0000000e:  R_TOC        (idx: 13) s[TC]
+; CHECKRELOC32-NEXT:        4: 90 01 00 08                      stw 0, 8(1)
+; CHECKRELOC32-NEXT:        8: 94 21 ff c0                      stwu 1, -64(1)
+; CHECKRELOC32-NEXT:        c: 80 62 00 00                      lwz 3, 0(2)
+; CHECKRELOC64-NEXT:        4: f8 01 00 10                      std 0, 16(1)
+; CHECKRELOC64-NEXT:        8: f8 21 ff 91                      stdu 1, -112(1)
+; CHECKRELOC64-NEXT:        c: e8 62 00 00                      ld 3, 0(2)
+; CHECKRELOC32-NEXT:    0000000e:  R_TOC        (idx: 13) s[TC]
+; CHECKRELOC64-NEXT:    000000000000000e:  R_TOC  (idx: 13) s[TC]
 ; CHECKRELOC-NEXT:       10: 80 83 00 04                        lwz 4, 4(3)
 ; CHECKRELOC-NEXT:       14: 7c 85 23 78                        mr 5, 4
 ; CHECKRELOC-NEXT:       18: 4b ff ff e9                        bl 0x0
-; CHECKRELOC-NEXT:                      00000018:  R_RBR        (idx: 1) .memset[PR]
+; CHECKRELOC32-NEXT:    00000018:  R_RBR        (idx: 1) .memset[PR]
+; CHECKRELOC64-NEXT:    0000000000000018:  R_RBR  (idx: 1) .memset[PR]

llvm/test/CodeGen/PowerPC/aix-return55.ll

 ; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc-ibm-aix-xcoff \
 ; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false < %s | FileCheck %s
 ; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc-ibm-aix-xcoff \
 ; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
-; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=CHECKOBJ %s
-; RUN: llvm-readobj -S %t.o | FileCheck --check-prefix=CHECKSECT %s
+; RUN: llvm-objdump -D %t.o | FileCheck --check-prefixes=CHECKOBJ,CHECKOBJ32 %s
+; RUN: llvm-readobj -S %t.o | FileCheck --check-prefixes=CHECKSECT,CHECKSECT32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false \
+; RUN:     -filetype=obj -o %t64.o < %s
+; RUN: llvm-objdump -D %t64.o | FileCheck --check-prefixes=CHECKOBJ,CHECKOBJ64 %s
+; RUN: llvm-readobj -S %t64.o | FileCheck --check-prefixes=CHECKSECT,CHECKSECT64 %s
 
 @a = global i64 320255973571806, align 8
 @d = global double 5.000000e+00, align 8
 @strA = private unnamed_addr constant [10 x i8] c"hellowor\0A\00", align 1
 
 define dso_local signext i32 @foo() {
 entry:
   ret i32 55
 ; CHECK-LABEL: .foo:
 ; CHECK: li 3, 55
 ; CHECK: blr
 }
 
-;CHECKOBJ:      00000000 <.foo>:
+;CHECKOBJ32:    00000000 <.foo>:
+;CHECKOBJ64:    0000000000000000 <.foo>:
 ;CHECKOBJ-NEXT:       0: 38 60 00 37                    li 3, 55
 ;CHECKOBJ-NEXT:       4: 4e 80 00 20                    blr{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000008 <.rodata.str1.1>:
+;CHECKOBJ32-NEXT: 00000008 <.rodata.str1.1>:
+;CHECKOBJ64-NEXT: 0000000000000008 <.rodata.str1.1>:
 ;CHECKOBJ-NEXT:       8: 68 65 6c 6c                   xori 5, 3, 27756
 ;CHECKOBJ-NEXT:       c: 6f 77 6f 72 xoris 23, 27, 28530
 ;CHECKOBJ-NEXT:      10: 0a 00 00 00 tdlti 0, 0{{[[:space:]] *}}
-;CHECKOBJ-NEXT: Disassembly of section .data:{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000018 <a>:
+;CHECKOBJ-NEXT:   Disassembly of section .data:{{[[:space:]] *}}
+;CHECKOBJ32-NEXT: 00000018 <a>:
+;CHECKOBJ64-NEXT: 0000000000000018 <a>:
 ;CHECKOBJ-NEXT:      18: 00 01 23 45                   <unknown>
 ;CHECKOBJ-NEXT:      1c: 67 8a bc de                   oris 10, 28, 48350{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000020 <d>:
+;CHECKOBJ32-NEXT: 00000020 <d>:
+;CHECKOBJ64-NEXT: 0000000000000020 <d>:
 ;CHECKOBJ-NEXT:      20: 40 14 00 00                   bdnzf   20, 0x20
 ;CHECKOBJ-NEXT:      24: 00 00 00 00                   <unknown>{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000028 <foo>:
-;CHECKOBJ-NEXT:      28: 00 00 00 00                   <unknown>
-;CHECKOBJ-NEXT:      2c: 00 00 00 34                   <unknown>
-;CHECKOBJ-NEXT:      30: 00 00 00 00                   <unknown>
+;CHECKOBJ32-NEXT: 00000028 <foo>:
+;CHECKOBJ32-NEXT:    28: 00 00 00 00                   <unknown>
+;CHECKOBJ32-NEXT:    2c: 00 00 00 34                   <unknown>
+;CHECKOBJ32-NEXT:    30: 00 00 00 00                   <unknown>
+;CHECKOBJ64-NEXT: 0000000000000028 <foo>:
+;CHECKOBJ64-NEXT:    ...
+;CHECKOBJ64-NEXT:    34: 00 00 00 40    <unknown>
 
 ;CHECKSECT: Sections [
 ;CHECKSECT-NEXT:   Section {
 ;CHECKSECT-NEXT:     Index: 1
 ;CHECKSECT-NEXT:     Name: .text
 ;CHECKSECT-NEXT:     PhysicalAddress: 0x0
 ;CHECKSECT-NEXT:     VirtualAddress: 0x0
 ;CHECKSECT-NEXT:     Size: 0x14
-;CHECKSECT-NEXT:     RawDataOffset: 0x64
+;CHECKSECT32-NEXT:   RawDataOffset: 0x64
+;CHECKSECT64-NEXT:   RawDataOffset: 0xA8
 ;CHECKSECT-NEXT:     RelocationPointer: 0x0
 ;CHECKSECT-NEXT:     LineNumberPointer: 0x0
 ;CHECKSECT-NEXT:     NumberOfRelocations: 0
 ;CHECKSECT-NEXT:     NumberOfLineNumbers: 0
 ;CHECKSECT-NEXT:     Type: STYP_TEXT (0x20)
 ;CHECKSECT-NEXT:   }
 ;CHECKSECT-NEXT:   Section {
 ;CHECKSECT-NEXT:     Index: 2
 ;CHECKSECT-NEXT:     Name: .data
 ;CHECKSECT-NEXT:     PhysicalAddress: 0x18
 ;CHECKSECT-NEXT:     VirtualAddress: 0x18
-;CHECKSECT-NEXT:     Size: 0x1C
-;CHECKSECT-NEXT:     RawDataOffset: 0x78
-;CHECKSECT-NEXT:     RelocationPointer: 0x94
+;CHECKSECT32-NEXT:   Size: 0x1C
+;CHECKSECT32-NEXT:   RawDataOffset: 0x78
+;CHECKSECT32-NEXT:   RelocationPointer: 0x94
+;CHECKSECT64-NEXT:   Size: 0x28
+;CHECKSECT64-NEXT:   RawDataOffset: 0xBC
+;CHECKSECT64-NEXT:   RelocationPointer: 0xE4
 ;CHECKSECT-NEXT:     LineNumberPointer: 0x0
 ;CHECKSECT-NEXT:     NumberOfRelocations: 2
 ;CHECKSECT-NEXT:     NumberOfLineNumbers: 0
 ;CHECKSECT-NEXT:     Type: STYP_DATA (0x40)
 ;CHECKSECT-NEXT:   }
 ;CHECKSECT-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-weak.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -xcoff-traceback-table=false -mcpu=pwr4 \
 ; RUN:   -mattr=-altivec -data-sections=false < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -xcoff-traceback-table=false -mcpu=pwr4 \
 ; RUN:   -mattr=-altivec -data-sections=false < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -xcoff-traceback-table=false -mcpu=pwr4 \
 ; RUN:   -mattr=-altivec -data-sections=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -xcoff-traceback-table=false -mcpu=pwr4 \
+; RUN:   -mattr=-altivec -data-sections=false -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=CHECKSYM,CHECKSYM64 %s
 
 @foo_weak_p = global void (...)* bitcast (void ()* @foo_ref_weak to void (...)*), align 4
 @b = weak global i32 0, align 4
 
 define weak void @foo_weak(i32* %p)  {
 entry:
   %p.addr = alloca i32*, align 4
   store i32* %p, i32** %p.addr, align 4

 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+1]]
 ; CHECKSYM-NEXT:       SectionLen: 136
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+2]]
 ; CHECKSYM-NEXT:     Name: .foo_weak
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+3]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+4]]
 ; CHECKSYM-NEXT:     Name: .foo_ref_weak
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x20
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+5]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+6]]
 ; CHECKSYM-NEXT:     Name: .main
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x30
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+7]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+8]]
 ; CHECKSYM-NEXT:     Name: .data
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+9]]
-; CHECKSYM-NEXT:       SectionLen: 8
+; CHECKSYM32-NEXT:     SectionLen: 8
+; CHECKSYM64-NEXT:     SectionLen: 12
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+10]]
 ; CHECKSYM-NEXT:     Name: foo_weak_p
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+12]]
 ; CHECKSYM-NEXT:     Name: b
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x8C
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x90
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+13]]
 ; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
 ; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+14]]
 ; CHECKSYM-NEXT:     Name: foo_weak
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x90
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0x98
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+15]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+16]]
 ; CHECKSYM-NEXT:     Name: foo_ref_weak
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x9C
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0x9C
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xB0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+17]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+18]]
 ; CHECKSYM-NEXT:     Name: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xA8
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0xA8
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xC8
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+19]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM32-NEXT:     SectionLen: 12
+; CHECKSYM64-NEXT:     SectionLen: 24
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+20]]
 ; CHECKSYM-NEXT:     Name: TOC
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB4
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0xB4
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xE0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+21]]
 ; CHECKSYM-NEXT:       SectionLen: 0
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
 ; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+22]]
 ; CHECKSYM-NEXT:     Name: foo_weak_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB4
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0xB4
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xE0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+23]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+24]]
 ; CHECKSYM-NEXT:     Name: b
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB8
+; CHECKSYM32-NEXT:   Value (RelocatableAddress): 0xB8
+; CHECKSYM64-NEXT:   Value (RelocatableAddress): 0xE8
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+25]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM32-NEXT:     SectionLen: 4
+; CHECKSYM64-NEXT:     SectionLen: 8
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM32-NEXT:     SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:     SymbolAlignmentLog2: 3
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; CHECKSYM-NEXT:       StabInfoIndex: 0x0
-; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
+; CHECKSYM32-NEXT:     StabSectNum: 0x0
+; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-xcoff-data-only-notoc.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s 2>&1 | FileCheck %s
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefix=SYMS %s
 
 @a = external global i32, align 4
 @b = external global i64, align 8
 @c = external global i16, align 2
 @globa = common global i32 0, align 4
 
 @ptr = internal global void (...)* null, align 4
 
 ; CHECK-NOT: .toc
 ; SYMS-NOT: Name: TOC

llvm/test/CodeGen/PowerPC/aix-xcoff-data.ll

 ; This file tests the codegen of initialized and common variables in AIX
 ; assembly and XCOFF object files.
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -data-sections=false < %s | FileCheck --check-prefixes=CHECK,CHECK32 %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false < %s | FileCheck --check-prefixes=CHECK,CHECK64 %s
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --section-headers --file-header %t.o | \
 ; RUN:   FileCheck --check-prefix=OBJ %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t64.o < %s
 ; RUN: llvm-readobj --section-headers --file-header %t64.o | \
 ; RUN:   FileCheck --check-prefix=OBJ64 %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYMS,SYMS64 %s
 
 @ivar = local_unnamed_addr global i32 35, align 4
 @llvar = local_unnamed_addr global i64 36, align 8
 @svar = local_unnamed_addr global i16 37, align 2
 @fvar = local_unnamed_addr global float 8.000000e+02, align 4
 @dvar = local_unnamed_addr global double 9.000000e+02, align 8
 @over_aligned = local_unnamed_addr global double 9.000000e+02, align 32
 @chrarray = local_unnamed_addr global [4 x i8] c"abcd", align 1

 ; OBJ-NEXT:     RelocationPointer: 0x0
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 0
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_BSS (0x80)
 ; OBJ-NEXT:   }
 ; OBJ:      ]
 
-; SYMS:      File: {{.*}}aix-xcoff-data.ll.tmp.o
-; SYMS-NEXT: Format: aixcoff-rs6000
-; SYMS-NEXT: Arch: powerpc
-; SYMS-NEXT: AddressSize: 32bit
 ; SYMS:      Symbols [
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: 0
 ; SYMS-NEXT:     Name: .file
 ; SYMS-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYMS-NEXT:     Section: N_DEBUG
 ; SYMS-NEXT:     Source Language ID: TB_C (0x0)
 ; SYMS-NEXT:     CPU Version ID: 0x0

 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+1]]
 ; SYMS-NEXT:       SectionLen: 0
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 2
 ; SYMS-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+2]]
 ; SYMS-NEXT:     Name: .data
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+3]]
 ; SYMS-NEXT:       SectionLen: 128
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 5
 ; SYMS-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+4]]
 ; SYMS-NEXT:     Name: ivar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+5]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+6]]
 ; SYMS-NEXT:     Name: llvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x8
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+7]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+8]]
 ; SYMS-NEXT:     Name: svar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x10
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+9]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+10]]
 ; SYMS-NEXT:     Name: fvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x14
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+11]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+12]]
 ; SYMS-NEXT:     Name: dvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x18
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+13]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+14]]
 ; SYMS-NEXT:     Name: over_aligned
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x20
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+15]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+16]]
 ; SYMS-NEXT:     Name: chrarray
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x28
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+17]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+18]]
 ; SYMS-NEXT:     Name: dblarr
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x30
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+19]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+20]]
 ; SYMS-NEXT:     Name: d_0
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x50
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+21]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+22]]
 ; SYMS-NEXT:     Name: s_0
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x58
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+23]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+24]]
 ; SYMS-NEXT:     Name: f_0
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x5C
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+25]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+26]]
 ; SYMS-NEXT:     Name: astruct
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x60
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+27]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+28]]
 ; SYMS-NEXT:     Name: bstruct
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x70
 ; SYMS-NEXT:     Section: .data
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+29]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+30]]
 ; SYMS-NEXT:     Name: a
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x80
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+31]]
 ; SYMS-NEXT:       SectionLen: 4
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 2
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+32]]
 ; SYMS-NEXT:     Name: b
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x88
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+33]]
 ; SYMS-NEXT:       SectionLen: 8
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 3
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+34]]
 ; SYMS-NEXT:     Name: c
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x90
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+35]]
 ; SYMS-NEXT:       SectionLen: 2
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 1
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+36]]
 ; SYMS-NEXT:     Name: d
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x98
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+37]]
 ; SYMS-NEXT:       SectionLen: 8
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 3
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+38]]
 ; SYMS-NEXT:     Name: f
 ; SYMS-NEXT:     Value (RelocatableAddress): 0xA0
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+39]]
 ; SYMS-NEXT:       SectionLen: 4
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 2
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+40]]
 ; SYMS-NEXT:     Name: over_aligned_comm
 ; SYMS-NEXT:     Value (RelocatableAddress): 0xC0
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+41]]
 ; SYMS-NEXT:       SectionLen: 8
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 5
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+42]]
 ; SYMS-NEXT:     Name: array
 ; SYMS-NEXT:     Value (RelocatableAddress): 0xC8
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+43]]
 ; SYMS-NEXT:       SectionLen: 33
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS:      ]
 
 ; OBJ64:      Format: aix5coff64-rs6000
 ; OBJ64-NEXT: Arch: powerpc64
 ; OBJ64-NEXT: AddressSize: 64bit
 ; OBJ64-NEXT: FileHeader {
 ; OBJ64-NEXT:   Magic: 0x1F7
 ; OBJ64-NEXT:   NumberOfSections: 3
 ; OBJ64-NEXT:   TimeStamp: None (0x0)
 ; OBJ64-NEXT:   SymbolTableOffset: 0x170
-; OBJ64-NEXT:   SymbolTableEntries: 0
+; OBJ64-NEXT:   SymbolTableEntries: 45
 ; OBJ64-NEXT:   OptionalHeaderSize: 0x0
 ; OBJ64-NEXT:   Flags: 0x0
 ; OBJ64-NEXT: }
 
 ; OBJ64:      Sections [
 ; OBJ64-NEXT:   Section {
 ; OBJ64-NEXT:     Index: [[#OBJ64_INDX:]]
 ; OBJ64-NEXT:     Name: .text

llvm/test/CodeGen/PowerPC/aix-xcoff-externL.ll

 ;; Test to make sure a symbol name that starts with an 'L' could be succesfully
 ;; consumed. Note that this could fail if PrivateGlobalPrefix returns
 ;; 'L'/'.L' instead of 'L..' because the resulting symbol gets created as
 ;; a temporary symbol.
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --symbols %t.o | \
-; RUN:   FileCheck --check-prefix=XCOFF32 %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefixes=XCOFF,XCOFF32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --symbols %t64.o | FileCheck --check-prefixes=XCOFF,XCOFF64 %s
 
 @La = external global i32, align 4
 
 declare i32 @Lb(...)
 
 define void @foo() {
 entry:
   store i32 1, i32* @La, align 4
   call i32 bitcast (i32 (...)* @Lb to i32 ()*)()
   ret void
 }
 
-; XCOFF32:         Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .Lb
-; XCOFF32-NEXT:    Value (RelocatableAddress): 0x0
-; XCOFF32-NEXT:    Section: N_UNDEF
-; XCOFF32-NEXT:    Type: 0x0
-; XCOFF32-NEXT:    StorageClass: C_EXT (0x2)
-; XCOFF32-NEXT:    NumberOfAuxEntries: 1
-; XCOFF32-NEXT:    CSECT Auxiliary Entry {
-; XCOFF32-NEXT:      Index: [[#IND+1]]
-; XCOFF32-NEXT:      SectionLen: 0
-; XCOFF32-NEXT:      ParameterHashIndex: 0x0
-; XCOFF32-NEXT:      TypeChkSectNum: 0x0
-; XCOFF32-NEXT:      SymbolAlignmentLog2: 0
-; XCOFF32-NEXT:      SymbolType: XTY_ER (0x0)
-; XCOFF32-NEXT:      StorageMappingClass: XMC_PR (0x0)
-; XCOFF32-NEXT:      StabInfoIndex: 0x0
-; XCOFF32-NEXT:      StabSectNum: 0x0
-; XCOFF32-NEXT:    }
-; XCOFF32-NEXT:  }
-; XCOFF32-NEXT:  Symbol {
-; XCOFF32-NEXT:    Index: [[#IND+2]]
-; XCOFF32-NEXT:    Name: La
-; XCOFF32-NEXT:    Value (RelocatableAddress): 0x0
-; XCOFF32-NEXT:    Section: N_UNDEF
-; XCOFF32-NEXT:    Type: 0x0
-; XCOFF32-NEXT:    StorageClass: C_EXT (0x2)
-; XCOFF32-NEXT:    NumberOfAuxEntries: 1
-; XCOFF32-NEXT:    CSECT Auxiliary Entry {
-; XCOFF32-NEXT:      Index: [[#IND+3]]
-; XCOFF32-NEXT:      SectionLen: 0
-; XCOFF32-NEXT:      ParameterHashIndex: 0x0
-; XCOFF32-NEXT:      TypeChkSectNum: 0x0
-; XCOFF32-NEXT:      SymbolAlignmentLog2: 0
-; XCOFF32-NEXT:      SymbolType: XTY_ER (0x0)
-; XCOFF32-NEXT:      StorageMappingClass: XMC_UA (0x4)
-; XCOFF32-NEXT:      StabInfoIndex: 0x0
-; XCOFF32-NEXT:      StabSectNum: 0x0
-; XCOFF32-NEXT:    }
-; XCOFF32-NEXT:  }
+; XCOFF:         Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .Lb
+; XCOFF-NEXT:    Value (RelocatableAddress): 0x0
+; XCOFF-NEXT:    Section: N_UNDEF
+; XCOFF-NEXT:    Type: 0x0
+; XCOFF-NEXT:    StorageClass: C_EXT (0x2)
+; XCOFF-NEXT:    NumberOfAuxEntries: 1
+; XCOFF-NEXT:    CSECT Auxiliary Entry {
+; XCOFF-NEXT:      Index: [[#IND+1]]
+; XCOFF-NEXT:      SectionLen: 0
+; XCOFF-NEXT:      ParameterHashIndex: 0x0
+; XCOFF-NEXT:      TypeChkSectNum: 0x0
+; XCOFF-NEXT:      SymbolAlignmentLog2: 0
+; XCOFF-NEXT:      SymbolType: XTY_ER (0x0)
+; XCOFF-NEXT:      StorageMappingClass: XMC_PR (0x0)
+; XCOFF32-NEXT:    StabInfoIndex: 0x0
+; XCOFF32-NEXT:    StabSectNum: 0x0
+; XCOFF64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
+; XCOFF-NEXT:    }
+; XCOFF-NEXT:  }
+; XCOFF-NEXT:  Symbol {
+; XCOFF-NEXT:    Index: [[#IND+2]]
+; XCOFF-NEXT:    Name: La
+; XCOFF-NEXT:    Value (RelocatableAddress): 0x0
+; XCOFF-NEXT:    Section: N_UNDEF
+; XCOFF-NEXT:    Type: 0x0
+; XCOFF-NEXT:    StorageClass: C_EXT (0x2)
+; XCOFF-NEXT:    NumberOfAuxEntries: 1
+; XCOFF-NEXT:    CSECT Auxiliary Entry {
+; XCOFF-NEXT:      Index: [[#IND+3]]
+; XCOFF-NEXT:      SectionLen: 0
+; XCOFF-NEXT:      ParameterHashIndex: 0x0
+; XCOFF-NEXT:      TypeChkSectNum: 0x0
+; XCOFF-NEXT:      SymbolAlignmentLog2: 0
+; XCOFF-NEXT:      SymbolType: XTY_ER (0x0)
+; XCOFF-NEXT:      StorageMappingClass: XMC_UA (0x4)
+; XCOFF32-NEXT:    StabInfoIndex: 0x0
+; XCOFF32-NEXT:    StabSectNum: 0x0
+; XCOFF64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
+; XCOFF-NEXT:    }
+; XCOFF-NEXT:  }

llvm/test/CodeGen/PowerPC/aix-xcoff-huge-relocs.ll

 ;; This test generates 65534 relocation entries, an overflow section should
 ;; not be generated.
 ; RUN: grep -v RUN: %s | \
 ; RUN:   sed >%t.ll 's/SIZE/65534/;s/MACRO/#/;s/#/################/g;s/#/################/g;s/#/################/g;s/#/################/g;s/#/#_/g;s/_#_#_\([^#]\)/\1/;s/_/, /g;s/#/i8* @c/g;'
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.ll
 ; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=XCOFF32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+;; An XCOFF64 file may not contain an overflow section header.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t64.o %t.overflow.ll
+; RUN: llvm-readobj --section-headers %t64.o | FileCheck --check-prefix=XCOFF64 %s
 
 @c = external global i8, align 1
 @arr = global [SIZE x i8*] [MACRO], align 8
 
 ; XCOFF32-NOT:     Name: .ovrflo
 ; XCOFF32-NOT:     Type: STYP_OVRFLO
 ; XCOFF32:       Section {
 ; XCOFF32:         Name: .data
 ; XCOFF32-NEXT:    PhysicalAddress: 0x0
 ; XCOFF32-NEXT:    VirtualAddress: 0x0
 ; XCOFF32-NEXT:    Size: 0x3FFF8
 ; XCOFF32-NEXT:    RawDataOffset: 0x64
 ; XCOFF32-NEXT:    RelocationPointer: 0x4005C
 ; XCOFF32-NEXT:    LineNumberPointer: 0x0
 ; XCOFF32-NEXT:    NumberOfRelocations: 65534
 ; XCOFF32-NEXT:    NumberOfLineNumbers: 0
 ; XCOFF32-NEXT:    Type: STYP_DATA (0x40)
 ; XCOFF32-NEXT:  }
 ; XCOFF32-NOT:     Name: .ovrflo
 ; XCOFF32-NOT:     Type: STYP_OVRFLO
+
+; XCOFF64:      Section {
+; XCOFF64:        Name: .data
+; XCOFF64-NEXT:   PhysicalAddress: 0x0
+; XCOFF64-NEXT:   VirtualAddress: 0x0
+; XCOFF64-NEXT:   Size: 0x7FFF8
+; XCOFF64-NEXT:   RawDataOffset: 0xA8
+; XCOFF64-NEXT:   RelocationPointer: 0x800A0
+; XCOFF64-NEXT:   LineNumberPointer: 0x0
+; XCOFF64-NEXT:   NumberOfRelocations: 65535
+; XCOFF64-NEXT:   NumberOfLineNumbers: 0
+; XCOFF64-NEXT:   Type: STYP_DATA (0x40)
+; XCOFF64-NEXT: }

llvm/test/CodeGen/PowerPC/aix-xcoff-lcomm.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --section-headers --file-header %t.o | \
-; RUN:   FileCheck --check-prefix=OBJ %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
+; RUN:   FileCheck --check-prefixes=OBJ,OBJ32 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t64.o | \
+; RUN:   FileCheck --check-prefixes=OBJ,OBJ64 %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYMS,SYMS64 %s
 
 @a = internal global i32 0, align 4
 @b = internal global i64 0, align 8
 @c = internal global i16 0, align 2
 
 ; CHECK:      .lcomm a,4,a[BS],2
 ; CHECK-NEXT: .lcomm b,8,b[BS],3
 ; CHECK-NEXT: .lcomm c,2,c[BS],1
 
-; OBJ:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
-; OBJ-NEXT: Format: aixcoff-rs6000
-; OBJ-NEXT: Arch: powerpc
-; OBJ-NEXT: AddressSize: 32bit
-; OBJ-NEXT: FileHeader {
-; OBJ-NEXT:   Magic: 0x1DF
-; OBJ-NEXT:   NumberOfSections: 2
-; OBJ-NEXT:   TimeStamp:
-; OBJ-NEXT:   SymbolTableOffset: 0x64
-; OBJ-NEXT:   SymbolTableEntries: 9
-; OBJ-NEXT:   OptionalHeaderSize: 0x0
-; OBJ-NEXT:   Flags: 0x0
-; OBJ-NEXT: }
-; OBJ-NEXT: Sections [
-; OBJ:        Section {{[{][[:space:]] *}}Index: 2
-; OBJ-NEXT:     Name: .bss
-; OBJ-NEXT:     PhysicalAddress: 0x0
-; OBJ-NEXT:     VirtualAddress: 0x0
-; OBJ-NEXT:     Size: 0x14
-; OBJ-NEXT:     RawDataOffset: 0x0
-; OBJ-NEXT:     RelocationPointer: 0x0
-; OBJ-NEXT:     LineNumberPointer: 0x0
-; OBJ-NEXT:     NumberOfRelocations: 0
-; OBJ-NEXT:     NumberOfLineNumbers: 0
-; OBJ-NEXT:     Type: STYP_BSS (0x80)
-; OBJ-NEXT:   }
-; OBJ-NEXT: ]
+; OBJ:        Arch: powerpc
+; OBJ32-NEXT: AddressSize: 32bit
+; OBJ64-NEXT: AddressSize: 64bit
+; OBJ-NEXT:   FileHeader {
+; OBJ32-NEXT:   Magic: 0x1DF
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ-NEXT:     NumberOfSections: 2
+; OBJ-NEXT:     TimeStamp:
+; OBJ32-NEXT:   SymbolTableOffset: 0x64
+; OBJ64-NEXT:   SymbolTableOffset: 0xA8
+; OBJ-NEXT:     SymbolTableEntries: 9
+; OBJ-NEXT:     OptionalHeaderSize: 0x0
+; OBJ-NEXT:     Flags: 0x0
+; OBJ-NEXT:   }
+; OBJ-NEXT:   Sections [
+; OBJ:          Section {{[{][[:space:]] *}}Index: 2
+; OBJ-NEXT:       Name: .bss
+; OBJ-NEXT:       PhysicalAddress: 0x0
+; OBJ-NEXT:       VirtualAddress: 0x0
+; OBJ-NEXT:       Size: 0x14
+; OBJ-NEXT:       RawDataOffset: 0x0
+; OBJ-NEXT:       RelocationPointer: 0x0
+; OBJ-NEXT:       LineNumberPointer: 0x0
+; OBJ-NEXT:       NumberOfRelocations: 0
+; OBJ-NEXT:       NumberOfLineNumbers: 0
+; OBJ-NEXT:       Type: STYP_BSS (0x80)
+; OBJ-NEXT:     }
+; OBJ-NEXT:   ]
 
-; SYMS:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
-; SYMS-NEXT: Format: aixcoff-rs6000
-; SYMS-NEXT: Arch: powerpc
-; SYMS-NEXT: AddressSize: 32bit
-; SYMS-NEXT: Symbols [
+; SYMS:      Symbols [
 ; SYMS:        Symbol {{[{][[:space:]] *}}Index: [[#Index:]]{{[[:space:]] *}}Name: a
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#Index + 1]]
 ; SYMS-NEXT:       SectionLen: 4
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 2
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_BS (0x9)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: [[#Index + 2]]
 ; SYMS-NEXT:     Name: b
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x8
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#Index + 3]]
 ; SYMS-NEXT:       SectionLen: 8
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 3
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_BS (0x9)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: [[#Index + 4]]
 ; SYMS-NEXT:     Name: c
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x10
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#Index + 5]]
 ; SYMS-NEXT:       SectionLen: 2
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 1
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_BS (0x9)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-xcoff-lower-comm.ll

 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,ASM32 %s
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,ASM64 %s
 
-; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj -r --expand-relocs --syms %t.o | FileCheck --check-prefixes=RELOC,SYM %s
-
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -data-sections=false \
+; RUN:   -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj -r --expand-relocs --syms %t.o | FileCheck --check-prefixes=RELOC,SYM,RELOC32,SYM32 %s
+
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false \
+; RUN:   -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj -r --expand-relocs --syms %t64.o | FileCheck --check-prefixes=RELOC,SYM,RELOC64,SYM64 %s
 
 @common = common global i32 0, align 4
 @pointer = global i32* @common, align 4
 
 
 ; CHECK:             .comm   common[RW],4,2
 ; ASM32-NEXT:        .csect .data[RW],2
 ; ASM64-NEXT:        .csect .data[RW],3
 ; CHECK-NEXT:        .globl  pointer
 ; ASM32-NEXT:        .align  2
 ; ASM64-NEXT:        .align  3
 ; CHECK-NEXT:pointer:
 ; ASM32-NEXT:        .vbyte 4, common[RW]
 ; ASM64-NEXT:        .vbyte 8, common[RW]
 
 
 ; RELOC:      Relocations [
 ; RELOC-NEXT:   Section (index: {{[0-9]+}}) .data {
 ; RELOC-NEXT:   Relocation {
 ; RELOC-NEXT:     Virtual Address: 0x0
 ; RELOC-NEXT:     Symbol: common ([[#COM_INDX:]])
 ; RELOC-NEXT:     IsSigned: No
 ; RELOC-NEXT:     FixupBitValue: 0
-; RELOC-NEXT:     Length: 32
+; RELOC32-NEXT:   Length: 32
+; RELOC64-NEXT:   Length: 64
 ; RELOC-NEXT:     Type: R_POS (0x0)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT: }
 ; RELOC-NEXT: ]
 
 ; SYM:        Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .data
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+1]]
-; SYM-NEXT:       SectionLen: 4
+; SYM32-NEXT:     SectionLen: 4
+; SYM64-NEXT:     SectionLen: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
+; SYM32-NEXT:     SymbolAlignmentLog2: 2
+; SYM64-NEXT:     SymbolAlignmentLog2: 3
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+2]]
 ; SYM-NEXT:     Name: pointer
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+3]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#COM_INDX]]
 ; SYM-NEXT:     Name: common
-; SYM-NEXT:     Value (RelocatableAddress): 0x4
+; SYM32-NEXT:   Value (RelocatableAddress): 0x4
+; SYM64-NEXT:   Value (RelocatableAddress): 0x8
 ; SYM-NEXT:     Section: .bss
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#COM_INDX+1]]
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc-large.ll

 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -filetype=obj -code-model=large -o %t.o < %s
 ; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck --check-prefixes=RELOC %s
 ; RUN: llvm-objdump -D -r --symbol-description %t.o | FileCheck --check-prefix=DIS %s
 
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -filetype=obj -code-model=large -o %t64.o < %s
+; RUN: llvm-readobj --relocs --expand-relocs %t64.o | FileCheck --check-prefixes=RELOC64 %s
+; RUN: llvm-objdump -D -r --symbol-description %t64.o | FileCheck --check-prefix=DIS64 %s
+
 @a = global i32 2, align 4
 @b = global i32 10, align 4
 @c = global i32 11, align 4
 
 define i32 @foo() {
 entry:
   %0 = load i32, i32* @a, align 4
   %1 = load i32, i32* @b, align 4

 ; DIS-NEXT:         18: 3c a2 00 00   addis 5, 2, 0
 ; DIS-NEXT:                           0000001a:  R_TOCU       (idx: [[#INDX+4]]) c[TE]
 ; DIS-NEXT:         1c: 80 a5 00 08   lwz 5, 8(5)
 ; DIS-NEXT:                           0000001e:  R_TOCL       (idx: [[#INDX+4]]) c[TE]
 ; DIS-NEXT:         20: 7c 63 22 14   add 3, 3, 4
 ; DIS-NEXT:         24: 80 a5 00 00   lwz 5, 0(5)
 ; DIS-NEXT:         28: 7c 63 2a 14   add 3, 3, 5
 ; DIS-NEXT:         2c: 4e 80 00 20   blr
+
+; RELOC64:       Section (index: {{[0-9]+}}) .text {
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0x2
+; RELOC64-NEXT:      Symbol: a ([[#INDX:]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCU (0x30)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0x6
+; RELOC64-NEXT:      Symbol: b ([[#INDX+2]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCU (0x30)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0xA
+; RELOC64-NEXT:      Symbol: c ([[#INDX+4]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCU (0x30)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0xE
+; RELOC64-NEXT:      Symbol: a ([[#INDX]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCL (0x31)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0x12
+; RELOC64-NEXT:      Symbol: b ([[#INDX+2]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCL (0x31)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:    Relocation {
+; RELOC64-NEXT:      Virtual Address: 0x16
+; RELOC64-NEXT:      Symbol: c ([[#INDX+4]])
+; RELOC64-NEXT:      IsSigned: No
+; RELOC64-NEXT:      FixupBitValue: 0
+; RELOC64-NEXT:      Length: 16
+; RELOC64-NEXT:      Type: R_TOCL (0x31)
+; RELOC64-NEXT:    }
+; RELOC64-NEXT:  }
+
+; DIS64:      Disassembly of section .text:
+; DIS64-EMPTY:
+; DIS64-NEXT: 0000000000000000 (idx: 3) .foo:
+; DIS64-NEXT:        0: 3c 62 00 00   addis 3, 2, 0
+; DIS64-NEXT:     0000000000000002:  R_TOCU (idx: [[#INDX:]]) a[TE]
+; DIS64-NEXT:        4: 3c 82 00 00   addis 4, 2, 0
+; DIS64-NEXT:     0000000000000006:  R_TOCU (idx: [[#INDX+2]]) b[TE]
+; DIS64-NEXT:        8: 3c a2 00 00   addis 5, 2, 0
+; DIS64-NEXT:     000000000000000a:  R_TOCU (idx: [[#INDX+4]]) c[TE]
+; DIS64-NEXT:        c: e8 63 00 00   ld 3, 0(3)
+; DIS64-NEXT:     000000000000000e:  R_TOCL (idx: [[#INDX]]) a[TE]
+; DIS64-NEXT:       10: e8 84 00 08   ld 4, 8(4)
+; DIS64-NEXT:     0000000000000012:  R_TOCL (idx: [[#INDX+2]]) b[TE]
+; DIS64-NEXT:       14: e8 a5 00 10   ld 5, 16(5)
+; DIS64-NEXT:     0000000000000016:  R_TOCL (idx: [[#INDX+4]]) c[TE]
+; DIS64-NEXT:       18: 80 63 00 00   lwz 3, 0(3)
+; DIS64-NEXT:       1c: 80 84 00 00   lwz 4, 0(4)
+; DIS64-NEXT:       20: 80 a5 00 00   lwz 5, 0(5)
+; DIS64-NEXT:       24: 7c 63 22 14   add 3, 3, 4
+; DIS64-NEXT:       28: 7c 63 2a 14   add 3, 3, 5
+; DIS64-NEXT:       2c: 4e 80 00 20   blr

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc.ll

 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -mattr=-altivec \
 ; RUN:     -xcoff-traceback-table=false -data-sections=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --section-headers --file-header %t.o | \
-; RUN:   FileCheck --check-prefix=OBJ %s
-; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck --check-prefix=RELOC %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYM %s
+; RUN: llvm-readobj --section-headers --file-header %t.o | FileCheck --check-prefixes=OBJ,OBJ32 %s
+; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck --check-prefixes=RELOC,RELOC32 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYM,SYM32 %s
 ; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=DIS %s
 ; RUN: llvm-objdump -r %t.o | FileCheck --check-prefix=DIS_REL %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -mattr=-altivec \
+; RUN:     -xcoff-traceback-table=false -data-sections=false -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t64.o | FileCheck --check-prefixes=OBJ,OBJ64 %s
+; RUN: llvm-readobj --relocs --expand-relocs %t64.o | FileCheck --check-prefixes=RELOC,RELOC64 %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYM,SYM64 %s
+; RUN: llvm-objdump -D %t64.o | FileCheck --check-prefix=DIS64 %s
+; RUN: llvm-objdump -r %t64.o | FileCheck --check-prefix=DIS_REL64 %s
 
 @globalA = global i32 1, align 4
 @globalB = global i32 2, align 4
 @arr = global <{ i32, [9 x i32] }> <{ i32 3, [9 x i32] zeroinitializer }>, align 4
 @p = global i32* bitcast (i8* getelementptr (i8, i8* bitcast (<{ i32, [9 x i32] }>* @arr to i8*), i64 16) to i32*), align 4
 
 define i32 @foo() {
 entry:
   %call = call i32 @bar(i32 1)
   %0 = load i32, i32* @globalA, align 4
   %add = add nsw i32 %call, %0
   %1 = load i32, i32* @globalB, align 4
   %add1 = add nsw i32 %add, %1
   ret i32 %add1
 }
 
 declare i32 @bar(i32)
 
-; OBJ:      File: {{.*}}aix-xcoff-reloc.ll.tmp.o
-; OBJ-NEXT: Format: aixcoff-rs6000
-; OBJ-NEXT: Arch: powerpc
-; OBJ-NEXT: AddressSize: 32bit
-; OBJ-NEXT: FileHeader {
-; OBJ-NEXT:   Magic: 0x1DF
-; OBJ-NEXT:   NumberOfSections: 2
-; OBJ-NEXT:   TimeStamp: None (0x0)
-; OBJ-NEXT:   SymbolTableOffset: 0x13C
-; OBJ-NEXT:   SymbolTableEntries: 27
-; OBJ-NEXT:   OptionalHeaderSize: 0x0
-; OBJ-NEXT:   Flags: 0x0
-; OBJ-NEXT: }
+; OBJ:        FileHeader {
+; OBJ32-NEXT:   Magic: 0x1DF
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ-NEXT:     NumberOfSections: 2
+; OBJ-NEXT:     TimeStamp: None (0x0)
+; OBJ32-NEXT:   SymbolTableOffset: 0x13C
+; OBJ64-NEXT:   SymbolTableOffset: 0x1B8
+; OBJ-NEXT:     SymbolTableEntries: 27
+; OBJ-NEXT:     OptionalHeaderSize: 0x0
+; OBJ-NEXT:     Flags: 0x0
+; OBJ-NEXT:   }
 ; OBJ-NEXT: Sections [
 ; OBJ-NEXT:   Section {
 ; OBJ-NEXT:     Index: 1
 ; OBJ-NEXT:     Name: .text
 ; OBJ-NEXT:     PhysicalAddress: 0x0
 ; OBJ-NEXT:     VirtualAddress: 0x0
 ; OBJ-NEXT:     Size: 0x40
-; OBJ-NEXT:     RawDataOffset: 0x64
-; OBJ-NEXT:     RelocationPointer: 0xEC
+; OBJ32-NEXT:   RawDataOffset: 0x64
+; OBJ32-NEXT:   RelocationPointer: 0xEC
+; OBJ64-NEXT:   RawDataOffset: 0xA8
+; OBJ64-NEXT:   RelocationPointer: 0x148
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 3
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_TEXT (0x20)
 ; OBJ-NEXT:   }
 ; OBJ-NEXT:   Section {
 ; OBJ-NEXT:     Index: 2
 ; OBJ-NEXT:     Name: .data
 ; OBJ-NEXT:     PhysicalAddress: 0x40
 ; OBJ-NEXT:     VirtualAddress: 0x40
-; OBJ-NEXT:     Size: 0x48
-; OBJ-NEXT:     RawDataOffset: 0xA4
-; OBJ-NEXT:     RelocationPointer: 0x10A
+; OBJ32-NEXT:   Size: 0x48
+; OBJ32-NEXT:   RawDataOffset: 0xA4
+; OBJ32-NEXT:   RelocationPointer: 0x10A
+; OBJ64-NEXT:   Size: 0x60
+; OBJ64-NEXT:   RawDataOffset: 0xE8
+; OBJ64-NEXT:   RelocationPointer: 0x172
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 5
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_DATA (0x40)
 ; OBJ-NEXT:   }
 ; OBJ-NEXT: ]
 
-
-; RELOC:      File: {{.*}}aix-xcoff-reloc.ll.tmp.o
-; RELOC-NEXT: Format: aixcoff-rs6000
-; RELOC-NEXT: Arch: powerpc
-; RELOC-NEXT: AddressSize: 32bit
-; RELOC-NEXT: Relocations [
+; RELOC:      Relocations [
 ; RELOC-NEXT:   Section (index: 1) .text {
-; RELOC-NEXT:   Relocation {
-; RELOC-NEXT:     Virtual Address: 0x10
-; RELOC-NEXT:     Symbol: .bar (1)
-; RELOC-NEXT:     IsSigned: Yes
-; RELOC-NEXT:     FixupBitValue: 0
-; RELOC-NEXT:     Length: 26
-; RELOC-NEXT:     Type: R_RBR (0x1A)
-; RELOC-NEXT:   }
-; RELOC-NEXT:   Relocation {
-; RELOC-NEXT:     Virtual Address: 0x1A
-; RELOC-NEXT:     Symbol: globalA (23)
-; RELOC-NEXT:     IsSigned: No
-; RELOC-NEXT:     FixupBitValue: 0
-; RELOC-NEXT:     Length: 16
-; RELOC-NEXT:     Type: R_TOC (0x3)
-; RELOC-NEXT:   }
-; RELOC-NEXT:   Relocation {
-; RELOC-NEXT:     Virtual Address: 0x1E
-; RELOC-NEXT:     Symbol: globalB (25)
-; RELOC-NEXT:     IsSigned: No
-; RELOC-NEXT:     FixupBitValue: 0
-; RELOC-NEXT:     Length: 16
-; RELOC-NEXT:     Type: R_TOC (0x3)
-; RELOC-NEXT:   }
-; RELOC-NEXT: }
-; RELOC-NEXT: Section (index: 2) .data {
-; RELOC-NEXT: Relocation {
-; RELOC-NEXT:   Virtual Address: 0x70
-; RELOC-NEXT:   Symbol: arr (15)
-; RELOC-NEXT:   IsSigned: No
-; RELOC-NEXT:   FixupBitValue: 0
-; RELOC-NEXT:   Length: 32
-; RELOC-NEXT:   Type: R_POS (0x0)
-; RELOC-NEXT: }
-; RELOC-NEXT: Relocation {
-; RELOC-NEXT:   Virtual Address: 0x74
-; RELOC-NEXT:   Symbol: .foo (7)
-; RELOC-NEXT:   IsSigned: No
-; RELOC-NEXT:   FixupBitValue: 0
-; RELOC-NEXT:   Length: 32
-; RELOC-NEXT:   Type: R_POS (0x0)
-; RELOC-NEXT: }
-; RELOC-NEXT: Relocation {
-; RELOC-NEXT:   Virtual Address: 0x78
-; RELOC-NEXT:   Symbol: TOC (21)
-; RELOC-NEXT:   IsSigned: No
-; RELOC-NEXT:   FixupBitValue: 0
-; RELOC-NEXT:   Length: 32
-; RELOC-NEXT:   Type: R_POS (0x0)
-; RELOC-NEXT: }
-; RELOC-NEXT: Relocation {
-; RELOC-NEXT:   Virtual Address: 0x80
-; RELOC-NEXT:   Symbol: globalA (11)
-; RELOC-NEXT:   IsSigned: No
-; RELOC-NEXT:   FixupBitValue: 0
-; RELOC-NEXT:   Length: 32
-; RELOC-NEXT:   Type: R_POS (0x0)
-; RELOC-NEXT: }
-; RELOC-NEXT: Relocation {
-; RELOC-NEXT:   Virtual Address: 0x84
-; RELOC-NEXT:   Symbol: globalB (13)
-; RELOC-NEXT:   IsSigned: No
-; RELOC-NEXT:   FixupBitValue: 0
-; RELOC-NEXT:   Length: 32
-; RELOC-NEXT:   Type: R_POS (0x0)
-; RELOC-NEXT: }
-; RELOC-NEXT: }
+; RELOC-NEXT:     Relocation {
+; RELOC-NEXT:       Virtual Address: 0x10
+; RELOC-NEXT:       Symbol: .bar (1)
+; RELOC-NEXT:       IsSigned: Yes
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC-NEXT:       Length: 26
+; RELOC-NEXT:       Type: R_RBR (0x1A)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC-NEXT:       Virtual Address: 0x1A
+; RELOC-NEXT:       Symbol: globalA (23)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC-NEXT:       Length: 16
+; RELOC-NEXT:       Type: R_TOC (0x3)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC-NEXT:       Virtual Address: 0x1E
+; RELOC-NEXT:       Symbol: globalB (25)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC-NEXT:       Length: 16
+; RELOC-NEXT:       Type: R_TOC (0x3)
+; RELOC-NEXT:     }
+; RELOC-NEXT:   }
+; RELOC-NEXT:   Section (index: 2) .data {
+; RELOC-NEXT:     Relocation {
+; RELOC-NEXT:       Virtual Address: 0x70
+; RELOC-NEXT:       Symbol: arr (15)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC32-NEXT:     Length: 32
+; RELOC64-NEXT:     Length: 64
+; RELOC-NEXT:       Type: R_POS (0x0)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC32-NEXT:     Virtual Address: 0x74
+; RELOC64-NEXT:     Virtual Address: 0x78
+; RELOC-NEXT:       Symbol: .foo (7)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC32-NEXT:     Length: 32
+; RELOC64-NEXT:     Length: 64
+; RELOC-NEXT:       Type: R_POS (0x0)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC32-NEXT:     Virtual Address: 0x78
+; RELOC64-NEXT:     Virtual Address: 0x80
+; RELOC-NEXT:       Symbol: TOC (21)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC32-NEXT:     Length: 32
+; RELOC64-NEXT:     Length: 64
+; RELOC-NEXT:       Type: R_POS (0x0)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC32-NEXT:     Virtual Address: 0x80
+; RELOC64-NEXT:     Virtual Address: 0x90
+; RELOC-NEXT:       Symbol: globalA (11)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC32-NEXT:     Length: 32
+; RELOC64-NEXT:     Length: 64
+; RELOC-NEXT:       Type: R_POS (0x0)
+; RELOC-NEXT:     }
+; RELOC-NEXT:     Relocation {
+; RELOC32-NEXT:     Virtual Address: 0x84
+; RELOC64-NEXT:     Virtual Address: 0x98
+; RELOC-NEXT:       Symbol: globalB (13)
+; RELOC-NEXT:       IsSigned: No
+; RELOC-NEXT:       FixupBitValue: 0
+; RELOC32-NEXT:     Length: 32
+; RELOC64-NEXT:     Length: 64
+; RELOC-NEXT:       Type: R_POS (0x0)
+; RELOC-NEXT:     }
+; RELOC-NEXT:   }
 ; RELOC-NEXT: ]
 
 ; SYM:      Symbols [
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 0
 ; SYM-NEXT:     Name: .file
 ; SYM-NEXT:     Value (SymbolTableIndex): 0x0
 ; SYM-NEXT:     Section: N_DEBUG

 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+1]]
 ; SYM-NEXT:       SectionLen: 0
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+2]]
 ; SYM-NEXT:     Name: bar
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: N_UNDEF
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+3]]
 ; SYM-NEXT:       SectionLen: 0
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+4]]
 ; SYM-NEXT:     Name: .text
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+5]]
 ; SYM-NEXT:       SectionLen: 64
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 4
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+6]]
 ; SYM-NEXT:     Name: .foo
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+7]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+4]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+8]]
 ; SYM-NEXT:     Name: .data
 ; SYM-NEXT:     Value (RelocatableAddress): 0x40
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+9]]
-; SYM-NEXT:       SectionLen: 52
+; SYM32-NEXT:     SectionLen: 52
+; SYM64-NEXT:     SectionLen: 56
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
+; SYM32-NEXT:     SymbolAlignmentLog2: 2
+; SYM64-NEXT:     SymbolAlignmentLog2: 3
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+10]]
 ; SYM-NEXT:     Name: globalA
 ; SYM-NEXT:     Value (RelocatableAddress): 0x40
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+11]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+12]]
 ; SYM-NEXT:     Name: globalB
 ; SYM-NEXT:     Value (RelocatableAddress): 0x44
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+13]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+14]]
 ; SYM-NEXT:     Name: arr
 ; SYM-NEXT:     Value (RelocatableAddress): 0x48
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+15]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+16]]
 ; SYM-NEXT:     Name: p
 ; SYM-NEXT:     Value (RelocatableAddress): 0x70
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+17]]
 ; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+18]]
 ; SYM-NEXT:     Name: foo
-; SYM-NEXT:     Value (RelocatableAddress): 0x74
+; SYM32-NEXT:   Value (RelocatableAddress): 0x74
+; SYM64-NEXT:   Value (RelocatableAddress): 0x78
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+19]]
-; SYM-NEXT:       SectionLen: 12
+; SYM32-NEXT:     SectionLen: 12
+; SYM64-NEXT:     SectionLen: 24
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
+; SYM32-NEXT:     SymbolAlignmentLog2: 2
+; SYM64-NEXT:     SymbolAlignmentLog2: 3
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+20]]
 ; SYM-NEXT:     Name: TOC
-; SYM-NEXT:     Value (RelocatableAddress): 0x80
+; SYM32-NEXT:   Value (RelocatableAddress): 0x80
+; SYM64-NEXT:   Value (RelocatableAddress): 0x90
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+21]]
 ; SYM-NEXT:       SectionLen: 0
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+22]]
 ; SYM-NEXT:     Name: globalA
-; SYM-NEXT:     Value (RelocatableAddress): 0x80
+; SYM32-NEXT:   Value (RelocatableAddress): 0x80
+; SYM64-NEXT:   Value (RelocatableAddress): 0x90
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+23]]
-; SYM-NEXT:       SectionLen: 4
+; SYM32-NEXT:     SectionLen: 4
+; SYM64-NEXT:     SectionLen: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
+; SYM32-NEXT:     SymbolAlignmentLog2: 2
+; SYM64-NEXT:     SymbolAlignmentLog2: 3
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+24]]
 ; SYM-NEXT:     Name: globalB
-; SYM-NEXT:     Value (RelocatableAddress): 0x84
+; SYM32-NEXT:   Value (RelocatableAddress): 0x84
+; SYM64-NEXT:   Value (RelocatableAddress): 0x98
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+25]]
-; SYM-NEXT:       SectionLen: 4
+; SYM32-NEXT:     SectionLen: 4
+; SYM64-NEXT:     SectionLen: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
+; SYM32-NEXT:     SymbolAlignmentLog2: 2
+; SYM64-NEXT:     SymbolAlignmentLog2: 3
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
+; SYM32-NEXT:     StabInfoIndex: 0x0
+; SYM32-NEXT:     StabSectNum: 0x0
+; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT: ]
 
 
 ; DIS:      {{.*}}aix-xcoff-reloc.ll.tmp.o:   file format aixcoff-rs6000
 ; DIS:      Disassembly of section .text:
 ; DIS:      00000000 <.foo>:

 ; DIS_REL-NEXT:  0000001e R_TOC                    globalB
 ; DIS_REL:       RELOCATION RECORDS FOR [.data]:
 ; DIS_REL-NEXT:  OFFSET   TYPE                     VALUE
 ; DIS_REL-NEXT:  00000030 R_POS                    arr
 ; DIS_REL-NEXT:  00000034 R_POS                    .foo
 ; DIS_REL-NEXT:  00000038 R_POS                    TOC
 ; DIS_REL-NEXT:  00000040 R_POS                    globalA
 ; DIS_REL-NEXT:  00000044 R_POS                    globalB
+
+; DIS64:      Disassembly of section .text:
+; DIS64:      0000000000000000 <.foo>:
+; DIS64-NEXT:        0: 7c 08 02 a6   mflr 0
+; DIS64-NEXT:        4: f8 01 00 10   std 0, 16(1)
+; DIS64-NEXT:        8: f8 21 ff 91   stdu 1, -112(1)
+; DIS64-NEXT:        c: 38 60 00 01   li 3, 1
+; DIS64-NEXT:       10: 4b ff ff f1   bl 0x0 <.foo>
+; DIS64-NEXT:       14: 60 00 00 00   nop
+; DIS64-NEXT:       18: e8 82 00 00   ld 4, 0(2)
+; DIS64-NEXT:       1c: e8 a2 00 08   ld 5, 8(2)
+; DIS64-NEXT:       20: 80 84 00 00   lwz 4, 0(4)
+; DIS64-NEXT:       24: 80 a5 00 00   lwz 5, 0(5)
+; DIS64-NEXT:       28: 7c 63 22 14   add 3, 3, 4
+; DIS64-NEXT:       2c: 7c 63 2a 14   add 3, 3, 5
+; DIS64-NEXT:       30: 38 21 00 70   addi 1, 1, 112
+; DIS64-NEXT:       34: e8 01 00 10   ld 0, 16(1)
+; DIS64-NEXT:       38: 7c 08 03 a6   mtlr 0
+; DIS64-NEXT:       3c: 4e 80 00 20   blr
+
+; DIS64:      Disassembly of section .data:
+; DIS64:      0000000000000040 <globalA>:
+; DIS64-NEXT:       40: 00 00 00 01   <unknown>
+; DIS64:      0000000000000044 <globalB>:
+; DIS64-NEXT:       44: 00 00 00 02   <unknown>
+; DIS64:      0000000000000048 <arr>:
+; DIS64-NEXT:       48: 00 00 00 03   <unknown>
+; DIS64-NEXT:     ...
+; DIS64:      0000000000000070 <p>:
+; DIS64-NEXT:       70: 00 00 00 00   <unknown>
+; DIS64-NEXT:       74: 00 00 00 58   <unknown>
+; DIS64:      0000000000000078 <foo>:
+; DIS64-NEXT:     ...
+; DIS64-NEXT:       84: 00 00 00 90   <unknown>
+; DIS64-NEXT:     ...
+; DIS64:      0000000000000090 <globalA>:
+; DIS64-NEXT:       90: 00 00 00 00   <unknown>
+; DIS64-NEXT:       94: 00 00 00 40   <unknown>
+; DIS64:      0000000000000098 <globalB>:
+; DIS64-NEXT:       98: 00 00 00 00   <unknown>
+; DIS64-NEXT:       9c: 00 00 00 44   <unknown>
+
+; DIS_REL64:      RELOCATION RECORDS FOR [.text]:
+; DIS_REL64-NEXT: OFFSET           TYPE                     VALUE
+; DIS_REL64-NEXT: 0000000000000010 R_RBR                    .bar
+; DIS_REL64-NEXT: 000000000000001a R_TOC                    globalA
+; DIS_REL64-NEXT: 000000000000001e R_TOC                    globalB
+
+; DIS_REL64:      RELOCATION RECORDS FOR [.data]:
+; DIS_REL64-NEXT: OFFSET           TYPE                     VALUE
+; DIS_REL64-NEXT: 0000000000000030 R_POS                    arr
+; DIS_REL64-NEXT: 0000000000000038 R_POS                    .foo
+; DIS_REL64-NEXT: 0000000000000040 R_POS                    TOC
+; DIS_REL64-NEXT: 0000000000000050 R_POS                    globalA
+; DIS_REL64-NEXT: 0000000000000058 R_POS                    globalB

llvm/test/CodeGen/PowerPC/aix-xcoff-rodata.ll

 ; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,CHECK32 %s
 ; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,CHECK64 %s
 
-; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff -data-sections=false \
+; RUN:   -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --section-headers --file-header %t.o | \
-; RUN:   FileCheck --check-prefix=OBJ %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
+; RUN:   FileCheck --check-prefixes=OBJ,OBJ32 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS32 %s
 ; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=DIS %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false \
+; RUN:   -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t64.o | \
+; RUN:   FileCheck --check-prefixes=OBJ,OBJ64 %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYMS,SYMS64 %s
 
 @const_ivar = constant i32 35, align 4
 @const_llvar = constant i64 36, align 8
 @const_svar = constant i16 37, align 2
 @const_fvar = constant float 8.000000e+02, align 4
 @const_dvar = constant double 9.000000e+02, align 8
 @const_over_aligned = constant double 9.000000e+02, align 32
 @const_chrarray = constant [4 x i8] c"abcd", align 1

 ; CHECK64-NEXT:        .vbyte 8, 0x4000000000000000
 ; CHECK32-NEXT:        .vbyte 4, 1074266112
 ; CHECK32-NEXT:        .vbyte 4, 0
 ; CHECK64-NEXT:        .vbyte 8, 0x4008000000000000
 ; CHECK32-NEXT:        .vbyte 4, 1074790400
 ; CHECK32-NEXT:        .vbyte 4, 0
 ; CHECK64-NEXT:        .vbyte 8, 0x4010000000000000
 
-
-; OBJ:      File: {{.*}}aix-xcoff-rodata.ll.tmp.o
-; OBJ-NEXT: Format: aixcoff-rs6000
-; OBJ-NEXT: Arch: powerpc
-; OBJ-NEXT: AddressSize: 32bit
-; OBJ-NEXT: FileHeader {
-; OBJ-NEXT:   Magic: 0x1DF
+; OBJ:      FileHeader {
+; OBJ32-NEXT: Magic: 0x1DF
+; OBJ64-NEXT: Magic: 0x1F7
 ; OBJ-NEXT:   NumberOfSections: 1
 ; OBJ-NEXT:   TimeStamp: None (0x0)
-; OBJ-NEXT:   SymbolTableOffset: 0x8C
+; OBJ32-NEXT: SymbolTableOffset: 0x8C
+; OBJ64-NEXT: SymbolTableOffset: 0xB0
 ; OBJ-NEXT:   SymbolTableEntries: 21
 ; OBJ-NEXT:   OptionalHeaderSize: 0x0
 ; OBJ-NEXT:   Flags: 0x0
 ; OBJ-NEXT: }
 
 ; OBJ:      Sections [
 ; OBJ:        Section {
 ; OBJ-NEXT:     Index: 1
 ; OBJ-NEXT:     Name: .text
 ; OBJ-NEXT:     PhysicalAddress: 0x0
 ; OBJ-NEXT:     VirtualAddress: 0x0
-; OBJ-NEXT:     Size: 0x50
-; OBJ-NEXT:     RawDataOffset: 0x3C
+; OBJ32-NEXT:   Size: 0x50
+; OBJ32-NEXT:   RawDataOffset: 0x3C
+; OBJ64-NEXT:   Size: 0x50
+; OBJ64-NEXT:   RawDataOffset: 0x60
 ; OBJ-NEXT:     RelocationPointer: 0x0
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 0
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_TEXT (0x20)
 ; OBJ-NEXT:   }
 ; OBJ-NEXT: ]
 
-
-; SYMS:       File: {{.*}}aix-xcoff-rodata.ll.tmp.o
-; SYMS-NEXT:  Format: aixcoff-rs6000
-; SYMS-NEXT:  Arch: powerpc
-; SYMS-NEXT:  AddressSize: 32bit
 ; SYMS:       Symbols [
 ; SYMS:        Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .rodata
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+1]]
 ; SYMS-NEXT:       SectionLen: 80
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 5
 ; SYMS-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+2]]
 ; SYMS-NEXT:     Name: const_ivar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+3]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+4]]
 ; SYMS-NEXT:     Name: const_llvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x8
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+5]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+6]]
 ; SYMS-NEXT:     Name: const_svar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x10
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+7]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+8]]
 ; SYMS-NEXT:     Name: const_fvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x14
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+9]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+10]]
 ; SYMS-NEXT:     Name: const_dvar
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x18
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+11]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+12]]
 ; SYMS-NEXT:     Name: const_over_aligned
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x20
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+13]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+14]]
 ; SYMS-NEXT:     Name: const_chrarray
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x28
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+15]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+16]]
 ; SYMS-NEXT:     Name: const_dblarr
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x30
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+17]]
 ; SYMS-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RO (0x1)
-; SYMS-NEXT:       StabInfoIndex: 0x0
-; SYMS-NEXT:       StabSectNum: 0x0
+; SYMS32-NEXT:     StabInfoIndex: 0x0
+; SYMS32-NEXT:     StabSectNum: 0x0
+; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS:      ]
 
 ; DIS: Disassembly of section .text:
 ; DIS: 00000000 <const_ivar>:
 ; DIS-NEXT:        0: 00 00 00 23
 ; DIS-NEXT:        4: 00 00 00 00

llvm/test/CodeGen/PowerPC/aix-xcoff-toc.ll

 ; This file tests TOC entry generation and undefined symbol generation.
 
-; RUN: llc  -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
-; RUN:      -xcoff-traceback-table=false < %s | FileCheck --check-prefixes CHECK,CHECK32 %s
-; RUN: llc  -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:      -xcoff-traceback-table=false < %s 2>&1 | FileCheck --check-prefixes CHECK,CHECK64  %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
+; RUN:     -xcoff-traceback-table=false < %s | FileCheck --check-prefixes CHECK,CHECK32 %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -xcoff-traceback-table=false < %s 2>&1 | FileCheck --check-prefixes CHECK,CHECK64  %s
 
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     --xcoff-traceback-table=false -filetype=obj -o %t.o < %s
-; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYM %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYM,SYM32 %s
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     --xcoff-traceback-table=false -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --syms %t64.o | FileCheck --check-prefixes=SYM,SYM64 %s
 
 @a = external global i32, align 4
 @b = external global i64, align 8
 @c = external global i16, align 2
 @globa = common global i32 0, align 4
 
 @ptr = internal global void (...)* null, align 4
 

 ; CHECK-NEXT: L..C6:
 ; CHECK-NEXT: .tc   foo[TC],foo[DS]
 ; CHECK-NEXT: L..C7:
 ; CHECK-NEXT: .tc   foobar[TC],foobar[DS]
 
 
 ; Test undefined symbol generation.
 
-; SYM:       File: {{.*}}aix-xcoff-toc.ll.tmp.o
 ; SYM:       Symbol {{[{][[:space:]] *}}Index: [[#UNDEF_INDX:]]{{[[:space:]] *}}Name: a
 ; SYM-NEXT:   Value (RelocatableAddress): 0x0
 ; SYM-NEXT:   Section: N_UNDEF
 ; SYM-NEXT:   Type: 0x0
 ; SYM-NEXT:   StorageClass: C_EXT (0x2)
 ; SYM-NEXT:   NumberOfAuxEntries: 1
 ; SYM-NEXT:   CSECT Auxiliary Entry {
 ; SYM-NEXT:     Index: [[#UNDEF_INDX+1]]
 ; SYM-NEXT:     SectionLen: 0
 ; SYM-NEXT:     ParameterHashIndex: 0x0
 ; SYM-NEXT:     TypeChkSectNum: 0x0
 ; SYM-NEXT:     SymbolAlignmentLog2: 0
 ; SYM-NEXT:     SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:     StorageMappingClass: XMC_UA (0x4)
-; SYM-NEXT:     StabInfoIndex: 0x0
-; SYM-NEXT:     StabSectNum: 0x0
+; SYM32-NEXT:   StabInfoIndex: 0x0
+; SYM32-NEXT:   StabSectNum: 0x0
+; SYM64-NEXT:   Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:   }
 ; SYM-NEXT: }
 ; SYM-NEXT: Symbol {
 ; SYM-NEXT:   Index: [[#UNDEF_INDX+2]]
 ; SYM-NEXT:   Name: b
 ; SYM-NEXT:   Value (RelocatableAddress): 0x0
 ; SYM-NEXT:   Section: N_UNDEF
 ; SYM-NEXT:   Type: 0x0
 ; SYM-NEXT:   StorageClass: C_EXT (0x2)
 ; SYM-NEXT:   NumberOfAuxEntries: 1
 ; SYM-NEXT:   CSECT Auxiliary Entry {
 ; SYM-NEXT:     Index: [[#UNDEF_INDX+3]]
 ; SYM-NEXT:     SectionLen: 0
 ; SYM-NEXT:     ParameterHashIndex: 0x0
 ; SYM-NEXT:     TypeChkSectNum: 0x0
 ; SYM-NEXT:     SymbolAlignmentLog2: 0
 ; SYM-NEXT:     SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:     StorageMappingClass: XMC_UA (0x4)
-; SYM-NEXT:     StabInfoIndex: 0x0
-; SYM-NEXT:     StabSectNum: 0x0
+; SYM32-NEXT:   StabInfoIndex: 0x0
+; SYM32-NEXT:   StabSectNum: 0x0
+; SYM64-NEXT:   Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:   }
 ; SYM-NEXT: }
 ; SYM-NEXT: Symbol {
 ; SYM-NEXT:   Index: [[#UNDEF_INDX+4]]
 ; SYM-NEXT:   Name: c
 ; SYM-NEXT:   Value (RelocatableAddress): 0x0
 ; SYM-NEXT:   Section: N_UNDEF
 ; SYM-NEXT:   Type: 0x0
 ; SYM-NEXT:   StorageClass: C_EXT (0x2)
 ; SYM-NEXT:   NumberOfAuxEntries: 1
 ; SYM-NEXT:   CSECT Auxiliary Entry {
 ; SYM-NEXT:     Index: [[#UNDEF_INDX+5]]
 ; SYM-NEXT:     SectionLen: 0
 ; SYM-NEXT:     ParameterHashIndex: 0x0
 ; SYM-NEXT:     TypeChkSectNum: 0x0
 ; SYM-NEXT:     SymbolAlignmentLog2: 0
 ; SYM-NEXT:     SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:     StorageMappingClass: XMC_UA (0x4)
-; SYM-NEXT:     StabInfoIndex: 0x0
-; SYM-NEXT:     StabSectNum: 0x0
+; SYM32-NEXT:   StabInfoIndex: 0x0
+; SYM32-NEXT:   StabSectNum: 0x0
+; SYM64-NEXT:   Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:   }
 ; SYM-NEXT: }
 ; SYM-NEXT: Symbol {
 ; SYM-NEXT:   Index: [[#UNDEF_INDX+6]]
 ; SYM-NEXT:   Name: .foo
 ; SYM-NEXT:   Value (RelocatableAddress): 0x0
 ; SYM-NEXT:   Section: N_UNDEF
 ; SYM-NEXT:   Type: 0x0
 ; SYM-NEXT:   StorageClass: C_EXT (0x2)
 ; SYM-NEXT:   NumberOfAuxEntries: 1
 ; SYM-NEXT:   CSECT Auxiliary Entry {
 ; SYM-NEXT:     Index: [[#UNDEF_INDX+7]]
 ; SYM-NEXT:     SectionLen: 0
 ; SYM-NEXT:     ParameterHashIndex: 0x0
 ; SYM-NEXT:     TypeChkSectNum: 0x0
 ; SYM-NEXT:     SymbolAlignmentLog2: 0
 ; SYM-NEXT:     SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:     StorageMappingClass: XMC_PR (0x0)
-; SYM-NEXT:     StabInfoIndex: 0x0
-; SYM-NEXT:     StabSectNum: 0x0
+; SYM32-NEXT:   StabInfoIndex: 0x0
+; SYM32-NEXT:   StabSectNum: 0x0
+; SYM64-NEXT:   Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:   }
 ; SYM-NEXT: }
 ; SYM-NEXT: Symbol {
 ; SYM-NEXT:   Index: [[#UNDEF_INDX+8]]
 ; SYM-NEXT:   Name: foo
 ; SYM-NEXT:   Value (RelocatableAddress): 0x0
 ; SYM-NEXT:   Section: N_UNDEF
 ; SYM-NEXT:   Type: 0x0
 ; SYM-NEXT:   StorageClass: C_EXT (0x2)
 ; SYM-NEXT:   NumberOfAuxEntries: 1
 ; SYM-NEXT:   CSECT Auxiliary Entry {
 ; SYM-NEXT:     Index: [[#UNDEF_INDX+9]]
 ; SYM-NEXT:     SectionLen: 0
 ; SYM-NEXT:     ParameterHashIndex: 0x0
 ; SYM-NEXT:     TypeChkSectNum: 0x0
 ; SYM-NEXT:     SymbolAlignmentLog2: 0
 ; SYM-NEXT:     SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:     StorageMappingClass: XMC_DS (0xA)
-; SYM-NEXT:     StabInfoIndex: 0x0
-; SYM-NEXT:     StabSectNum: 0x0
+; SYM32-NEXT:   StabInfoIndex: 0x0
+; SYM32-NEXT:   StabSectNum: 0x0
+; SYM64-NEXT:   Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:   }
 ; SYM-NEXT: }
 
 ; Test TOC entry symbol generation.
 
 ; SYM:       Symbol {{[{][[:space:]] *}}Index: [[#TOC_INDX:]]{{[[:space:]] *}}Name: TOC
-; SYM-NEXT:    Value (RelocatableAddress): 0xA8
+; SYM32-NEXT:  Value (RelocatableAddress): 0xA8
+; SYM64-NEXT:  Value (RelocatableAddress): 0xC0
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+1]]
 ; SYM-NEXT:      SectionLen: 0
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
 ; SYM-NEXT:      SymbolAlignmentLog2: 2
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC0 (0xF)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+2]]
 ; SYM-NEXT:    Name: a
-; SYM-NEXT:    Value (RelocatableAddress): 0xA8
+; SYM32-NEXT:  Value (RelocatableAddress): 0xA8
+; SYM64-NEXT:  Value (RelocatableAddress): 0xC0
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+3]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+4]]
 ; SYM-NEXT:    Name: b
-; SYM-NEXT:    Value (RelocatableAddress): 0xAC
+; SYM32-NEXT:  Value (RelocatableAddress): 0xAC
+; SYM64-NEXT:  Value (RelocatableAddress): 0xC8
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+5]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+6]]
 ; SYM-NEXT:    Name: c
-; SYM-NEXT:    Value (RelocatableAddress): 0xB0
+; SYM32-NEXT:  Value (RelocatableAddress): 0xB0
+; SYM64-NEXT:  Value (RelocatableAddress): 0xD0
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+7]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+8]]
 ; SYM-NEXT:    Name: globa
-; SYM-NEXT:    Value (RelocatableAddress): 0xB4
+; SYM32-NEXT:  Value (RelocatableAddress): 0xB4
+; SYM64-NEXT:  Value (RelocatableAddress): 0xD8
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+9]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+10]]
 ; SYM-NEXT:    Name: ptr
-; SYM-NEXT:    Value (RelocatableAddress): 0xB8
+; SYM32-NEXT:  Value (RelocatableAddress): 0xB8
+; SYM64-NEXT:  Value (RelocatableAddress): 0xE0
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+11]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+12]]
 ; SYM-NEXT:    Name: bar
-; SYM-NEXT:    Value (RelocatableAddress): 0xBC
+; SYM32-NEXT:  Value (RelocatableAddress): 0xBC
+; SYM64-NEXT:  Value (RelocatableAddress): 0xE8
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+13]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+14]]
 ; SYM-NEXT:    Name: foo
-; SYM-NEXT:    Value (RelocatableAddress): 0xC0
+; SYM32-NEXT:  Value (RelocatableAddress): 0xC0
+; SYM64-NEXT:  Value (RelocatableAddress): 0xF0
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+15]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }
 ; SYM-NEXT:  Symbol {
 ; SYM-NEXT:    Index: [[#TOC_INDX+16]]
 ; SYM-NEXT:    Name: foobar
-; SYM-NEXT:    Value (RelocatableAddress): 0xC4
+; SYM32-NEXT:  Value (RelocatableAddress): 0xC4
+; SYM64-NEXT:  Value (RelocatableAddress): 0xF8
 ; SYM-NEXT:    Section: .data
 ; SYM-NEXT:    Type: 0x0
 ; SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:    NumberOfAuxEntries: 1
 ; SYM-NEXT:    CSECT Auxiliary Entry {
 ; SYM-NEXT:      Index: [[#TOC_INDX+17]]
-; SYM-NEXT:      SectionLen: 4
+; SYM32-NEXT:    SectionLen: 4
+; SYM64-NEXT:    SectionLen: 8
 ; SYM-NEXT:      ParameterHashIndex: 0x0
 ; SYM-NEXT:      TypeChkSectNum: 0x0
-; SYM-NEXT:      SymbolAlignmentLog2: 2
+; SYM32-NEXT:    SymbolAlignmentLog2: 2
+; SYM64-NEXT:    SymbolAlignmentLog2: 3
 ; SYM-NEXT:      SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:      StorageMappingClass: XMC_TC (0x3)
-; SYM-NEXT:      StabInfoIndex: 0x0
-; SYM-NEXT:      StabSectNum: 0x0
+; SYM32-NEXT:    StabInfoIndex: 0x0
+; SYM32-NEXT:    StabSectNum: 0x0
+; SYM64-NEXT:    Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:    }
 ; SYM-NEXT:  }

llvm/test/CodeGen/PowerPC/aix-xcoff-visibility.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec -data-sections=false < %s | \
 ; RUN:   FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec -data-sections=false < %s |\
 ; RUN:   FileCheck %s
 
 ; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -filetype=obj -o %t.o < %s 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF32 %s
-; XCOFF32: LLVM ERROR: Emitting non-zero visibilities is not supported yet.
+; RUN:   FileCheck --check-prefix=XCOFF %s
 
 ; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
 ; RUN:     -filetype=obj -o %t.o 2>&1 < %s 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; FIXME: This should check for the visibility error, but we actually fail before
-; that due to unimplemented relocations.
-; XCOFF64: LLVM ERROR: Unimplemented fixup kind.
+; RUN:   FileCheck --check-prefix=XCOFF %s
+
+; XCOFF: LLVM ERROR: Emitting non-zero visibilities is not supported yet.
 
 @b =  global i32 0, align 4
 @b_h = hidden global i32 0, align 4
 @b_e = dllexport global i32 0, align 4
 
 define void @foo() {
 entry:
   ret void

llvm/test/CodeGen/PowerPC/basic-toc-data-def.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff  -verify-machineinstrs < %s | FileCheck %s
 ; RUN: not --crash llc -filetype=obj -mtriple powerpc-ibm-aix-xcoff  \
 ; RUN:                 -verify-machineinstrs < %s 2>&1 | \
 ; RUN:   FileCheck %s --check-prefix=OBJ
 
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -verify-machineinstrs < %s | FileCheck %s
+; RUN: not --crash llc -filetype=obj -mtriple powerpc64-ibm-aix-xcoff  \
+; RUN:                 -verify-machineinstrs < %s 2>&1 | \
+; RUN:   FileCheck %s --check-prefix=OBJ
+
 @i = global i32 55, align 4 #0
 
 attributes #0 = { "toc-data" }
 ; CHECK:            .toc
 ; CHECK-NEXT:       .csect i[TD],2
 ; CHECK-NEXT:       .globl i[TD]
 ; CHECK-NEXT:       .align 2
 ; CHECK-NEXT:       .vbyte 4, 55
 
 ; OBJ: LLVM ERROR:  toc-data not yet supported when writing object files.

llvm/test/CodeGen/PowerPC/basic-toc-data-extern.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -verify-machineinstrs < %s | FileCheck %s
 ; RUN: not --crash llc -filetype=obj -mtriple powerpc-ibm-aix-xcoff  \
 ; RUN:                 -verify-machineinstrs < %s 2>&1 | \
-; RUN:   FileCheck %s --check-prefix=OBJ32
+; RUN:   FileCheck %s --check-prefix=OBJ
 
-;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -verify-machineinstrs < %s | FileCheck %s
+; RUN: not --crash llc -filetype=obj -mtriple powerpc64-ibm-aix-xcoff  \
+; RUN:                 -verify-machineinstrs < %s 2>&1 | \
+; RUN:   FileCheck %s --check-prefix=OBJ
 
 @i = external global i32, align 4  #0
 
 ; Function Attrs: noinline nounwind optnone
 define i32* @get() {
   entry:
     ret i32* @i
 }
 
 ; CHECK:        la 3, i[TD](2)
 ; CHECK:        .toc
 ; CHECK-NEXT:   .extern i[TD]
 
-; OBJ32: LLVM ERROR:  toc-data not yet supported when writing object files.
+; OBJ: LLVM ERROR:  toc-data not yet supported when writing object files.
 
 attributes #0 = { "toc-data" }

llvm/test/MC/PowerPC/ppc64-abs-reloc.s

 # RUN: llvm-mc -triple powerpc64le-unknown-linux-gnu %s -filetype=obj -o - | \
 # RUN:    llvm-objdump -D -r - | FileCheck %s
-  .text
+
+# RUN: llvm-mc -triple powerpc64-ibm-aix-xcoff %s -filetype=obj -o - | \
+# RUN:    llvm-objdump -D -r - | FileCheck %s
+
 test:                                   # @test
         add 5, 3, 4
         extsw 3, 5
         .space 32776
 lab2:
         lxv 5, (lab2-test)@l(4)
         ld 5, (lab2-test)@l(4)
         lwz 5, (lab2-test)@l(4)
         lxv 5, 8389632@l(4)
         ld 5, 8389632@l(4)
         lwz 5, 8389632@l(4)
         blr
 
 # CHECK: lxv 5, -32752(4)
 # CHECK: ld 5, -32752(4)
 # CHECK: lwz 5, -32752(4)
 # CHECK: lxv 5, 1024(4)
 # CHECK: ld 5, 1024(4)
 # CHECK: lwz 5, 1024(4)