[XCOFF][AIX] Add support for XCOFF 64 bit Object files

[EGuesnet]

Summary

Support the integrated assembler for XCOFF 64 bit, and update the related tests.
The patch is based on D85774 revision

[nemanjai]

Please be sure to add reviewers from IBM that are actively developing this area of the PowerPC back end on your patches.

[sfertile]

Thanks for working on this. My first suggestion is we need to break up this patch to make it smaller and easier to review. The natural place to partition it is the llvm-readobj functionality. I don't think the YAML tools support generating 64-bit XCOFF objects yet, but we can add a precompiled object file as test input.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

108

Please remove the unreachable instead of commenting it out.

[jsji]

I don't think the YAML tools support generating 64-bit XCOFF objects yet, but we can add a precompiled object file as test input.

https://reviews.llvm.org/D100375 is ready for review, so I would suggest we use yam2obj base on that .
It would be great if we can help review and test D100375.

[sfertile]

In D103696#2803289, @jsji wrote:

I don't think the YAML tools support generating 64-bit XCOFF objects yet, but we can add a precompiled object file as test input.

https://reviews.llvm.org/D100375 is ready for review, so I would suggest we use yam2obj base on that .
It would be great if we can help review and test D100375.

Awesome, I'm happy to help review it. Thanks Jinsong.

[EGuesnet]

Remove the unreachable
@sfertile thank you

[jhenderson]

Lots of stylistic comments from me. Someone else will need to review functionality.

llvm/include/llvm/Object/XCOFFObjectFile.h

264

It would be preferable if we didn't duplicate nearly the entire contents of the 32-bit version of this struct. Could you have a single generic version which stores the virtual address in the larger field, and then just write it out to the right size at the appropriate time?

llvm/lib/MC/XCOFFObjectWriter.cpp

347–348

603

I'm not sure this comment gives us anything, since the is64Bit check is right before it. Same below for the 32-bit version.

606–607

Please ensure comments are complete sentences, as per the style guide. Additionally, why is Zeros capitalised and plural? In fact, I'm not sure you need to go into this much detail - that belongs in the underlying function. Here, I'd just specify "Name or string table offset", if you feel you really need to, although really the function name for writeSymbolName should be descriptive enough that the comment is superfluous.

627

628

This doesn't look to be clang-formatted to me. Additionally, do you actually need the mask and cast? Does the write function not already do that conversion implicitly?

636

637

As above - clang-format and do you need the cast?

638

Please end all your comments with . as per the style guide and the existing code.

640

682–683

Same comments as above re. typos/grammar/clang-format/casting.

691–696

Ditto.

908–912

Don't use braces for single-statement if/else clauses (see the style guide).

1009–1015

Don't use braces (as above). Also, please run clang-format on all your changed code before uploading for review.

llvm/lib/Object/XCOFFObjectFile.cpp

370

Use upper-case variable names.

728

Don't have blank lines at the start of functions.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

169

170–172

Is there a particular need for this? Whilst the spec may say that only these section types have relocations, if I follow things correctly, there's nothing actually stopping XCOFF emitters from generating files with relocations for other section types.

173

Prefer to report warnings rather than errors, so that llvm-readobj doesn't bail out on malformed inputs. This helps diagnose more issues.

See reportUniqueWarning for the preferred method.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

264

As an alternate, why don't we take the same approach as the section headers. For Relocations we would have a base class that can implement everything, and simply have a template parameter for the type of the VirtualAddress field. That will simplify the llvm-readobj XCOFF dumper changes in this patch nicely, and keeps the relocation implementation consistent with the other parts of this class.

425–428

No need to disambiguate by adding '32' on this since this interface only makes sense with 32-bit XCOFF files. But we might want to rethink the naming here. It would be useful to have the same function name, overloaded by the section argument type for both 64-bit and 32-bit that returns the 'real' count of relocations. @hubert.reinterpretcast Do you have any. thoughts on this?

431

Do we need the '64' vs '32' the disambiguate for relocations? We have it for the section header tables but that's because we don't have an argument to use for overloading with those.

[MaryamBen]

llvm/include/llvm/Object/XCOFFObjectFile.h

264

Yeah, it would be great if I were able to do it, especially that the only difference is the size of VirtualAddress (32-bit/64-bit).

I have done this because in function relocation32 they read relocations from memory and save them into an array of XCOFFRelocation32, so the structure must match the content of memory.

static_assert(
      sizeof(XCOFFRelocation32) == XCOFF::RelocationSerializationSize32, "");
  auto RelocationOrErr =
      getObject<XCOFFRelocation32>(Data, reinterpret_cast<void *>(RelocAddr),
                                   NumRelocEntries * sizeof(XCOFFRelocation32));

[EGuesnet]

@jhenderson thank you for your comments. It was very helpful.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

264

Yep, I believe the only difference between the 32-bit and 64-bit relocation structures is the VirtualAddress field. Cribing from the section header implementation, something like:

template <typename VirtualAddress_t>
struct XCOFFReloc {
  static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
  static constexpr uint8_t XR_FIXUP_MASK = 0x40;
  static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;

  VirtualAddress_t         VirtualAddress;
  llvm::support::ubig32_t  SymbolIndex;
  uint8_t                  Info;
  uint8_t                  Type;

  bool isRelocationSigned() const;
  bool isFixupIndicated() const;

  uint8_t getRelocatedLength() const;
};

struct XCOFFReloc32;
struct XCOFFReloc64;

extern template struct XCOFFReloc<llvm::support::ubig32_t>;
extern template struct XCOFFReloc<llvm::support::ubig64_t>;

struct XCOFFReloc32 : XCOFFReloc<llvm::support::ubig32_t> {};
struct XCOFFReloc64 : XCOFFReloc<llvm::support::ubig64_t> {};

allows us to implement all the shared functionality in the base class, while having the correct size and layout for each of the derived types with minimal boiler plate.

[EGuesnet]

Implement XCOFFRelocation32 and XCOFFRelocation64 properly

[EGuesnet]

Hello,
For you information, we have had trouble with arcanist configuration, and my account is used to push to review. Patch has been written by @MaryamBen, as confirmed by commit author.
Comments in push message are also made @MaryamBen.
Regards.

[sfertile]

In D103696#2816619, @EGuesnet wrote:

Hello,
For you information, we have had trouble with arcanist configuration, and my account is used to push to review. Patch has been written by @MaryamBen, as confirmed by commit author.
Comments in push message are also made @MaryamBen.
Regards.

I don't really use archanist so I can't comment on how to fix any problems with it, but now that the review is posted @MaryamBen can commander the revision from you. Also you can upload diffs using the 'edit revision` button with out needing to use arcanist.

In D103696#2803251, @sfertile wrote:

My first suggestion is we need to break up this patch to make it smaller and easier to review. The natural place to partition it is the llvm-readobj functionality. I don't think the YAML tools support generating 64-bit XCOFF objects yet, but we can add a precompiled object file as test input.

Reiterating this, as I think it is really important. This patch is too large to review as is. I understand breaking it up seems like extra work but it is going to go much faster/smoother if we can partition this into some smaller changes. The first patch I think should be the addition of Relocation64 to the XCOFF implementation in the Object library (ie include/llvm/Object/XCOFFObjectFile.h and lib/ObjectXCOFFObjectFile.cpp), any code needed to support that (for example if additions need to be made to include/llvm/BinaryFormat/XCOFF.h) and the 64-bit relocation reading support added to the llvm-readobj XCOFFDumper to exercises the newly added functionality.

[jhenderson]

llvm/include/llvm/BinaryFormat/XCOFF.h

280

Let's keep the 32 bit and 64 bit versions of each of these structs next to each other, so the order will be: FileHeader32, FileHeader64, SectionHeader32, SectionHeader64.

llvm/include/llvm/Object/XCOFFObjectFile.h

231

Drop the _t. Optionally, change this to VirtualAddressType or probably more simply just AddressType or similar. We don't name our types and variables with prefix/suffixes like this typically (exceptions are some enums - see the Coding Standards for details).

425–428

+1 to something like this. For ELF we often use templates for these functions, and then just explicitly instantiate them in the .cpp. Take a look throughout the LLD source code for example. You'd end up with something like:

template<typename XCOFFT> Expected<uint32_t>
  getNumberOfRelocationEntries(const XOCFFT::XCOFFSectionHeader &Sec) const;

For this to work, you'd create an equivalent of the ElfTraits structs, which contains typedefs for the 32-bit and 64-bit types.

431

Name your inptu parameter.

llvm/lib/MC/XCOFFObjectWriter.cpp

609

As previously stated, this comment doesn't really give us anything. At least drop the "32 bits", since you're inside the`!is64Bit` check. (Also "Symbole" -> "Symbol").

707–711

Drop the braces for simple if-else statements, as per the Coding Standards.

722

You don't need to cahnge this comment. It's clear from the context that this is for 32 bits.

729

Put this comment inside the if and drop the "64 bits" bit of it.

1011–1012

If you were to switch to the ElfTraits model suggested above, you could avoid this if and just do something like:

RawPointer = sizeof(XCOFFTraits::FileHeader) + auxiliaryHeaderSize() +
             SectionCount * sizeof(XCOFFTraits::SectionHeader);

llvm/lib/Object/XCOFFObjectFile.cpp

73

Same comment as above re _t. Also goes for the following functions.

371

515–516

Unrelated formatting changes should be applied in a different commit.

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

61

The changes in this file doesn't seem related to the rest of the patch. Should they be a separate patch?

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

335

Delete second blank line.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

137

Don't use auto where the type isn't obvious (except in certain cases to do with iterators). See the Coding Standards.

143

Ditto. Don't use auto here. Also should this be const &?

162

Do you plan to add support for this? I think it would make more sense to just ignore the option, if there's no strong motivation to crash in this case... (even if you do want a warning/error, use the reportUniqueWarning/reportError functions).

167

Don't use auto.

169

This and the following comments haven't been addressed.

[Esme]

llvm/include/llvm/BinaryFormat/XCOFF.h

280

Please refer to patch D103901, we have removed these structures as we only use their size. It looks like this patch also only use their sizeof, so it's reasonable to replace the two structs with the constants:

constexpr size_t FileHeaderSize64 = 24;
constexpr size_t SectionHeaderSize64 = 72;

llvm/lib/MC/XCOFFObjectWriter.cpp

206

StringRef is small and pervasive enough in LLVM that it should always be passed by value. (https://bcain-llvm.readthedocs.io/projects/llvm/en/latest/ProgrammersManual/#the-stringref-class)

580

nameShouldBeInStringTable() will never be called if the TargetObjectWriter->is64Bit() is true, right? Maybe we can just remove the or condition.

745

Move this comment to the appropriate code, ie. inside the if.

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

336

Add some space to keep alignment. Same as below.

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

94

llvm/tools/llvm-readobj/XCOFFDumper.cpp

47

I think you should split these part to another patch about implementation of printing relocations64 in llvm-readobj, and add corresponding test cases.

[MaryamBen]

In D103696#2803251, @sfertile wrote:

My first suggestion is we need to break up this patch to make it smaller and easier to review. The natural place to partition it is the llvm-readobj functionality. I don't think the YAML tools support generating 64-bit XCOFF objects yet, but we can add a precompiled object file as test input.

Reiterating this, as I think it is really important. This patch is too large to review as is. I understand breaking it up seems like extra work but it is going to go much faster/smoother if we can partition this into some smaller changes. The first patch I think should be the addition of Relocation64 to the XCOFF implementation in the Object library (ie include/llvm/Object/XCOFFObjectFile.h and lib/ObjectXCOFFObjectFile.cpp), any code needed to support that (for example if additions need to be made to include/llvm/BinaryFormat/XCOFF.h) and the 64-bit relocation reading support added to the llvm-readobj XCOFFDumper to exercises the newly added functionality.

You are right, I will break it into two parts.
The first patch for the objectWriter ( PPCXCOFFObjectWriter.cpp, XCOFFObjectWriter.cpp, XCOFF.h and the related tests), the second part for 64-bit relocation support.

[MaryamBen]

llvm/lib/MC/XCOFFObjectWriter.cpp

580

Actually it's used in XCOFFObjectWriter::executePostLayoutBinding() even for 64 bit.

[MaryamBen]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

162

I have no idea why this condition needs to be checked, as I just adapted the existing code for 64-bit, but since it is better to use reportUniqueWarning, I will do so.

llvm/include/llvm/BinaryFormat/XCOFF.h

 namespace XCOFF {
 
 // Constants used in the XCOFF definition.
 
 constexpr size_t FileNamePadSize = 6;
 constexpr size_t NameSize = 8;
 constexpr size_t SymbolTableEntrySize = 18;
 constexpr size_t RelocationSerializationSize32 = 10;
+constexpr size_t RelocationSerializationSize64 = 14;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
 enum StorageMappingClass : uint8_t {
struct SectionHeader32 {
   uint32_t FileOffsetToData;
   uint32_t FileOffsetToRelocations;
   uint32_t FileOffsetToLineNumbers;
   uint16_t NumberOfRelocations;
   uint16_t NumberOfLineNumbers;
   int32_t Flags;
 };
 
+struct FileHeader64 {
+  uint16_t Magic;
+  uint16_t NumberOfSections;
+  int32_t TimeStamp;
+  uint64_t SymbolTableFileOffset;
+  uint16_t AuxiliaryHeaderSize;
+  uint16_t Flags;
+  int32_t NumberOfSymbolTableEntries;
+};
+
+struct SectionHeader64 {
+  char Name[XCOFF::NameSize];
+  uint64_t PhysicalAddress;
+  uint64_t VirtualAddress;
+  uint64_t Size;
+  uint64_t FileOffsetToData;
+  uint64_t FileOffsetToRelocations;
+  uint64_t FileOffsetToLineNumbers;
+  uint32_t NumberOfRelocations;
+  uint32_t NumberOfLineNumbers;
+  int32_t Flags;
+  char Padding[4];
+};
+
 enum CFileStringType : uint8_t {
   XFT_FN = 0,  ///< Specifies the source-file name.
   XFT_CT = 1,  ///< Specifies the compiler time stamp.
   XFT_CV = 2,  ///< Specifies the compiler version number.
   XFT_CD = 128 ///< Specifies compiler-defined information.
 };
 
 enum CFileLangId : uint8_t {

llvm/include/llvm/Object/XCOFFObjectFile.h

 
 struct XCOFFSectAuxEntForStat {
   support::ubig32_t SectionLength;
   support::ubig16_t NumberOfRelocEnt;
   support::ubig16_t NumberOfLineNum;
   uint8_t Pad[10];
 }; // 32-bit XCOFF file only.
 
-struct XCOFFRelocation32 {
+template <typename VirtualAddress_t>
+struct XCOFFRelocation {
   // Masks for packing/unpacking the r_rsize field of relocations.
 
   // The msb is used to indicate if the bits being relocated are signed or
   // unsigned.
   static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
 
   // The 2nd msb is used to indicate that the binder has replaced/modified the
   // original instruction.
   static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40;
 
   // The remaining bits specify the bit length of the relocatable reference
   // minus one.
   static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;
 
 public:
-  support::ubig32_t VirtualAddress;
+  VirtualAddress_t VirtualAddress;
   support::ubig32_t SymbolIndex;
 
   // Packed field, see XR_* masks for details of packing.
   uint8_t Info;
 
   XCOFF::RelocationType Type;
 
 public:
   bool isRelocationSigned() const;
   bool isFixupIndicated() const;
 
   // Returns the number of bits being relocated.
   uint8_t getRelocatedLength() const;
 };
 
+extern template struct XCOFFRelocation<llvm::support::ubig32_t>;
+extern template struct XCOFFRelocation<llvm::support::ubig64_t>;
+
+struct XCOFFRelocation32 : XCOFFRelocation<llvm::support::ubig32_t> {};
+struct XCOFFRelocation64 : XCOFFRelocation<llvm::support::ubig64_t> {};
+
 class XCOFFSymbolRef;
 
 class XCOFFObjectFile : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const void *SymbolTblPtr = nullptr;
public:
 
   int32_t getSectionFlags(DataRefImpl Sec) const;
   Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
   void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;
 
   // Relocation-related interfaces.
   Expected<uint32_t>
-  getLogicalNumberOfRelocationEntries(const XCOFFSectionHeader32 &Sec) const;
+  getLogicalNumberOfRelocationEntries32(const XCOFFSectionHeader32 &Sec) const;
+
+  uint32_t
+  getNumberOfRelocationEntries64(const XCOFFSectionHeader64 &Sec) const;
 
   Expected<ArrayRef<XCOFFRelocation32>>
-  relocations(const XCOFFSectionHeader32 &) const;
+  relocations32(const XCOFFSectionHeader32 &) const;
 
+  Expected<ArrayRef<XCOFFRelocation64>>
+  relocations64(const XCOFFSectionHeader64 &) const;
   // This function returns string table entry.
   Expected<StringRef> getStringTableEntry(uint32_t Offset) const;
 
   const XCOFF::SymbolAuxType *getSymbolAuxType(uintptr_t AuxEntryAddress) const;
 
   static uintptr_t getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
                                                  uint32_t Distance);
 

llvm/lib/MC/XCOFFObjectWriter.cpp

 constexpr unsigned DefaultSectionAlign = 4;
 constexpr int16_t MaxSectionIndex = INT16_MAX;
 
 // Packs the csect's alignment and type into a byte.
 uint8_t getEncodedType(const MCSectionXCOFF *);
 
 struct XCOFFRelocation {
   uint32_t SymbolTableIndex;
-  uint32_t FixupOffsetInCsect;
+  uint64_t FixupOffsetInCsect;
   uint8_t SignAndSize;
   uint8_t Type;
 };
 
 // Wrapper around an MCSymbolXCOFF.
 struct Symbol {
   const MCSymbolXCOFF *const MCSym;
   uint32_t SymbolTableIndex;
 
   XCOFF::StorageClass getStorageClass() const {
     return MCSym->getStorageClass();
   }
   StringRef getSymbolTableName() const { return MCSym->getSymbolTableName(); }
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
 struct ControlSection {
   const MCSectionXCOFF *const MCCsect;
   uint32_t SymbolTableIndex;
-  uint32_t Address;
-  uint32_t Size;
+  uint64_t Address;
+  uint64_t Size;
 
   SmallVector<Symbol, 1> Syms;
   SmallVector<XCOFFRelocation, 1> Relocations;
   StringRef getSymbolTableName() const { return MCCsect->getSymbolTableName(); }
   ControlSection(const MCSectionXCOFF *MCSec)
       : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
 using CsectGroup = std::deque<ControlSection>;
 using CsectGroups = std::deque<CsectGroup *>;
 
 // Represents the data related to a section excluding the csects that make up
 // the raw data of the section. The csects are stored separately as not all
 // sections contain csects, and some sections contain csects which are better
 // stored separately, e.g. the .data section containing read-write, descriptor,
 // TOCBase and TOC-entry csects.
 struct Section {
   char Name[XCOFF::NameSize];
   // The physical/virtual address of the section. For an object file
   // these values are equivalent.
-  uint32_t Address;
-  uint32_t Size;
-  uint32_t FileOffsetToData;
-  uint32_t FileOffsetToRelocations;
+  uint64_t Address;
+  uint64_t Size;
+  uint64_t FileOffsetToData;
+  uint64_t FileOffsetToRelocations;
   uint32_t RelocationCount;
   int32_t Flags;
 
   int16_t Index;
 
   // Virtual sections do not need storage allocated in the object file.
   const bool IsVirtual;
 
Section(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
     assert(N.size() <= XCOFF::NameSize && "section name too long");
     memcpy(Name, N.data(), N.size());
   }
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
-  uint32_t SymbolTableOffset = 0;
+  uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint32_t RelocationEntryOffset = 0;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   // Maps the MCSection representation to its corresponding ControlSection
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;
 
-  static bool nameShouldBeInStringTable(const StringRef &);
+  bool nameShouldBeInStringTable(const StringRef &);
   void writeSymbolName(const StringRef &);
   void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
                                                 const ControlSection &, int16_t,
                                                 uint64_t);
   void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
                                               XCOFF::StorageClass);
   void writeFileHeader();
   void writeSectionHeaderTable();

 static MCSectionXCOFF *getContainingCsect(const MCSymbolXCOFF *XSym) {
   if (XSym->isDefined())
     return cast<MCSectionXCOFF>(XSym->getFragment()->getParent());
   return XSym->getRepresentedCsect();
 }
 
 void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                  const MCAsmLayout &Layout) {
+  // TODO: Add ".file" in the StringTableBuilder implicitly for XCOFF64.
   if (TargetObjectWriter->is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
+    Strings.add(".file");
 
   for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
            "Cannot add a csect twice.");
     assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
            "An undefined csect should not get registered.");
 
return SymbolIndexMap.find(Sym) != SymbolIndexMap.end()
                ? SymbolIndexMap[Sym]
                : SymbolIndexMap[ContainingCsect->getQualNameSymbol()];
   };
 
   auto getVirtualAddress = [this,
                             &Layout](const MCSymbol *Sym,
                                      const MCSectionXCOFF *ContainingCsect) {
     // If Sym is a csect, return csect's address.
-    // If Sym is a label, return csect's address + label's offset from the csect.
+    // If Sym is a label, return csect's address + label's offset from the
+    // csect.
     return SectionMap[ContainingCsect]->Address +
            (Sym->isDefined() ? Layout.getSymbolOffset(*Sym) : 0);
   };
 
   const MCSymbol *const SymA = &Target.getSymA()->getSymbol();
 
   MCAsmBackend &Backend = Asm.getBackend();
   bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
else if (Type == XCOFF::RelocationType::R_TOC ||
 
     FixedValue = TOCEntryOffset;
   }
 
   assert(
       (TargetObjectWriter->is64Bit() ||
        Fixup.getOffset() <= UINT32_MAX - Layout.getFragmentOffset(Fragment)) &&
       "Fragment offset + fixup offset is overflowed in 32-bit mode.");
-  uint32_t FixupOffsetInCsect =
+  uint64_t FixupOffsetInCsect =
       Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
 
   XCOFFRelocation Reloc = {Index, FixupOffsetInCsect, SignAndSize, Type};
   MCSectionXCOFF *RelocationSec = cast<MCSectionXCOFF>(Fragment->getParent());
   assert(SectionMap.find(RelocationSec) != SectionMap.end() &&
          "Expected containing csect to exist in map.");
   SectionMap[RelocationSec]->Relocations.push_back(Reloc);
 
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) {
-  uint32_t CurrentAddressLocation = 0;
+  uint64_t CurrentAddressLocation = 0;
   for (const auto *Section : Sections) {
     // Nothing to write for this Section.
     if (Section->Index == Section::UninitializedIndex || Section->IsVirtual)
       continue;
 
     // There could be a gap (without corresponding zero padding) between
     // sections.
     assert(((CurrentAddressLocation <= Section->Address) ||

 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.");
 
-  if (TargetObjectWriter->is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
-
   finalizeSectionInfo();
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
   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) || TargetObjectWriter->is64Bit();
 }
 
 void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
+  if (TargetObjectWriter->is64Bit()) {
+    W.write<uint32_t>(Strings.getOffset(SymbolName));
+  } else {
     if (nameShouldBeInStringTable(SymbolName)) {
       W.write<int32_t>(0);
       W.write<uint32_t>(Strings.getOffset(SymbolName));
     } else {
-    char Name[XCOFF::NameSize+1];
+      char Name[XCOFF::NameSize + 1];
       std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
       ArrayRef<char> NameRef(Name, XCOFF::NameSize);
       W.write(NameRef);
     }
   }
+}
 
 void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const ControlSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
-  // Name or Zeros and string table offset
+  if (TargetObjectWriter->is64Bit())
+    W.write<uint64_t>(CSectionRef.Address + SymbolOffset);
+  // Name or string table offset.
   writeSymbolName(SymbolRef.getSymbolTableName());
+  if (!TargetObjectWriter->is64Bit()) {
     assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
            "Symbol address overflows.");
+    // Symbole value 32 bits.
     W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
+  }
   W.write<int16_t>(SectionIndex);
   // 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.
   // TODO FIXME How to assert a symbol's visibilty is default?
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
   W.write<uint16_t>(0);
   W.write<uint8_t>(SymbolRef.getStorageClass());
   // Always 1 aux entry for now.
   W.write<uint8_t>(1);
 
   // Now output the auxiliary entry.
   W.write<uint32_t>(CSectionRef.SymbolTableIndex);
   // Parameter typecheck hash. Not supported.
   W.write<uint32_t>(0);
   // Typecheck section number. Not supported.
   W.write<uint16_t>(0);
   // Symbol type: Label
   W.write<uint8_t>(XCOFF::XTY_LD);
   // Storage mapping class.
   W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  if (TargetObjectWriter->is64Bit()) {
+    // High 4 bytes length only on 64 bits.
+    W.write<uint32_t>((CSectionRef.SymbolTableIndex & 0xFFFFFFFF00000000) >>
+                      32);
+    // Reserved (pad).
+    W.write<uint8_t>(0);
+    // Auxiliary type entry.
+    W.write<uint8_t>(XCOFF::SymbolAuxType::AUX_CSECT);
+  } else {
     // Reserved (x_stab).
     W.write<uint32_t>(0);
     // Reserved (x_snstab).
     W.write<uint16_t>(0);
   }
+}
 
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const ControlSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
+  if (TargetObjectWriter->is64Bit()) {
+    // n_value
+    W.write<uint64_t>(CSectionRef.Address);
+    // n_offset
+    writeSymbolName(CSectionRef.getSymbolTableName());
+  } else {
     // n_name, n_zeros, n_offset
     writeSymbolName(CSectionRef.getSymbolTableName());
     // n_value
     W.write<uint32_t>(CSectionRef.Address);
+  }
   // n_scnum
   W.write<int16_t>(SectionIndex);
   // 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.
   // TODO FIXME How to assert a symbol's visibilty is default?
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
   W.write<uint16_t>(0);
   // n_sclass
   W.write<uint8_t>(StorageClass);
   // Always 1 aux entry for now.
   W.write<uint8_t>(1);
 
   // Now output the auxiliary entry.
   W.write<uint32_t>(CSectionRef.Size);
   // Parameter typecheck hash. Not supported.
   W.write<uint32_t>(0);
   // Typecheck section number. Not supported.
   W.write<uint16_t>(0);
   // Symbol type.
   W.write<uint8_t>(getEncodedType(CSectionRef.MCCsect));
   // Storage mapping class.
   W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  if (TargetObjectWriter->is64Bit()) {
+    // High 4 bytes length only on 64 bits.
+    W.write<uint32_t>((CSectionRef.Size & 0xFFFFFFFF00000000) >> 32);
+    // Reserved (pad).
+    W.write<uint8_t>(0);
+    // Auxiliary type entry.
+    W.write<uint8_t>(XCOFF::SymbolAuxType::AUX_CSECT);
+  } else {
     // Reserved (x_stab).
     W.write<uint32_t>(0);
     // Reserved (x_snstab).
     W.write<uint16_t>(0);
   }
+}
 
 void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
+  if (TargetObjectWriter->is64Bit()) {
+    W.write<uint16_t>(0x01f7);
+  } else {
     W.write<uint16_t>(0x01df);
+  }
   // Number of sections.
   W.write<uint16_t>(SectionCount);
   // Timestamp field. For reproducible output we write a 0, which represents no
   // timestamp.
   W.write<int32_t>(0);
   // Byte Offset to the start of the symbol table.
+  if (TargetObjectWriter->is64Bit()) {
+    W.write<uint64_t>(SymbolTableOffset);
+  } else {
     W.write<uint32_t>(SymbolTableOffset);
-  // Number of entries in the symbol table.
+    // Number of entries in the symbol table (32 bits).
     W.write<int32_t>(SymbolTableEntryCount);
+  }
   // Size of the optional header.
   W.write<uint16_t>(0);
   // Flags.
   W.write<uint16_t>(0);
+  // Number of entries in the symbol table (64 bits).
+  if (TargetObjectWriter->is64Bit())
+    W.write<int32_t>(SymbolTableEntryCount);
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
   for (const auto *Sec : Sections) {
     // Nothing to write for this Section.
     if (Sec->Index == Section::UninitializedIndex)
       continue;
 
     // Write Name.
     ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
     W.write(NameRef);
 
     // Write the Physical Address and Virtual Address. In an object file these
     // are the same.
+    if (TargetObjectWriter->is64Bit()) {
+      W.write<uint64_t>(Sec->Address);
+      W.write<uint64_t>(Sec->Address);
+
+      W.write<uint64_t>(Sec->Size);
+      W.write<uint64_t>(Sec->FileOffsetToData);
+      W.write<uint64_t>(Sec->FileOffsetToRelocations);
+
+      // Line number pointer. Not supported yet.
+      W.write<uint64_t>(0);
+
+      W.write<uint32_t>(Sec->RelocationCount);
+
+      // Line number counts. Not supported yet.
+      W.write<uint32_t>(0);
+
+      W.write<int32_t>(Sec->Flags);
+      W.write<int32_t>(0);
+    } else {
       W.write<uint32_t>(Sec->Address);
       W.write<uint32_t>(Sec->Address);
 
       W.write<uint32_t>(Sec->Size);
       W.write<uint32_t>(Sec->FileOffsetToData);
       W.write<uint32_t>(Sec->FileOffsetToRelocations);
 
       // Line number pointer. Not supported yet.
       W.write<uint32_t>(0);
 
       W.write<uint16_t>(Sec->RelocationCount);
 
       // Line number counts. Not supported yet.
       W.write<uint16_t>(0);
 
       W.write<int32_t>(Sec->Flags);
     }
   }
+}
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const ControlSection &CSection) {
+  if (TargetObjectWriter->is64Bit())
+    W.write<uint64_t>(CSection.Address + Reloc.FixupOffsetInCsect);
+  else
     W.write<uint32_t>(CSection.Address + 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 == Section::UninitializedIndex)
for (const auto *Section : Sections) {
     }
   }
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   // Write symbol 0 as C_FILE.
   // FIXME: support 64-bit C_FILE symbol.
   //
+  if (TargetObjectWriter->is64Bit()) {
+    // n_value
+    W.write<uint64_t>(0);
+    // n_offset
+    writeSymbolName(".file");
+  } else {
     // n_name. The n_name of a C_FILE symbol is the source filename when no
     // auxiliary entries are present. The source filename 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 filename.
     writeSymbolName(".file");
     // n_value. The n_value of a C_FILE symbol is its symbol table index.
     W.write<uint32_t>(0);
+  }
   // n_scnum. N_DEBUG is a reserved section number for indicating a special
   // symbolic debugging symbol.
   W.write<int16_t>(XCOFF::ReservedSectionNum::N_DEBUG);
   // n_type. The n_type field of a C_FILE symbol encodes the source language and
   // CPU version info; zero indicates no info.
   W.write<uint16_t>(0);
   // n_sclass. The C_FILE symbol provides source file-name information,
   // source-language ID and CPU-version ID information and some other optional
   // infos.
   W.write<uint8_t>(XCOFF::C_FILE);
   // n_numaux. No aux entry for now.
   W.write<uint8_t>(0);
 
   for (const auto &Csect : UndefinedCsects) {
-    writeSymbolTableEntryForControlSection(
-        Csect, XCOFF::ReservedSectionNum::N_UNDEF, Csect.MCCsect->getStorageClass());
+    writeSymbolTableEntryForControlSection(Csect,
+                                           XCOFF::ReservedSectionNum::N_UNDEF,
+                                           Csect.MCCsect->getStorageClass());
   }
 
   for (const auto *Section : Sections) {
     if (Section->Index == Section::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
     for (const auto *Group : Section->Groups) {
if (Section->Index == Section::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)
+        if (!TargetObjectWriter->is64Bit() &&
+            (CsectRelocCount >= XCOFF::RelocOverflow ||
+             Section->RelocationCount >=
+                 XCOFF::RelocOverflow - CsectRelocCount))
           report_fatal_error(
               "relocation entries overflowed; overflow section is "
               "not implemented yet");
 
         Section->RelocationCount += CsectRelocCount;
       }
     }
   }
 
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
   for (auto Sec : Sections) {
     if (Sec->Index == Section::UninitializedIndex || !Sec->RelocationCount)
       continue;
 
     Sec->FileOffsetToRelocations = RawPointer;
-    const uint32_t RelocationSizeInSec =
+    uint64_t RelocationSizeInSec;
+    if (TargetObjectWriter->is64Bit())
+      RelocationSizeInSec =
+          Sec->RelocationCount * XCOFF::RelocationSerializationSize64;
+    else
+      RelocationSizeInSec =
           Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
+
     RawPointer += RelocationSizeInSec;
-    if (RawPointer > UINT32_MAX)
+    if (RawPointer > UINT32_MAX && !TargetObjectWriter->is64Bit())
       report_fatal_error("Relocation data overflowed this object file.");
   }
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
for (auto &Csect : UndefinedCsects) {
     SymbolIndexMap[Csect.MCCsect->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(); });
for (auto *Section : Sections) {
     // DefaultSectionAlign.
     Address = alignTo(Address, DefaultSectionAlign);
     Section->Size = Address - Section->Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
-  uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
-                        SectionCount * sizeof(XCOFF::SectionHeader32);
+  uint64_t RawPointer;
+  if (TargetObjectWriter->is64Bit())
+    RawPointer = sizeof(XCOFF::FileHeader64) + auxiliaryHeaderSize() +
+                 SectionCount * sizeof(XCOFF::SectionHeader64);
+  else
+    RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
+
   for (auto *Sec : Sections) {
     if (Sec->Index == Section::UninitializedIndex || Sec->IsVirtual)
       continue;
 
     Sec->FileOffsetToData = RawPointer;
     RawPointer += Sec->Size;
-    if (RawPointer > UINT32_MAX)
+    if (RawPointer > UINT32_MAX && !TargetObjectWriter->is64Bit())
       report_fatal_error("Section raw data overflowed this object file.");
   }
 
   RelocationEntryOffset = RawPointer;
 }
 
 // Takes the log base 2 of the alignment and shifts the result into the 5 most
 // significant bits of a byte, then or's in the csect type into the least

llvm/lib/Object/XCOFFObjectFile.cpp

template <typename T> uint16_t XCOFFSectionHeader<T>::getSectionType() const {
   return DerivedXCOFFSectionHeader.Flags & SectionFlagsTypeMask;
 }
 
 template <typename T>
 bool XCOFFSectionHeader<T>::isReservedSectionType() const {
   return getSectionType() & SectionFlagsReservedMask;
 }
 
-bool XCOFFRelocation32::isRelocationSigned() const {
+template <typename VirtualAddress_t>
+bool XCOFFRelocation<VirtualAddress_t>::isRelocationSigned() const {
   return Info & XR_SIGN_INDICATOR_MASK;
 }
 
-bool XCOFFRelocation32::isFixupIndicated() const {
+template <typename VirtualAddress_t>
+bool XCOFFRelocation<VirtualAddress_t>::isFixupIndicated() const {
   return Info & XR_FIXUP_INDICATOR_MASK;
 }
 
-uint8_t XCOFFRelocation32::getRelocatedLength() const {
+template <typename VirtualAddress_t>
+uint8_t XCOFFRelocation<VirtualAddress_t>::getRelocatedLength() const {
   // The relocation encodes the bit length being relocated minus 1. Add back
   // the 1 to get the actual length being relocated.
   return (Info & XR_BIASED_LENGTH_MASK) + 1;
 }
 
 uintptr_t
 XCOFFObjectFile::getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
                                                uint32_t Distance) {
const XCOFFFileHeader32 *XCOFFObjectFile::fileHeader32() const {
   return static_cast<const XCOFFFileHeader32 *>(FileHeader);
 }
 
 const XCOFFFileHeader64 *XCOFFObjectFile::fileHeader64() const {
   assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
   return static_cast<const XCOFFFileHeader64 *>(FileHeader);
 }
 
-const XCOFFSectionHeader32 *
-XCOFFObjectFile::sectionHeaderTable32() const {
+const XCOFFSectionHeader32 *XCOFFObjectFile::sectionHeaderTable32() const {
   assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
   return static_cast<const XCOFFSectionHeader32 *>(SectionHeaderTable);
 }
 
-const XCOFFSectionHeader64 *
-XCOFFObjectFile::sectionHeaderTable64() const {
+const XCOFFSectionHeader64 *XCOFFObjectFile::sectionHeaderTable64() const {
   assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
   return static_cast<const XCOFFSectionHeader64 *>(SectionHeaderTable);
 }
 
 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   uintptr_t NextSymbolAddr = getAdvancedSymbolEntryAddress(
       Symb.p, toSymbolRef(Symb).getNumberOfAuxEntries() + 1);
 #ifndef NDEBUG
if (isSectionVirtual(Sec))
     return ArrayRef<uint8_t>();
 
   uint64_t OffsetToRaw;
   if (is64Bit())
     OffsetToRaw = toSection64(Sec)->FileOffsetToRawData;
   else
     OffsetToRaw = toSection32(Sec)->FileOffsetToRawData;
 
-  const uint8_t * ContentStart = base() + OffsetToRaw;
+  const uint8_t *ContentStart = base() + OffsetToRaw;
   uint64_t SectionSize = getSectionSize(Sec);
   if (checkOffset(Data, reinterpret_cast<uintptr_t>(ContentStart), SectionSize))
     return make_error<BinaryError>();
 
-  return makeArrayRef(ContentStart,SectionSize);
+  return makeArrayRef(ContentStart, SectionSize);
 }
 
 uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   uint64_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 

 }
 
 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   return is64Bit() ? toSection64(Sec)->FileOffsetToRawData == 0
                    : toSection32(Sec)->FileOffsetToRawData == 0;
 }
 
 relocation_iterator XCOFFObjectFile::section_rel_begin(DataRefImpl Sec) const {
-  if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+  DataRefImpl Ret;
+  if (is64Bit()) {
+    const XCOFFSectionHeader64 *SectionEntPtr = toSection64(Sec);
+    auto RelocationsOrErr = relocations64(*SectionEntPtr);
+    if (Error E = RelocationsOrErr.takeError())
+      return relocation_iterator(RelocationRef());
+    Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().begin());
+  } else {
     const XCOFFSectionHeader32 *SectionEntPtr = toSection32(Sec);
-  auto RelocationsOrErr = relocations(*SectionEntPtr);
+    auto RelocationsOrErr = relocations32(*SectionEntPtr);
     if (Error E = RelocationsOrErr.takeError())
       return relocation_iterator(RelocationRef());
-  DataRefImpl Ret;
     Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().begin());
+  }
   return relocation_iterator(RelocationRef(Ret, this));
 }
 
 relocation_iterator XCOFFObjectFile::section_rel_end(DataRefImpl Sec) const {
-  if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+  DataRefImpl Ret;
+  if (is64Bit()) {
+    const XCOFFSectionHeader64 *SectionEntPtr = toSection64(Sec);
+    auto RelocationsOrErr = relocations64(*SectionEntPtr);
+    if (Error E = RelocationsOrErr.takeError())
+      return relocation_iterator(RelocationRef());
+    Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().end());
+  } else {
     const XCOFFSectionHeader32 *SectionEntPtr = toSection32(Sec);
-  auto RelocationsOrErr = relocations(*SectionEntPtr);
+    auto RelocationsOrErr = relocations32(*SectionEntPtr);
     if (Error E = RelocationsOrErr.takeError())
       return relocation_iterator(RelocationRef());
-  DataRefImpl Ret;
     Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().end());
+  }
   return relocation_iterator(RelocationRef(Ret, this));
 }
 
 void XCOFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
+  if (is64Bit())
+    Rel.p = reinterpret_cast<uintptr_t>(viewAs<XCOFFRelocation64>(Rel.p) + 1);
+  else
     Rel.p = reinterpret_cast<uintptr_t>(viewAs<XCOFFRelocation32>(Rel.p) + 1);
 }
 
 uint64_t XCOFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
-  if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+  if (is64Bit()) {
+    const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
+    const XCOFFSectionHeader64 *Sec64 = sectionHeaderTable64();
+    const uint64_t RelocAddress = Reloc->VirtualAddress;
+    const uint16_t NumberOfSections = getNumberOfSections();
+    for (uint16_t I = 0; I < NumberOfSections; ++I) {
+      // Find which section this relocation is belonging to, and get the
+      // relocation offset relative to the start of the section.
+      if (Sec64->VirtualAddress <= RelocAddress &&
+          RelocAddress < Sec64->VirtualAddress + Sec64->SectionSize) {
+        return RelocAddress - Sec64->VirtualAddress;
+      }
+      ++Sec64;
+    }
+  } else {
     const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
     const XCOFFSectionHeader32 *Sec32 = sectionHeaderTable32();
     const uint32_t RelocAddress = Reloc->VirtualAddress;
     const uint16_t NumberOfSections = getNumberOfSections();
-  for (uint16_t i = 0; i < NumberOfSections; ++i) {
+    for (uint16_t I = 0; I < NumberOfSections; ++I) {
       // Find which section this relocation is belonging to, and get the
       // relocation offset relative to the start of the section.
       if (Sec32->VirtualAddress <= RelocAddress &&
           RelocAddress < Sec32->VirtualAddress + Sec32->SectionSize) {
         return RelocAddress - Sec32->VirtualAddress;
       }
       ++Sec32;
     }
+  }
   return InvalidRelocOffset;
 }
 
 symbol_iterator XCOFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
-  if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+  uint32_t Index;
+  if (is64Bit()) {
+    const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
+    Index = Reloc->SymbolIndex;
+
+    if (Index >= getNumberOfSymbolTableEntries64())
+      return symbol_end();
+  } else {
     const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
-  const uint32_t Index = Reloc->SymbolIndex;
+    Index = Reloc->SymbolIndex;
 
     if (Index >= getLogicalNumberOfSymbolTableEntries32())
       return symbol_end();
-
+  }
   DataRefImpl SymDRI;
   SymDRI.p = getSymbolEntryAddressByIndex(Index);
   return symbol_iterator(SymbolRef(SymDRI, this));
 }
 
 uint64_t XCOFFObjectFile::getRelocationType(DataRefImpl Rel) const {
   if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+    return viewAs<XCOFFRelocation64>(Rel.p)->Type;
   return viewAs<XCOFFRelocation32>(Rel.p)->Type;
 }
 
 void XCOFFObjectFile::getRelocationTypeName(
     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
-  if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+  StringRef Res;
+  if (is64Bit()) {
+    const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
+    Res = XCOFF::getRelocationTypeString(Reloc->Type);
+  } else {
     const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
-  StringRef Res = XCOFF::getRelocationTypeString(Reloc->Type);
+    Res = XCOFF::getRelocationTypeString(Reloc->Type);
+  }
   Result.append(Res.begin(), Res.end());
 }
 
 Expected<uint32_t> XCOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
   uint32_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }

 }
 
 SubtargetFeatures XCOFFObjectFile::getFeatures() const {
   return SubtargetFeatures();
 }
 
 bool XCOFFObjectFile::isRelocatableObject() const {
   if (is64Bit())
-    report_fatal_error("64-bit support not implemented yet");
+    return !(fileHeader64()->Flags & NoRelMask);
   return !(fileHeader32()->Flags & NoRelMask);
 }
 
 Expected<uint64_t> XCOFFObjectFile::getStartAddress() const {
   // TODO FIXME Should get from auxiliary_header->o_entry when support for the
   // auxiliary_header is added.
   return 0;
 }
return StringSwitch<StringRef>(Name)
       .Default(Name);
 }
 
 size_t XCOFFObjectFile::getFileHeaderSize() const {
   return is64Bit() ? sizeof(XCOFFFileHeader64) : sizeof(XCOFFFileHeader32);
 }
 
 size_t XCOFFObjectFile::getSectionHeaderSize() const {
-  return is64Bit() ? sizeof(XCOFFSectionHeader64) :
-                     sizeof(XCOFFSectionHeader32);
+  return is64Bit() ? sizeof(XCOFFSectionHeader64)
+                   : sizeof(XCOFFSectionHeader32);
 }
 
 bool XCOFFObjectFile::is64Bit() const {
   return Binary::ID_XCOFF64 == getType();
 }
 
 uint16_t XCOFFObjectFile::getMagic() const {
   return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
ArrayRef<XCOFFSectionHeader32> XCOFFObjectFile::sections32() const {
   return ArrayRef<XCOFFSectionHeader32>(TablePtr,
                                         TablePtr + getNumberOfSections());
 }
 
 // In an XCOFF32 file, when the field value is 65535, then an STYP_OVRFLO
 // section header contains the actual count of relocation entries in the s_paddr
 // field. STYP_OVRFLO headers contain the section index of their corresponding
 // sections as their raw "NumberOfRelocations" field value.
-Expected<uint32_t> XCOFFObjectFile::getLogicalNumberOfRelocationEntries(
+Expected<uint32_t> XCOFFObjectFile::getLogicalNumberOfRelocationEntries32(
     const XCOFFSectionHeader32 &Sec) const {
 
   uint16_t SectionIndex = &Sec - sectionHeaderTable32() + 1;
 
   if (Sec.NumberOfRelocations < XCOFF::RelocOverflow)
     return Sec.NumberOfRelocations;
   for (const auto &Sec : sections32()) {
     if (Sec.Flags == XCOFF::STYP_OVRFLO &&
         Sec.NumberOfRelocations == SectionIndex)
       return Sec.PhysicalAddress;
   }
   return errorCodeToError(object_error::parse_failed);
 }
 
 Expected<ArrayRef<XCOFFRelocation32>>
-XCOFFObjectFile::relocations(const XCOFFSectionHeader32 &Sec) const {
+XCOFFObjectFile::relocations32(const XCOFFSectionHeader32 &Sec) const {
   uintptr_t RelocAddr = getWithOffset(reinterpret_cast<uintptr_t>(FileHeader),
                                       Sec.FileOffsetToRelocationInfo);
-  auto NumRelocEntriesOrErr = getLogicalNumberOfRelocationEntries(Sec);
+  auto NumRelocEntriesOrErr = getLogicalNumberOfRelocationEntries32(Sec);
   if (Error E = NumRelocEntriesOrErr.takeError())
     return std::move(E);
 
   uint32_t NumRelocEntries = NumRelocEntriesOrErr.get();
 
   static_assert(
       sizeof(XCOFFRelocation32) == XCOFF::RelocationSerializationSize32, "");
   auto RelocationOrErr =
       getObject<XCOFFRelocation32>(Data, reinterpret_cast<void *>(RelocAddr),
                                    NumRelocEntries * sizeof(XCOFFRelocation32));
   if (Error E = RelocationOrErr.takeError())
     return std::move(E);
 
   const XCOFFRelocation32 *StartReloc = RelocationOrErr.get();
 
   return ArrayRef<XCOFFRelocation32>(StartReloc, StartReloc + NumRelocEntries);
 }
 
+uint32_t XCOFFObjectFile::getNumberOfRelocationEntries64(
+    const XCOFFSectionHeader64 &Sec) const {
+  return Sec.NumberOfRelocations;
+}
+
+Expected<ArrayRef<XCOFFRelocation64>>
+XCOFFObjectFile::relocations64(const XCOFFSectionHeader64 &Sec) const {
+  uintptr_t RelocAddr = getWithOffset(reinterpret_cast<uintptr_t>(FileHeader),
+                                      Sec.FileOffsetToRelocationInfo);
+  uint32_t NumRelocEntries = getNumberOfRelocationEntries64(Sec);
+
+  static_assert(
+      sizeof(XCOFFRelocation64) == XCOFF::RelocationSerializationSize64, "");
+  auto RelocationOrErr =
+      getObject<XCOFFRelocation64>(Data, reinterpret_cast<void *>(RelocAddr),
+                                   NumRelocEntries * sizeof(XCOFFRelocation64));
+  if (Error E = RelocationOrErr.takeError())
+    return std::move(E);
+
+  const XCOFFRelocation64 *StartReloc = RelocationOrErr.get();
+
+  return ArrayRef<XCOFFRelocation64>(StartReloc, StartReloc + NumRelocEntries);
+}
+
 Expected<XCOFFStringTable>
 XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
   // If there is a string table, then the buffer must contain at least 4 bytes
   // for the string table's size. Not having a string table is not an error.
   if (Error E = Binary::checkOffset(
           Obj->Data, reinterpret_cast<uintptr_t>(Obj->base() + Offset), 4)) {
     consumeError(std::move(E));
     return XCOFFStringTable{0, nullptr};
Expected<StringRef> XCOFFSymbolRef::getName() const {
 
   return OwningObjectPtr->getStringTableEntry(Entry64->Offset);
 }
 
 // Explictly instantiate template classes.
 template struct XCOFFSectionHeader<XCOFFSectionHeader32>;
 template struct XCOFFSectionHeader<XCOFFSectionHeader64>;
 
+template struct XCOFFRelocation<llvm::support::ubig32_t>;
+template struct XCOFFRelocation<llvm::support::ubig64_t>;
+
 bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes) {
   if (Bytes.size() < 4)
     return false;
 
   return support::endian::read32be(Bytes.data()) == 0;
 }
 
 TBVectorExt::TBVectorExt(StringRef TBvectorStrRef) {

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

std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
 
   // The magic number we use in SignAndSize has a strong relationship with
   // the corresponding MCFixupKind. In most cases, it's the MCFixupKind
   // number - 1, because SignAndSize encodes the bit length being
   // relocated minus 1.
   switch ((unsigned)Fixup.getKind()) {
   default:
     report_fatal_error("Unimplemented fixup kind.");
+  case PPC::fixup_ppc_half16ds:
   case PPC::fixup_ppc_half16: {
     const uint8_t SignAndSizeForHalf16 = EncodedSignednessIndicator | 15;
     switch (Modifier) {
     default:
-      report_fatal_error("Unsupported modifier for half16 fixup.");
+      report_fatal_error("Unsupported modifier for half16/half16ds fixup.");
     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;
default:
       report_fatal_error("Unsupported modifier");
     case MCSymbolRefExpr::VK_PPC_AIX_TLSGD:
       return {XCOFF::RelocationType::R_TLS, EncodedSignednessIndicator | 31};
     case MCSymbolRefExpr::VK_PPC_AIX_TLSGDM:
       return {XCOFF::RelocationType::R_TLSM, EncodedSignednessIndicator | 31};
     case MCSymbolRefExpr::VK_None:
       return {XCOFF::RelocationType::R_POS, EncodedSignednessIndicator | 31};
     }
+  case FK_Data_8:
+    switch (Modifier) {
+    default:
+      report_fatal_error("Unsupported modifier");
+    case MCSymbolRefExpr::VK_PPC_AIX_TLSGD:
+      return {XCOFF::RelocationType::R_TLS, EncodedSignednessIndicator | 63};
+    case MCSymbolRefExpr::VK_PPC_AIX_TLSGDM:
+      return {XCOFF::RelocationType::R_TLSM, EncodedSignednessIndicator | 63};
+    case MCSymbolRefExpr::VK_None:
+      return {XCOFF::RelocationType::R_POS, EncodedSignednessIndicator | 63};
+    }
   }
 }

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: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -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 | \
 ; RUN:   FileCheck --check-prefix=XCOFF32 %s
 
-; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | \
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | \
 ; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
 
 @_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:     }
+
+; XCOFF64:          Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN3Foo1aE
+; XCOFF64-NEXT:     Value (RelocatableAddress): 0x0
+; XCOFF64-NEXT:     Section: N_UNDEF
+; XCOFF64-NEXT:     Type: 0x0
+; XCOFF64-NEXT:     StorageClass: C_EXT (0x2)
+; XCOFF64-NEXT:     NumberOfAuxEntries: 1
+; XCOFF64-NEXT:     CSECT Auxiliary Entry {
+; XCOFF64-NEXT:       Index: [[#Index+1]]
+; XCOFF64-NEXT:       SectionLen: 0
+; XCOFF64-NEXT:       ParameterHashIndex: 0x0
+; XCOFF64-NEXT:       TypeChkSectNum: 0x0
+; XCOFF64-NEXT:       SymbolAlignmentLog2: 0
+; XCOFF64-NEXT:       SymbolType: XTY_ER (0x0)
+; XCOFF64-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; XCOFF64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; XCOFF64-NEXT:     }

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: 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: 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: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o 2>&1 < %s | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
-
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-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=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:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; CHECKSYM-NEXT:       StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:       StabSectNum: 0x0
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]
+
+
+; CHECKSYM64: Symbols [
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 0
+; CHECKSYM64-NEXT:     Name: .file
+; CHECKSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+; CHECKSYM64-NEXT:     Section: N_DEBUG
+; CHECKSYM64-NEXT:     Source Language ID: TB_C (0x0)
+; CHECKSYM64-NEXT:     CPU Version ID: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_FILE (0x67)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 0
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index:]]
+; CHECKSYM64-NEXT:     Name: .foo_ext_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+1]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+2]]
+; CHECKSYM64-NEXT:     Name: foo_ext_weak_ref
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+3]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+4]]
+; CHECKSYM64-NEXT:     Name: b_w
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+5]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+6]]
+; CHECKSYM64-NEXT:     Name: .foo_ext_weak_ref
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+7]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+8]]
+; CHECKSYM64-NEXT:     Name: foo_ext_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+9]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+10]]
+; CHECKSYM64-NEXT:     Name: .text
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+11]]
+; CHECKSYM64-NEXT:       SectionLen: 80
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+12]]
+; CHECKSYM64-NEXT:     Name: .main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+13]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: 11
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+14]]
+; CHECKSYM64-NEXT:     Name: .data
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x50
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+15]]
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+16]]
+; CHECKSYM64-NEXT:     Name: foo_ext_weak_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x50
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+17]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: 15
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+18]]
+; CHECKSYM64-NEXT:     Name: main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x58
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+19]]
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+20]]
+; CHECKSYM64-NEXT:     Name: TOC
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+21]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+22]]
+; CHECKSYM64-NEXT:     Name: foo_ext_weak_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+23]]
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+24]]
+; CHECKSYM64-NEXT:     Name: b_w
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x78
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+25]]
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-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: 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: 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: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
-; RUN: -mattr=-altivec -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o 2>&1 < %s | FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-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=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:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; CHECKSYM-NEXT:       StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:       StabSectNum: 0x0
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]
+
+; CHECKSYM64: Symbols [
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 0
+; CHECKSYM64-NEXT:     Name: .file
+; CHECKSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+; CHECKSYM64-NEXT:     Section: N_DEBUG
+; CHECKSYM64-NEXT:     Source Language ID: TB_C (0x0)
+; CHECKSYM64-NEXT:     CPU Version ID: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_FILE (0x67)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 0
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 1
+; CHECKSYM64-NEXT:     Name: .bar_extern
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 2
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 3
+; CHECKSYM64-NEXT:     Name: .bar_ref
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 4
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 5
+; CHECKSYM64-NEXT:     Name: bar_ref
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 6
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 7
+; CHECKSYM64-NEXT:     Name: b_e
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 8
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 9
+; CHECKSYM64-NEXT:     Name: bar_extern
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 10
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 11
+; CHECKSYM64-NEXT:     Name: .text
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 12
+; CHECKSYM64-NEXT:       SectionLen: 112
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 13
+; CHECKSYM64-NEXT:     Name: .foo
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 14
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: 11
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 15
+; CHECKSYM64-NEXT:     Name: .main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x10
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 16
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: 11
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 17
+; CHECKSYM64-NEXT:     Name: .data
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 18
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 19
+; CHECKSYM64-NEXT:     Name: bar_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 20
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: 17
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 21
+; CHECKSYM64-NEXT:     Name: foo
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x78
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 22
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 23
+; CHECKSYM64-NEXT:     Name: main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 24
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 25
+; CHECKSYM64-NEXT:     Name: TOC
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xA8
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 26
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 27
+; CHECKSYM64-NEXT:     Name: b_e
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xA8
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 28
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 29
+; CHECKSYM64-NEXT:     Name: bar_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xB0
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 30
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-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: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS64 %s
 
 define i32 @foo()  align 32 {
 entry:
   ret i32 0
 }
 
 define i32 @bar()  align 64 {
 entry:

 ; 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
 ; SYMS-NEXT:    }
 ; SYMS-NEXT:  }
+
+; SYMS64:       Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .text
+; SYMS64-NEXT:    Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:    Section: .text
+; SYMS64-NEXT:    Type: 0x0
+; SYMS64-NEXT:    StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:    NumberOfAuxEntries: 1
+; SYMS64-NEXT:    CSECT Auxiliary Entry {
+; SYMS64-NEXT:      Index: [[#INDX+1]]
+; SYMS64-NEXT:      SectionLen: 72
+; SYMS64-NEXT:      ParameterHashIndex: 0x0
+; SYMS64-NEXT:      TypeChkSectNum: 0x0
+; SYMS64-NEXT:      SymbolAlignmentLog2: 6
+; SYMS64-NEXT:      SymbolType: XTY_SD (0x1)
+; SYMS64-NEXT:      StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:      Auxiliary Type: AUX_CSECT (0xFB) 
+; SYMS64-NEXT:    }
+; SYMS64-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: llvm-readobj --syms %t.o | FileCheck %s
-; RUN: not --crash llc -mtriple powerpc64-ibm-aix -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
-; RUN: -filetype=obj -o %t.o < %s 2>&1 | FileCheck --check-prefix=64-CHECK %s
+
+; RUN: llc -mtriple powerpc-ibm-aix -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
+; RUN: -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=CHECK64 %s
 
 define internal i32 @foo() {
   ret i32 1
 }
 
 ; CHECK:  Symbol {
 ; CHECK:       Name: .foo
 ; CHECK-NEXT:  Value (RelocatableAddress):

 ; 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
 
-;64-CHECK: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; CHECK64:  Symbol {
+; CHECK64:       Name: .foo
+; CHECK64-NEXT:  Value (RelocatableAddress):
+; CHECK64-NEXT:  Section: .text
+; CHECK64-NEXT:  Type: 0x0
+; CHECK64-NEXT:  StorageClass: C_HIDEXT (0x6B)
+
+; CHECK64:  Symbol {
+; CHECK64-NEXT: Index: [[#INDX:]]
+; CHECK64-NEXT: Name: foo
+; CHECK64-NEXT: Value (RelocatableAddress):
+; CHECK64-NEXT: Section: .data
+; CHECK64-NEXT: Type: 0x0
+; CHECK64-NEXT: StorageClass: C_HIDEXT (0x6B)
+; CHECK64-NEXT: NumberOfAuxEntries: 1
+; CHECK64-NEXT: CSECT Auxiliary Entry {
+; CHECK64-NEXT:  Index: [[#INDX+1]]
+; CHECK64-NEXT:  SectionLen: 12
+; CHECK64-NEXT:  ParameterHashIndex:
+; CHECK64-NEXT:  TypeChkSectNum:
+; CHECK64-NEXT:  SymbolAlignmentLog2:
+; CHECK64-NEXT:  SymbolType: XTY_SD (0x1)
+; CHECK64-NEXT:  StorageMappingClass: XMC_DS (0xA)
+
+; Make sure no label is emitted.
+; CHECK64-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: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:                 -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM64 %s
+; RUN: llvm-objdump -r -d --symbol-description %t.o | FileCheck --check-prefix=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

 ; 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]
 ; 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]
+
+
+; CHECKSYM64:        Symbol {
+; CHECKSYM64-NEXT:     Index: 0
+; CHECKSYM64-NEXT:     Name: .file
+; CHECKSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+; CHECKSYM64-NEXT:     Section: N_DEBUG
+; CHECKSYM64-NEXT:     Source Language ID: TB_C (0x0)
+; CHECKSYM64-NEXT:     CPU Version ID: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_FILE (0x67)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 0
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 1
+; CHECKSYM64-NEXT:     Name: .memset
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: N_UNDEF
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: 2
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB) 
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+
+; CHECKRELOC64:      00000000 (idx: 7) .bar:
+; CHECKRELOC64-NEXT:        0: 7c 08 02 a6                        mflr 0
+; 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)
+; CHECKRELOC64-NEXT:                      0000000e:  R_TOC        (idx: 13) s[TC]
+; CHECKRELOC64-NEXT:       10: 80 83 00 04                        lwz 4, 4(3)
+; CHECKRELOC64-NEXT:       14: 7c 85 23 78                        mr 5, 4
+; CHECKRELOC64-NEXT:       18: 4b ff ff e9                        bl 0x0
+; CHECKRELOC64-NEXT:                      00000018:  R_RBR        (idx: 1) .memset[PR]

llvm/test/CodeGen/PowerPC/aix-overflow-toc.py

 # UNSUPPORTED: expensive_checks, debug
 
 # RUN: %python %s > %t.ll
 # RUN: llc -mtriple powerpc-ibm-aix-xcoff -code-model=small -data-sections=false -mcpu=pwr4 -mattr=-altivec -O0 < %t.ll | \
 # RUN:   FileCheck --check-prefix=ASM32 %s
 
 # RUN: llc -mtriple powerpc64-ibm-aix-xcoff -code-model=small -data-sections=false -mcpu=pwr4 -mattr=-altivec -O0 < %t.ll | \
 # RUN:   FileCheck --check-prefix=ASM64 %s
 
 # RUN: llc -mtriple powerpc-ibm-aix-xcoff -code-model=small -data-sections=false -mcpu=pwr4 -mattr=-altivec -O0 \
 # RUN:     -filetype=obj -o %t.o < %t.ll
 # RUN: llvm-objdump -D -r --symbol-description %t.o | FileCheck --check-prefix=DIS32 %s
 
-# RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false \
-# RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %t.ll | \
-# RUN:   FileCheck --check-prefix=XCOFF64 %s
-# XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+# RUN: llc -mtriple powerpc64-ibm-aix-xcoff -code-model=small -data-sections=false -mcpu=pwr4 -mattr=-altivec -O0 \
+# RUN:     -filetype=obj -o %t.o < %t.ll
+# RUN: llvm-objdump -D -r --symbol-description %t.o | FileCheck --check-prefix=DIS64 %s
 
 numentries = 12290
 for x in range(0, numentries):
     print("@a%d = global i32 0, align 4" % (x))
 
 print("define void @foo() {")
 print("entry:")
 for x in range(0, numentries):

 # DIS32:      00010006:  R_TOC  (idx: 40975) a8192[TC]
 # DIS32:   1000c: 80 82 80 04   lwz 4, -32764(2)
 # DIS32:      0001000e:  R_TOC  (idx: 40977) a8193[TC]
 
 # DIS32:   18004: 80 82 c0 00   lwz 4, -16384(2)
 # DIS32:      00018006:  R_TOC  (idx: 49167) a12288[TC]
 # DIS32:   1800c: 80 82 c0 04   lwz 4, -16380(2)
 # DIS32:      0001800e:  R_TOC  (idx: 49169) a12289[TC]
+
+# DIS64:   0: e8 82 00 00   ld 4, 0(2)
+# DIS64:  00000002:  R_TOC  (idx: 24591) a0[TC]
+# DIS64:   c: e8 82 00 08   ld 4, 8(2)
+# DIS64:  0000000e:  R_TOC  (idx: 24593) a1[TC]
+
+# DIS64:    fffc: e8 82 ff f8   ld 4, -8(2)
+# DIS64:      0000fffe:  R_TOC  (idx: 40973) a8191[TC]
+# DIS64:   10004: e8 82 00 00   ld 4, 0(2)
+# DIS64:      00010006:  R_TOC  (idx: 40975) a8192[TC]
+# DIS64:   1000c: e8 82 00 08   ld 4, 8(2)
+# DIS64:      0001000e:  R_TOC  (idx: 40977) a8193[TC]
+
+# DIS64:   18004: e8 82 80 00   ld 4, -32768(2)
+# DIS64:      00018006:  R_TOC  (idx: 49167) a12288[TC]
+# DIS64:   1800c: e8 82 80 08   ld 4, -32760(2)
+# DIS64:      0001800e:  R_TOC  (idx: 49169) a12289[TC]

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 -sections %t.o | FileCheck --check-prefix=CHECKSECT %s
 
-; RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | \
-; RUN: FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc64-ibm-aix-xcoff \
+; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false < %s | FileCheck %s
+; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc64-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=CHECKOBJ64 %s
+; RUN: llvm-readobj -sections %t.o | FileCheck --check-prefix=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

 ;CHECKSECT-NEXT:     RawDataOffset: 0x78
 ;CHECKSECT-NEXT:     RelocationPointer: 0x94
 ;CHECKSECT-NEXT:     LineNumberPointer: 0x0
 ;CHECKSECT-NEXT:     NumberOfRelocations: 2
 ;CHECKSECT-NEXT:     NumberOfLineNumbers: 0
 ;CHECKSECT-NEXT:     Type: STYP_DATA (0x40)
 ;CHECKSECT-NEXT:   }
 ;CHECKSECT-NEXT: ]
+
+;CHECKOBJ64:      00000000 <.text>:
+;CHECKOBJ64-NEXT:       0: 38 60 00 37                    li 3, 55
+;CHECKOBJ64-NEXT:       4: 4e 80 00 20                    blr{{[[:space:]] *}}
+;CHECKOBJ64-NEXT: 00000008 <.rodata.str1.1>:
+;CHECKOBJ64-NEXT:       8: 68 65 6c 6c                   xori 5, 3, 27756
+;CHECKOBJ64-NEXT:       c: 6f 77 6f 72 xoris 23, 27, 28530
+;CHECKOBJ64-NEXT:      10: 0a 00 00 00 tdlti 0, 0{{[[:space:]] *}}
+;CHECKOBJ64-NEXT: Disassembly of section .data:{{[[:space:]] *}}
+;CHECKOBJ64-NEXT: 00000018 <a>:
+;CHECKOBJ64-NEXT:      18: 00 01 23 45                   <unknown>
+;CHECKOBJ64-NEXT:      1c: 67 8a bc de                   oris 10, 28, 48350{{[[:space:]] *}}
+;CHECKOBJ64-NEXT: 00000020 <d>:
+;CHECKOBJ64-NEXT:      20: 40 14 00 00                   bdnzf   20, 0x20
+;CHECKOBJ64-NEXT:      24: 00 00 00 00                   <unknown>{{[[:space:]] *}}
+;CHECKOBJ64-NEXT: 00000028 <foo>:
+;CHECKOBJ64-NEXT:      ... 
+;CHECKOBJ64-NEXT:      34: 00 00 00 40                   <unknown>
+;CHECKOBJ64-NEXT:      ...
+
+;CHECKSECT64: Sections [
+;CHECKSECT64-NEXT:   Section {
+;CHECKSECT64-NEXT:     Index: 1
+;CHECKSECT64-NEXT:     Name: .text
+;CHECKSECT64-NEXT:     PhysicalAddress: 0x0
+;CHECKSECT64-NEXT:     VirtualAddress: 0x0
+;CHECKSECT64-NEXT:     Size: 0x14
+;CHECKSECT64-NEXT:     RawDataOffset: 0xA8
+;CHECKSECT64-NEXT:     RelocationPointer: 0x0
+;CHECKSECT64-NEXT:     LineNumberPointer: 0x0
+;CHECKSECT64-NEXT:     NumberOfRelocations: 0
+;CHECKSECT64-NEXT:     NumberOfLineNumbers: 0
+;CHECKSECT64-NEXT:     Type: STYP_TEXT (0x20)
+;CHECKSECT64-NEXT:   }
+;CHECKSECT64-NEXT:   Section {
+;CHECKSECT64-NEXT:     Index: 2
+;CHECKSECT64-NEXT:     Name: .data
+;CHECKSECT64-NEXT:     PhysicalAddress: 0x18
+;CHECKSECT64-NEXT:     VirtualAddress: 0x18
+;CHECKSECT64-NEXT:     Size: 0x28
+;CHECKSECT64-NEXT:     RawDataOffset: 0xBC
+;CHECKSECT64-NEXT:     RelocationPointer: 0xE4
+;CHECKSECT64-NEXT:     LineNumberPointer: 0x0
+;CHECKSECT64-NEXT:     NumberOfRelocations: 2
+;CHECKSECT64-NEXT:     NumberOfLineNumbers: 0
+;CHECKSECT64-NEXT:     Type: STYP_DATA (0x40)
+;CHECKSECT64-NEXT:   }
+;CHECKSECT64-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-variables.ll

 ; This file tests the codegen of tls variables in AIX XCOFF object files
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=SECTION %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS-DATASECT %s
 ; RUN: llvm-objdump -D --symbol-description %t.o | FileCheck --check-prefixes=OBJDUMP-DATASECT %s
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=SECTION %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS,SYMS-NODATASECT %s
 ; RUN: llvm-objdump -D --symbol-description %t.o | FileCheck --check-prefixes=OBJDUMP-NODATASECT %s
 
-; RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=SECTION64 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS64,SYMS64-DATASECT %s
+; RUN: llvm-objdump -D --symbol-description %t.o | FileCheck --check-prefixes=OBJDUMP-DATASECT64 %s
+
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=SECTION64 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefixes=SYMS64,SYMS64-NODATASECT %s
+; RUN: llvm-objdump -D --symbol-description %t.o | FileCheck --check-prefixes=OBJDUMP-NODATASECT64 %s
 
 ; SECTION:      File: {{.*}}aix-tls-xcoff-variables.ll.tmp.o
 ; SECTION-NEXT: Format: aixcoff-rs6000
 ; SECTION-NEXT: Arch: powerpc
 ; SECTION-NEXT: AddressSize: 32bit
 ; SECTION-NEXT: Sections [
 ; SECTION-NEXT:   Section {
 ; SECTION-NEXT:     Index: 1

 @tls_global_double_common_zero_initialized = common thread_local global double 0.000000e+00, align 8
 @tls_global_double_external_uninitialized = external thread_local global i64, align 8
 @tls_global_long_long_internal_val_initialized = internal thread_local global i64 1, align 8
 @tls_global_long_long_internal_zero_initialized = internal thread_local global i64 0, align 8
 @tls_global_long_long_weak_val_initialized = weak thread_local global i64 1, align 8
 @tls_global_long_long_weak_zero_initialized = weak thread_local global i64 0, align 8
 @tls_global_alias_int_external_val_initialized = thread_local alias i32, i32* @tls_global_int_external_val_initialized
 @const_ivar = constant i32 6, align 4
+
+
+; SECTION64:      File: {{.*}}aix-tls-xcoff-variables.ll.tmp.o
+; SECTION64-NEXT: Format: aix5coff64-rs6000
+; SECTION64-NEXT: Arch: powerpc64
+; SECTION64-NEXT: AddressSize: 64bit
+; SECTION64-NEXT: Sections [
+; SECTION64-NEXT:   Section {
+; SECTION64-NEXT:     Index: 1
+; SECTION64-NEXT:     Name: .text
+; SECTION64-NEXT:     PhysicalAddress: 0x0
+; SECTION64-NEXT:     VirtualAddress: 0x0
+; SECTION64-NEXT:     Size: 0x4
+; SECTION64-NEXT:     RawDataOffset: 0xF0
+; SECTION64-NEXT:     RelocationPointer: 0x0
+; SECTION64-NEXT:     LineNumberPointer: 0x0
+; SECTION64-NEXT:     NumberOfRelocations: 0
+; SECTION64-NEXT:     NumberOfLineNumbers: 0
+; SECTION64-NEXT:     Type: STYP_TEXT (0x20)
+; SECTION64-NEXT:   }
+; SECTION64-NEXT:   Section {
+; SECTION64-NEXT:     Index: 2
+; SECTION64-NEXT:     Name: .tdata
+; SECTION64-NEXT:     PhysicalAddress: 0x0
+; SECTION64-NEXT:     VirtualAddress: 0x0
+; SECTION64-NEXT:     Size: 0x30
+; SECTION64-NEXT:     RawDataOffset: 0xF4
+; SECTION64-NEXT:     RelocationPointer: 0x0
+; SECTION64-NEXT:     LineNumberPointer: 0x0
+; SECTION64-NEXT:     NumberOfRelocations: 0
+; SECTION64-NEXT:     NumberOfLineNumbers: 0
+; SECTION64-NEXT:     Type: STYP_TDATA (0x400)
+; SECTION64-NEXT:   }
+; SECTION64-NEXT:   Section {
+; SECTION64-NEXT:     Index: 3
+; SECTION64-NEXT:     Name: .tbss
+; SECTION64-NEXT:     PhysicalAddress: 0x30
+; SECTION64-NEXT:     VirtualAddress: 0x30
+; SECTION64-NEXT:     Size: 0x18
+; SECTION64-NEXT:     RawDataOffset: 0x0
+; SECTION64-NEXT:     RelocationPointer: 0x0
+; SECTION64-NEXT:     LineNumberPointer: 0x0
+; SECTION64-NEXT:     NumberOfRelocations: 0
+; SECTION64-NEXT:     NumberOfLineNumbers: 0
+; SECTION64-NEXT:     Type: STYP_TBSS (0x800)
+; SECTION64-NEXT:   }
+; SECTION64-NEXT: ]
+
+
+; SYMS64:      File: {{.*}}aix-tls-xcoff-variables.ll.tmp.o
+; SYMS64-NEXT: Format: aix5coff64-rs6000
+; SYMS64-NEXT: Arch: powerpc64
+; SYMS64-NEXT: AddressSize: 64bit
+; SYMS64-NEXT: Symbols [
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: 0
+; SYMS64-NEXT:     Name: .file
+; SYMS64-NEXT:     Value (SymbolTableIndex): 0x0
+; SYMS64-NEXT:     Section: N_DEBUG
+; SYMS64-NEXT:     Source Language ID: TB_C (0x0)
+; SYMS64-NEXT:     CPU Version ID: 0x0
+; SYMS64-NEXT:     StorageClass: C_FILE (0x67)
+; SYMS64-NEXT:     NumberOfAuxEntries: 0
+; SYMS64-NEXT:   }
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#INDX:]]
+; SYMS64-NEXT:     Name: tls_global_int_external_uninitialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: N_UNDEF
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+1]]
+; SYMS64-NEXT:       SectionLen: 0
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_ER (0x0)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+2]]
+; SYMS64-NEXT:     Name: tls_global_double_external_uninitialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: N_UNDEF
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+3]]
+; SYMS64-NEXT:       SectionLen: 0
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_ER (0x0)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+4]]
+; SYMS64-NEXT:     Name: .text
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+5]]
+; SYMS64-NEXT:       SectionLen: 0
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64-NODATASECT:        Symbol {
+; SYMS64-NODATASECT-NEXT:     Index: [[#INDX+6]]
+; SYMS64-NODATASECT-NEXT:     Name: .rodata
+; SYMS64-NODATASECT-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NODATASECT-NEXT:     Section: .text
+; SYMS64-NODATASECT-NEXT:     Type: 0x0
+; SYMS64-NODATASECT-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NODATASECT-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NODATASECT-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NODATASECT-NEXT:       Index: [[#INDX+7]]
+; SYMS64-NODATASECT-NEXT:       SectionLen: 4
+; SYMS64-NODATASECT-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NODATASECT-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NODATASECT-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NODATASECT-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NODATASECT-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NODATASECT-NEXT:     }
+; SYMS64-NODATASECT-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+6]]
+; SYMS64-NODATASECT: Index: [[#INDX+8]]
+; SYMS64-NEXT:     Name: const_ivar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+7]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+9]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+6]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64-NODATASECT:        Symbol {
+; SYMS64-NODATASECT-NEXT:     Index: [[#INDX+10]]
+; SYMS64-NODATASECT-NEXT:     Name: .tdata
+; SYMS64-NODATASECT-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NODATASECT-NEXT:     Section: .tdata
+; SYMS64-NODATASECT-NEXT:     Type: 0x0
+; SYMS64-NODATASECT-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NODATASECT-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NODATASECT-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NODATASECT-NEXT:       Index: [[#INDX+11]]
+; SYMS64-NODATASECT-NEXT:       SectionLen: 48
+; SYMS64-NODATASECT-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NODATASECT-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NODATASECT-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NODATASECT-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT-NEXT:       StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NODATASECT-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NODATASECT-NEXT:     }
+; SYMS64-NODATASECT-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+8]]
+; SYMS64-NODATASECT: Index: [[#INDX+12]]
+; SYMS64:          Name: tls_global_int_external_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+9]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+13]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+10]]
+; SYMS64-NODATASECT: Index: [[#INDX+14]]
+; SYMS64:          Name: tls_global_alias_int_external_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+11]]
+; SYMS64-DATASECT-NEXT:   ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYMS64-NODATASECT:      Index: [[#INDX+15]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+12]]
+; SYMS64-NODATASECT: Index: [[#INDX+16]]
+; SYMS64:          Name: tls_global_int_external_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x4
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+13]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+17]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+14]]
+; SYMS64-NODATASECT: Index: [[#INDX+18]]
+; SYMS64:          Name: tls_global_int_local_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x8
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+15]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+19]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+16]]
+; SYMS64-NODATASECT: Index: [[#INDX+20]]
+; SYMS64:          Name: tls_global_int_weak_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0xC
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+17]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+21]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+18]]
+; SYMS64-NODATASECT: Index: [[#INDX+22]]
+; SYMS64:          Name: tls_global_int_weak_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x10
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+19]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 4
+; SYMS64-NODATASECT:      Index: [[#INDX+23]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 2
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+20]]
+; SYMS64-NODATASECT: Index: [[#INDX+24]]
+; SYMS64:          Name: tls_global_long_long_internal_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x18
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+21]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 8
+; SYMS64-NODATASECT:      Index: [[#INDX+25]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 3
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+22]]
+; SYMS64-NODATASECT: Index: [[#INDX+26]]
+; SYMS64:          Name: tls_global_long_long_weak_val_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x20
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+23]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 8
+; SYMS64-NODATASECT:      Index: [[#INDX+27]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 3
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+24]]
+; SYMS64-NODATASECT: Index: [[#INDX+28]]
+; SYMS64:          Name: tls_global_long_long_weak_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x28
+; SYMS64-NEXT:     Section: .tdata
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:        Index: [[#INDX+25]]
+; SYMS64-DATASECT-NEXT:   SectionLen: 8
+; SYMS64-NODATASECT:      Index: [[#INDX+29]]
+; SYMS64-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
+; SYMS64:            ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-DATASECT:        SymbolAlignmentLog2: 3
+; SYMS64-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
+; SYMS64-NODATASECT:      SymbolAlignmentLog2: 0
+; SYMS64-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
+; SYMS64:            StorageMappingClass: XMC_TL (0x14)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+26]]
+; SYMS64-NODATASECT: Index: [[#INDX+30]]
+; SYMS64:          Name: tls_global_int_local_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x30
+; SYMS64-NEXT:     Section: .tbss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:   Index: [[#INDX+27]]
+; SYMS64-NODATASECT: Index: [[#INDX+31]]
+; SYMS64:            SectionLen: 4
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+28]]
+; SYMS64-NODATASECT: Index: [[#INDX+32]]
+; SYMS64:          Name: tls_global_int_common_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x34
+; SYMS64-NEXT:     Section: .tbss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:   Index: [[#INDX+29]]
+; SYMS64-NODATASECT: Index: [[#INDX+33]]
+; SYMS64:            SectionLen: 4
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+30]]
+; SYMS64-NODATASECT: Index: [[#INDX+34]]
+; SYMS64:          Name: tls_global_double_common_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x38
+; SYMS64-NEXT:     Section: .tbss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:   Index: [[#INDX+31]]
+; SYMS64-NODATASECT: Index: [[#INDX+35]]
+; SYMS64:            SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-DATASECT:   Index: [[#INDX+32]]
+; SYMS64-NODATASECT: Index: [[#INDX+36]]
+; SYMS64:          Name: tls_global_long_long_internal_zero_initialized
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x40
+; SYMS64-NEXT:     Section: .tbss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-DATASECT:   Index: [[#INDX+33]]
+; SYMS64-NODATASECT: Index: [[#INDX+37]]
+; SYMS64:            SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_UL (0x15)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+
+; OBJDUMP-DATASECT64:        Disassembly of section .text:
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000000 (idx: 7) const_ivar[RO]:
+; OBJDUMP-DATASECT64-NEXT:   0: 00 00 00 06   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   Disassembly of section .tdata:
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000000 (idx: 11) tls_global_alias_int_external_val_initialized:
+; OBJDUMP-DATASECT64-NEXT:   0: 00 00 00 01   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000004 (idx: 13) tls_global_int_external_zero_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   4: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000008 (idx: 15) tls_global_int_local_val_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   8: 00 00 00 02   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   0000000c (idx: 17) tls_global_int_weak_zero_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   c: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000010 (idx: 19) tls_global_int_weak_val_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   10: 00 00 00 01   <unknown>
+; OBJDUMP-DATASECT64-NEXT:   14: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000018 (idx: 21) tls_global_long_long_internal_val_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   18: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT64-NEXT:   1c: 00 00 00 01   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000020 (idx: 23) tls_global_long_long_weak_val_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   20: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT64-NEXT:   24: 00 00 00 01   <unknown>
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000028 (idx: 25) tls_global_long_long_weak_zero_initialized[TL]:
+; OBJDUMP-DATASECT64-NEXT:   ...
+; OBJDUMP-DATASECT64-EMPTY:
+
+; OBJDUMP-DATASECT64-NEXT:   Disassembly of section .tbss:
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000030 (idx: 27) tls_global_int_local_zero_initialized[UL]:
+; OBJDUMP-DATASECT64-NEXT:   ...
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000034 (idx: 29) tls_global_int_common_zero_initialized[UL]:
+; OBJDUMP-DATASECT64-NEXT:   ...
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000038 (idx: 31) tls_global_double_common_zero_initialized[UL]
+; OBJDUMP-DATASECT64-NEXT:   ...
+; OBJDUMP-DATASECT64-EMPTY:
+; OBJDUMP-DATASECT64-NEXT:   00000040 (idx: 33) tls_global_long_long_internal_zero_initialized[UL]:
+; OBJDUMP-DATASECT64-NEXT:   ...
+
+; OBJDUMP-NODATASECT64:       Disassembly of section .text:
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000000 (idx: 9) const_ivar:
+; OBJDUMP-NODATASECT64-NEXT:  0: 00 00 00 06   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  Disassembly of section .tdata:
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64:       00000000 (idx: 13) tls_global_int_external_val_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  0: 00 00 00 01   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000004 (idx: 17) tls_global_int_external_zero_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  4: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000008 (idx: 19) tls_global_int_local_val_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  8: 00 00 00 02   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  0000000c (idx: 21) tls_global_int_weak_zero_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  c: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000010 (idx: 23) tls_global_int_weak_val_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  10: 00 00 00 01   <unknown>
+; OBJDUMP-NODATASECT64-NEXT:  14: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000018 (idx: 25) tls_global_long_long_internal_val_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  18: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT64-NEXT:  1c: 00 00 00 01   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000020 (idx: 27) tls_global_long_long_weak_val_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  20: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT64-NEXT:  24: 00 00 00 01   <unknown>
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000028 (idx: 29) tls_global_long_long_weak_zero_initialized:
+; OBJDUMP-NODATASECT64-NEXT:  ...
+; OBJDUMP-NODATASECT64-EMPTY:
+
+; OBJDUMP-NODATASECT64-NEXT:  Disassembly of section .tbss:
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000030 (idx: 31) tls_global_int_local_zero_initialized[UL]:
+; OBJDUMP-NODATASECT64-NEXT:  ...
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000034 (idx: 33) tls_global_int_common_zero_initialized[UL]:
+; OBJDUMP-NODATASECT64-NEXT:  ...
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000038 (idx: 35) tls_global_double_common_zero_initialized[UL]:
+; OBJDUMP-NODATASECT64-NEXT:  ...
+; OBJDUMP-NODATASECT64-EMPTY:
+; OBJDUMP-NODATASECT64-NEXT:  00000040 (idx: 37) tls_global_long_long_internal_zero_initialized[UL]:
+; OBJDUMP-NODATASECT64-NEXT:  ...

llvm/test/CodeGen/PowerPC/aix-user-defined-memcpy.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN: -mattr=-altivec -filetype=obj -xcoff-traceback-table=false -o %t.o < %s
 
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=32-SYM %s
 
 ; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck \
 ; RUN: --check-prefix=32-REL %s
 
 ; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=32-DIS %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -mcpu=pwr4 -mattr=-altivec < %s | \
 ; RUN:   FileCheck %s
 
-; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
-; RUN: -mcpu=pwr4 -mattr=-altivec -filetype=obj < %s 2>&1 | FileCheck \
-; RUN: --check-prefix=64-CHECK %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec -filetype=obj -xcoff-traceback-table=false -o %t.o < %s
+
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=64-SYM %s
+
+; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck \
+; RUN: --check-prefix=64-REL %s
+
+; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=64-DIS %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -mcpu=pwr4 -mattr=-altivec < %s | \
+; RUN:   FileCheck %s
 
 ; Test verifies:
 ; If there exists a user-defined function whose name is the same as the
 ; "memcpy" ExternalSymbol's, we pick up the user-defined version, even if this
 ; may lead to some undefined behavior.
 
 define dso_local signext i32 @memcpy(i8* %destination, i32 signext %num) {
 entry:

 ; 32-DIS-NEXT:       18: 94 21 ff c0                   stwu 1, -64(1)
 ; 32-DIS-NEXT:       1c: 4b ff ff e5                   bl 0x0
 ; 32-DIS-NEXT:       20: 60 00 00 00                   nop
 ; 32-DIS-NEXT:       24: 38 21 00 40                   addi 1, 1, 64
 ; 32-DIS-NEXT:       28: 80 01 00 08                   lwz 0, 8(1)
 ; 32-DIS-NEXT:       2c: 7c 08 03 a6                   mtlr 0
 ; 32-DIS-NEXT:       30: 4e 80 00 20                   blr
 
-; 64-CHECK: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; 64-SYM:      Symbol {{[{][[:space:]] *}}Index: [[#Index:]]{{[[:space:]] *}}Name: .memcpy 
+; 64-SYM-NEXT:    Value (RelocatableAddress): 0x0
+; 64-SYM-NEXT:    Section: .text
+; 64-SYM-NEXT:    Type: 0x0
+; 64-SYM-NEXT:    StorageClass: C_EXT (0x2)
+; 64-SYM-NEXT:    NumberOfAuxEntries: 1
+; 64-SYM-NEXT:    CSECT Auxiliary Entry {
+; 64-SYM-NEXT:      Index: 4
+; 64-SYM-NEXT:      ContainingCsectSymbolIndex: 1
+; 64-SYM-NEXT:      ParameterHashIndex: 0x0
+; 64-SYM-NEXT:      TypeChkSectNum: 0x0
+; 64-SYM-NEXT:      SymbolAlignmentLog2: 0
+; 64-SYM-NEXT:      SymbolType: XTY_LD (0x2)
+; 64-SYM-NEXT:      StorageMappingClass: XMC_PR (0x0)
+; 64-SYM-NEXT:      Auxiliary Type: AUX_CSECT (0xFB)
+; 64-SYM-NEXT:    }
+; 64-SYM-NEXT:  }
+
+; 64-SYM-NOT: .memcpy
+
+; 64-REL:      Relocations [
+; 64-REL-NEXT:  Section (index: 2) .data {
+; 64-REL-NEXT:  Relocation {
+; 64-REL-NEXT:    Virtual Address: 0x38
+; 64-REL-NEXT:    Symbol: .memcpy (3)
+; 64-REL-NEXT:    IsSigned: No
+; 64-REL-NEXT:    FixupBitValue: 0
+; 64-REL-NEXT:    Length: 64
+; 64-REL-NEXT:    Type: R_POS (0x0)
+; 64-REL-NEXT:  }
+; 64-REL-NEXT:  Relocation {
+; 64-REL-NEXT:    Virtual Address: 0x40
+; 64-REL-NEXT:    Symbol: TOC (11)
+; 64-REL-NEXT:    IsSigned: No
+; 64-REL-NEXT:    FixupBitValue: 0
+; 64-REL-NEXT:    Length: 64
+; 64-REL-NEXT:    Type: R_POS (0x0)
+; 64-REL-NEXT:  }
+; 64-REL-NEXT:  Relocation {
+; 64-REL-NEXT:    Virtual Address: 0x50
+; 64-REL-NEXT:    Symbol: .call_memcpy (5)
+; 64-REL-NEXT:    IsSigned: No
+; 64-REL-NEXT:    FixupBitValue: 0
+; 64-REL-NEXT:    Length: 64
+; 64-REL-NEXT:    Type: R_POS (0x0)
+; 64-REL-NEXT:  }
+; 64-REL-NEXT:  Relocation {
+; 64-REL-NEXT:    Virtual Address: 0x58
+; 64-REL-NEXT:    Symbol: TOC (11)
+; 64-REL-NEXT:    IsSigned: No
+; 64-REL-NEXT:    FixupBitValue: 0
+; 64-REL-NEXT:    Length: 64
+; 64-REL-NEXT:    Type: R_POS (0x0)
+; 64-REL-NEXT:  }
+; 64-REL-NEXT:  }
+; 64-REL-NEXT: ]
+
+; 64-REL-NOT:  Type: R_RBR (0x1A)
+
+; 64-DIS:      Disassembly of section .text:
+; 64-DIS:      00000000 <.text>:
+; 64-DIS-NEXT:        0: 38 60 00 03                   li 3, 3
+; 64-DIS-NEXT:        4: 4e 80 00 20                   blr
+; 64-DIS-NEXT:        8: 60 00 00 00                   nop
+; 64-DIS-NEXT:        c: 60 00 00 00                   nop
+; 64-DIS:      00000010 <.call_memcpy>:
+; 64-DIS-NEXT:       10: 7c 08 02 a6                   mflr 0
+; 64-DIS-NEXT:       14: f8 01 00 10                   std 0, 16(1)
+; 64-DIS-NEXT:       18: f8 21 ff 91                   stdu 1, -112(1)
+; 64-DIS-NEXT:       1c: 4b ff ff e5                   bl 0x0
+; 64-DIS-NEXT:       20: 60 00 00 00                   nop
+; 64-DIS-NEXT:       24: 38 21 00 70                   addi 1, 1, 112
+; 64-DIS-NEXT:       28: e8 01 00 10                   ld 0, 16(1)
+; 64-DIS-NEXT:       2c: 7c 08 03 a6                   mtlr 0
+; 64-DIS-NEXT:       30: 4e 80 00 20                   blr

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: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
-; RUN: -mattr=-altivec -data-sections=false -filetype=obj -o %t.o 2>&1 < %s | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-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=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:       SymbolAlignmentLog2: 2
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; CHECKSYM-NEXT:       StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:       StabSectNum: 0x0
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT: ]
+
+; CHECKSYM64:      Symbols [
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: 0
+; CHECKSYM64-NEXT:     Name: .file
+; CHECKSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+; CHECKSYM64-NEXT:     Section: N_DEBUG
+; CHECKSYM64-NEXT:     Source Language ID: TB_C (0x0)
+; CHECKSYM64-NEXT:     CPU Version ID: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_FILE (0x67)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 0
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index:]]
+; CHECKSYM64-NEXT:     Name: .text
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+1]]
+; CHECKSYM64-NEXT:       SectionLen: 136
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+2]]
+; CHECKSYM64-NEXT:     Name: .foo_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+3]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+4]]
+; CHECKSYM64-NEXT:     Name: .foo_ref_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x20
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+5]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+6]]
+; CHECKSYM64-NEXT:     Name: .main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x30
+; CHECKSYM64-NEXT:     Section: .text
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+7]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+8]]
+; CHECKSYM64-NEXT:     Name: .data
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x88
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+9]]
+; CHECKSYM64-NEXT:       SectionLen: 12
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+10]]
+; CHECKSYM64-NEXT:     Name: foo_weak_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x88
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+11]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+12]]
+; CHECKSYM64-NEXT:     Name: b
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+13]]
+; CHECKSYM64-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+14]]
+; CHECKSYM64-NEXT:     Name: foo_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0x98
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+15]]
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+16]]
+; CHECKSYM64-NEXT:     Name: foo_ref_weak
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xB0
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+17]]
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+18]]
+; CHECKSYM64-NEXT:     Name: main
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xC8
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+19]]
+; CHECKSYM64-NEXT:       SectionLen: 24
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+20]]
+; CHECKSYM64-NEXT:     Name: TOC
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xE0
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+21]]
+; CHECKSYM64-NEXT:       SectionLen: 0
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+22]]
+; CHECKSYM64-NEXT:     Name: foo_weak_p
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xE0
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+23]]
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-NEXT:   Symbol {
+; CHECKSYM64-NEXT:     Index: [[#Index+24]]
+; CHECKSYM64-NEXT:     Name: b
+; CHECKSYM64-NEXT:     Value (RelocatableAddress): 0xE8
+; CHECKSYM64-NEXT:     Section: .data
+; CHECKSYM64-NEXT:     Type: 0x0
+; CHECKSYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM64-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM64-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM64-NEXT:       Index: [[#Index+25]]
+; CHECKSYM64-NEXT:       SectionLen: 8
+; CHECKSYM64-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM64-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM64-NEXT:       SymbolAlignmentLog2: 3
+; CHECKSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; CHECKSYM64-NEXT:     }
+; CHECKSYM64-NEXT:   }
+; CHECKSYM64-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 powerpc64-ibm-aix-xcoff < %s | 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
 
-; RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | \
-; RUN: FileCheck --check-prefix=OBJ64 %s
-; OBJ64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --syms %t.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: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj < %s 2>&1 | \
-; RUN: FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -mtriple powerpc64-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=OBJ64 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=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:      ]
 
+; OBJ64:      File: {{.*}}aix-xcoff-data.ll.tmp.o
+; OBJ64-NEXT: 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:
+; OBJ64-NEXT:   SymbolTableOffset: 0x170
+; OBJ64-NEXT:   SymbolTableEntries: 45
+; OBJ64-NEXT:   OptionalHeaderSize: 0x0
+; OBJ64-NEXT:   Flags: 0x0
+; OBJ64-NEXT: }
+
+; OBJ64:      Sections [
+; OBJ64:        Section {
+; OBJ64-NEXT:     Index: [[#OBJ_INDX:]]
+; OBJ64-NEXT:     Name: .text
+; OBJ64-NEXT:     PhysicalAddress: 0x0
+; OBJ64-NEXT:     VirtualAddress: 0x0
+; OBJ64-NEXT:     Size: 0x0
+; OBJ64-NEXT:     RawDataOffset: 0xF0
+; OBJ64-NEXT:     RelocationPointer: 0x0
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 0
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_TEXT (0x20)
+; OBJ64-NEXT:   }
+
+; OBJ64:        Section {
+; OBJ64-NEXT:     Index: [[#OBJ_INDX+1]]
+; OBJ64-NEXT:     Name: .data
+; OBJ64-NEXT:     PhysicalAddress: 0x0
+; OBJ64-NEXT:     VirtualAddress: 0x0
+; OBJ64-NEXT:     Size: 0x80
+; OBJ64-NEXT:     RawDataOffset: 0xF0
+; OBJ64-NEXT:     RelocationPointer: 0x0
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 0
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_DATA (0x40)
+; OBJ64-NEXT:   }
+
+; OBJ64:        Section {
+; OBJ64-NEXT:     Index: [[#OBJ_INDX+2]]
+; OBJ64-NEXT:     Name: .bss
+; OBJ64-NEXT:     PhysicalAddress: 0x80
+; OBJ64-NEXT:     VirtualAddress: 0x80
+; OBJ64-NEXT:     Size: 0x6C
+; OBJ64-NEXT:     RawDataOffset: 0x0
+; OBJ64-NEXT:     RelocationPointer: 0x0
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 0
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_BSS (0x80)
+; OBJ64-NEXT:   }
+; OBJ64:      ]
+
 ; 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:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS:      ]
+
+; SYMS64:      File: {{.*}}aix-xcoff-data.ll.tmp.o
+; SYMS64-NEXT: Format: aix5coff64-rs6000
+; SYMS64-NEXT: Arch: powerpc64
+; SYMS64-NEXT: AddressSize: 64bit
+; SYMS64:      Symbols [
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: 0
+; SYMS64-NEXT:     Name: .file
+; SYMS64-NEXT:     Value (SymbolTableIndex): 0x0
+; SYMS64-NEXT:     Section: N_DEBUG
+; SYMS64-NEXT:     Source Language ID: TB_C (0x0)
+; SYMS64-NEXT:     CPU Version ID: 0x0
+; SYMS64-NEXT:     StorageClass: C_FILE (0x67)
+; SYMS64-NEXT:     NumberOfAuxEntries: 0
+; SYMS64-NEXT:   }
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#INDX:]]
+; SYMS64-NEXT:     Name: .text
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+1]]
+; SYMS64-NEXT:       SectionLen: 0
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB) 
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+2]]
+; SYMS64-NEXT:     Name: .data
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+3]]
+; SYMS64-NEXT:       SectionLen: 128
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 5
+; SYMS64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB) 
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+4]]
+; SYMS64-NEXT:     Name: ivar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+5]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+6]]
+; SYMS64-NEXT:     Name: llvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x8
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+7]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB) 
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+8]]
+; SYMS64-NEXT:     Name: svar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x10
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+9]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB) 
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+10]]
+; SYMS64-NEXT:     Name: fvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x14
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+11]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+12]]
+; SYMS64-NEXT:     Name: dvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x18
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+13]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+14]]
+; SYMS64-NEXT:     Name: over_aligned
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x20
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+15]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+16]]
+; SYMS64-NEXT:     Name: chrarray
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x28
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+17]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+18]]
+; SYMS64-NEXT:     Name: dblarr
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x30
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+19]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+20]]
+; SYMS64-NEXT:     Name: d_0
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x50
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+21]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+22]]
+; SYMS64-NEXT:     Name: s_0
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x58
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+23]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+24]]
+; SYMS64-NEXT:     Name: f_0
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x5C
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+25]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+26]]
+; SYMS64-NEXT:     Name: astruct
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x60
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+27]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+28]]
+; SYMS64-NEXT:     Name: bstruct
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x70
+; SYMS64-NEXT:     Section: .data
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+29]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+30]]
+; SYMS64-NEXT:     Name: a
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x80
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+31]]
+; SYMS64-NEXT:       SectionLen: 4
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+32]]
+; SYMS64-NEXT:     Name: b
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x88
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+33]]
+; SYMS64-NEXT:       SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+34]]
+; SYMS64-NEXT:     Name: c
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x90
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+35]]
+; SYMS64-NEXT:       SectionLen: 2
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 1
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+36]]
+; SYMS64-NEXT:     Name: d
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x98
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+37]]
+; SYMS64-NEXT:       SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+38]]
+; SYMS64-NEXT:     Name: f
+; SYMS64-NEXT:     Value (RelocatableAddress): 0xA0
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+39]]
+; SYMS64-NEXT:       SectionLen: 4
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+40]]
+; SYMS64-NEXT:     Name: over_aligned_comm
+; SYMS64-NEXT:     Value (RelocatableAddress): 0xC0
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+41]]
+; SYMS64-NEXT:       SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 5
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+42]]
+; SYMS64-NEXT:     Name: array
+; SYMS64-NEXT:     Value (RelocatableAddress): 0xC8
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+43]]
+; SYMS64-NEXT:       SectionLen: 33
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64:      ]

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: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | \
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | \
 ; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
 
 @La = external global i32, align 4
 
 declare i32 @Lb(...)
 
 define void @foo() {
 entry:
   store i32 1, i32* @La, align 4

 ; 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:  }
+
+; XCOFF64:         Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .Lb
+; XCOFF64-NEXT:    Value (RelocatableAddress): 0x0
+; XCOFF64-NEXT:    Section: N_UNDEF
+; XCOFF64-NEXT:    Type: 0x0
+; XCOFF64-NEXT:    StorageClass: C_EXT (0x2)
+; XCOFF64-NEXT:    NumberOfAuxEntries: 1
+; XCOFF64-NEXT:    CSECT Auxiliary Entry {
+; XCOFF64-NEXT:      Index: [[#IND+1]]
+; XCOFF64-NEXT:      SectionLen: 0
+; XCOFF64-NEXT:      ParameterHashIndex: 0x0
+; XCOFF64-NEXT:      TypeChkSectNum: 0x0
+; XCOFF64-NEXT:      SymbolAlignmentLog2: 0
+; XCOFF64-NEXT:      SymbolType: XTY_ER (0x0)
+; XCOFF64-NEXT:      StorageMappingClass: XMC_PR (0x0)
+; XCOFF64-NEXT:      Auxiliary Type: AUX_CSECT (0xFB)
+; XCOFF64-NEXT:    }
+; XCOFF64-NEXT:  }
+; XCOFF64-NEXT:  Symbol {
+; XCOFF64-NEXT:    Index: [[#IND+2]]
+; XCOFF64-NEXT:    Name: La
+; XCOFF64-NEXT:    Value (RelocatableAddress): 0x0
+; XCOFF64-NEXT:    Section: N_UNDEF
+; XCOFF64-NEXT:    Type: 0x0
+; XCOFF64-NEXT:    StorageClass: C_EXT (0x2)
+; XCOFF64-NEXT:    NumberOfAuxEntries: 1
+; XCOFF64-NEXT:    CSECT Auxiliary Entry {
+; XCOFF64-NEXT:      Index: [[#IND+3]]
+; XCOFF64-NEXT:      SectionLen: 0
+; XCOFF64-NEXT:      ParameterHashIndex: 0x0
+; XCOFF64-NEXT:      TypeChkSectNum: 0x0
+; XCOFF64-NEXT:      SymbolAlignmentLog2: 0
+; XCOFF64-NEXT:      SymbolType: XTY_ER (0x0)
+; XCOFF64-NEXT:      StorageMappingClass: XMC_UA (0x4)
+; XCOFF64-NEXT:      Auxiliary Type: AUX_CSECT (0xFB)
+; XCOFF64-NEXT:    }
+; XCOFF64-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
 
-; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:                 -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.overflow.ll 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
-; RUN:                 -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.ll 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.overflow.ll
+; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=XCOFF64_OVERF %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-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=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-NOT:     Name: .ovrflo
+; XCOFF64-NOT:     Type: STYP_OVRFLO
+; XCOFF64:       Section {
+; XCOFF64:         Name: .data
+; XCOFF64-NEXT:    PhysicalAddress: 0x0
+; XCOFF64-NEXT:    VirtualAddress: 0x0
+; XCOFF64-NEXT:    Size: 0x7FFF0
+; XCOFF64-NEXT:    RawDataOffset: 0xA8
+; XCOFF64-NEXT:    RelocationPointer: 0x80098
+; XCOFF64-NEXT:    LineNumberPointer: 0x0
+; XCOFF64-NEXT:    NumberOfRelocations: 65534
+; XCOFF64-NEXT:    NumberOfLineNumbers: 0
+; XCOFF64-NEXT:    Type: STYP_DATA (0x40)
+; XCOFF64-NEXT:  }
+; XCOFF64-NOT:     Name: .ovrflo
+; XCOFF64-NOT:     Type: STYP_OVRFLO
+
+; XCOFF64_OVERF-NOT:     Name: .ovrflo
+; XCOFF64_OVERF-NOT:     Type: STYP_OVRFLO
+; XCOFF64_OVERF:       Section {
+; XCOFF64_OVERF:         Name: .data
+; XCOFF64_OVERF-NEXT:    PhysicalAddress: 0x0
+; XCOFF64_OVERF-NEXT:    VirtualAddress: 0x0
+; XCOFF64_OVERF-NEXT:    Size: 0x7FFF8
+; XCOFF64_OVERF-NEXT:    RawDataOffset: 0xA8
+; XCOFF64_OVERF-NEXT:    RelocationPointer: 0x800A0
+; XCOFF64_OVERF-NEXT:    LineNumberPointer: 0x0
+; XCOFF64_OVERF-NEXT:    NumberOfRelocations: 65535
+; XCOFF64_OVERF-NEXT:    NumberOfLineNumbers: 0
+; XCOFF64_OVERF-NEXT:    Type: STYP_DATA (0x40)
+; XCOFF64_OVERF-NEXT:  }
+; XCOFF64_OVERF-NOT:     Name: .ovrflo
+; XCOFF64_OVERF-NOT:     Type: STYP_OVRFLO

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: not --crash llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | \
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t.o | \
 ; RUN: FileCheck --check-prefix=OBJ64 %s
-; OBJ64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=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

 ; SYMS-NEXT:       SymbolAlignmentLog2: 1
 ; SYMS-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYMS-NEXT:       StorageMappingClass: XMC_BS (0x9)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 ; SYMS-NEXT: ]
+
+; OBJ64:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
+; OBJ64-NEXT: Format: aix5coff64-rs6000
+; OBJ64-NEXT: Arch: powerpc64
+; OBJ64-NEXT: AddressSize: 64bit
+; OBJ64-NEXT: FileHeader {
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ64-NEXT:   NumberOfSections: 2
+; OBJ64-NEXT:   TimeStamp:
+; OBJ64-NEXT:   SymbolTableOffset: 0xA8
+; OBJ64-NEXT:   SymbolTableEntries: 9
+; OBJ64-NEXT:   OptionalHeaderSize: 0x0
+; OBJ64-NEXT:   Flags: 0x0
+; OBJ64-NEXT: }
+; OBJ64-NEXT: Sections [
+; OBJ64:        Section {{[{][[:space:]] *}}Index: 2
+; OBJ64-NEXT:     Name: .bss
+; OBJ64-NEXT:     PhysicalAddress: 0x0
+; OBJ64-NEXT:     VirtualAddress: 0x0
+; OBJ64-NEXT:     Size: 0x14
+; OBJ64-NEXT:     RawDataOffset: 0x0
+; OBJ64-NEXT:     RelocationPointer: 0x0
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 0
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_BSS (0x80)
+; OBJ64-NEXT:   }
+; OBJ64-NEXT: ]
+
+; SYMS64:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
+; SYMS64-NEXT: Format: aix5coff64-rs6000
+; SYMS64-NEXT: Arch: powerpc64
+; SYMS64-NEXT: AddressSize: 64bit
+; SYMS64-NEXT: Symbols [
+; SYMS64:        Symbol {{[{][[:space:]] *}}Index: [[#Index:]]{{[[:space:]] *}}Name: a
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#Index + 1]]
+; SYMS64-NEXT:       SectionLen: 4
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 2
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_BS (0x9)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#Index + 2]]
+; SYMS64-NEXT:     Name: b
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x8
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#Index + 3]]
+; SYMS64-NEXT:       SectionLen: 8
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 3
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_BS (0x9)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64-NEXT:   Symbol {
+; SYMS64-NEXT:     Index: [[#Index + 4]]
+; SYMS64-NEXT:     Name: c
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x10
+; SYMS64-NEXT:     Section: .bss
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#Index + 5]]
+; SYMS64-NEXT:       SectionLen: 2
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 1
+; SYMS64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYMS64-NEXT:       StorageMappingClass: XMC_BS (0x9)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64-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 -t %t.o | FileCheck --check-prefixes=RELOC,SYM %s
 
-; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
-; RUN: -data-sections=false -filetype=obj < %s 2>&1 | \
-; RUN:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj -r --expand-relocs -t %t.o | FileCheck --check-prefixes=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

 ; 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
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
+
+; RELOC64:      Relocations [
+; RELOC64-NEXT:   Section (index: {{[0-9]+}}) .data {
+; RELOC64-NEXT:   Relocation {
+; RELOC64-NEXT:     Virtual Address: 0x0
+; RELOC64-NEXT:     Symbol: common ([[#COM_INDX:]])
+; RELOC64-NEXT:     IsSigned: No
+; RELOC64-NEXT:     FixupBitValue: 0
+; RELOC64-NEXT:     Length: 64
+; RELOC64-NEXT:     Type: R_POS (0x0)
+; RELOC64-NEXT:   }
+; RELOC64-NEXT: }
+; RELOC64-NEXT: ]
+
+; SYM64:        Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .data
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+1]]
+; SYM64-NEXT:       SectionLen: 8
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 3
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+2]]
+; SYM64-NEXT:     Name: pointer
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+3]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#COM_INDX]]
+; SYM64-NEXT:     Name: common
+; SYM64-NEXT:     Value (RelocatableAddress): 0x8
+; SYM64-NEXT:     Section: .bss
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#COM_INDX+1]]
+; SYM64-NEXT:       SectionLen: 4
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 2
+; SYM64-NEXT:       SymbolType: XTY_CM (0x3)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }

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 -t %t.o | FileCheck --check-prefix=SYM %s
 ; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=DIS %s
 ; RUN: llvm-objdump -r %t.o | FileCheck --check-prefix=DIS_REL %s
 
-; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -mattr=-altivec -data-sections=false -filetype=obj < %s 2>&1 | \
-; RUN: FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-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=OBJ64 %s
+; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck --check-prefix=RELOC64 %s
+; RUN: llvm-readobj -t %t.o | FileCheck --check-prefix=SYM64 %s
+; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=DIS64 %s
+; RUN: llvm-objdump -r %t.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:

 ; 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
+
+; OBJ64:      File: {{.*}}aix-xcoff-reloc.ll.tmp.o
+; OBJ64-NEXT: Format: aix5coff64-rs6000
+; OBJ64-NEXT: Arch: powerpc64
+; OBJ64-NEXT: AddressSize: 64bit
+; OBJ64-NEXT: FileHeader {
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ64-NEXT:   NumberOfSections: 2
+; OBJ64-NEXT:   TimeStamp: None (0x0)
+; OBJ64-NEXT:   SymbolTableOffset: 0x1B8
+; OBJ64-NEXT:   SymbolTableEntries: 27
+; OBJ64-NEXT:   OptionalHeaderSize: 0x0
+; OBJ64-NEXT:   Flags: 0x0
+; OBJ64-NEXT: }
+; OBJ64-NEXT: Sections [
+; OBJ64-NEXT:   Section {
+; OBJ64-NEXT:     Index: 1
+; OBJ64-NEXT:     Name: .text
+; OBJ64-NEXT:     PhysicalAddress: 0x0
+; OBJ64-NEXT:     VirtualAddress: 0x0
+; OBJ64-NEXT:     Size: 0x40
+; OBJ64-NEXT:     RawDataOffset: 0xA8
+; OBJ64-NEXT:     RelocationPointer: 0x148
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 3
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_TEXT (0x20)
+; OBJ64-NEXT:   }
+; OBJ64-NEXT:   Section {
+; OBJ64-NEXT:     Index: 2
+; OBJ64-NEXT:     Name: .data
+; OBJ64-NEXT:     PhysicalAddress: 0x40
+; OBJ64-NEXT:     VirtualAddress: 0x40
+; OBJ64-NEXT:     Size: 0x60
+; OBJ64-NEXT:     RawDataOffset: 0xE8
+; OBJ64-NEXT:     RelocationPointer: 0x172
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 5
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_DATA (0x40)
+; OBJ64-NEXT:   }
+; OBJ64-NEXT: ]
+
+
+; RELOC64:      File: {{.*}}aix-xcoff-reloc.ll.tmp.o
+; RELOC64-NEXT: Format: aix5coff64-rs6000
+; RELOC64-NEXT: Arch: powerpc64
+; RELOC64-NEXT: AddressSize: 64bit
+; RELOC64-NEXT: Relocations [
+; RELOC64-NEXT:   Section (index: 1) .text {
+; RELOC64-NEXT:   Relocation {
+; RELOC64-NEXT:     Virtual Address: 0x10
+; RELOC64-NEXT:     Symbol: .bar (1)
+; RELOC64-NEXT:     IsSigned: Yes
+; RELOC64-NEXT:     FixupBitValue: 0
+; RELOC64-NEXT:     Length: 26
+; RELOC64-NEXT:     Type: R_RBR (0x1A)
+; RELOC64-NEXT:   }
+; RELOC64-NEXT:   Relocation {
+; RELOC64-NEXT:     Virtual Address: 0x1A
+; RELOC64-NEXT:     Symbol: globalA (23)
+; RELOC64-NEXT:     IsSigned: No
+; RELOC64-NEXT:     FixupBitValue: 0
+; RELOC64-NEXT:     Length: 16
+; RELOC64-NEXT:     Type: R_TOC (0x3)
+; RELOC64-NEXT:   }
+; RELOC64-NEXT:   Relocation {
+; RELOC64-NEXT:     Virtual Address: 0x1E
+; RELOC64-NEXT:     Symbol: globalB (25)
+; RELOC64-NEXT:     IsSigned: No
+; RELOC64-NEXT:     FixupBitValue: 0
+; RELOC64-NEXT:     Length: 16
+; RELOC64-NEXT:     Type: R_TOC (0x3)
+; RELOC64-NEXT:   }
+; RELOC64-NEXT: }
+; RELOC64-NEXT: Section (index: 2) .data {
+; RELOC64-NEXT: Relocation {
+; RELOC64-NEXT:   Virtual Address: 0x70
+; RELOC64-NEXT:   Symbol: arr (15)
+; RELOC64-NEXT:   IsSigned: No
+; RELOC64-NEXT:   FixupBitValue: 0
+; RELOC64-NEXT:   Length: 64
+; RELOC64-NEXT:   Type: R_POS (0x0)
+; RELOC64-NEXT: }
+; RELOC64-NEXT: Relocation {
+; RELOC64-NEXT:   Virtual Address: 0x78
+; RELOC64-NEXT:   Symbol: .foo (7)
+; RELOC64-NEXT:   IsSigned: No
+; RELOC64-NEXT:   FixupBitValue: 0
+; RELOC64-NEXT:   Length: 64
+; RELOC64-NEXT:   Type: R_POS (0x0)
+; RELOC64-NEXT: }
+; RELOC64-NEXT: Relocation {
+; RELOC64-NEXT:   Virtual Address: 0x80
+; RELOC64-NEXT:   Symbol: TOC (21)
+; RELOC64-NEXT:   IsSigned: No
+; RELOC64-NEXT:   FixupBitValue: 0
+; RELOC64-NEXT:   Length: 64
+; RELOC64-NEXT:   Type: R_POS (0x0)
+; RELOC64-NEXT: }
+; RELOC64-NEXT: Relocation {
+; RELOC64-NEXT:   Virtual Address: 0x90
+; RELOC64-NEXT:   Symbol: globalA (11)
+; RELOC64-NEXT:   IsSigned: No
+; RELOC64-NEXT:   FixupBitValue: 0
+; RELOC64-NEXT:   Length: 64
+; RELOC64-NEXT:   Type: R_POS (0x0)
+; RELOC64-NEXT: }
+; RELOC64-NEXT: Relocation {
+; RELOC64-NEXT:   Virtual Address: 0x98
+; RELOC64-NEXT:   Symbol: globalB (13)
+; RELOC64-NEXT:   IsSigned: No
+; RELOC64-NEXT:   FixupBitValue: 0
+; RELOC64-NEXT:   Length: 64
+; RELOC64-NEXT:   Type: R_POS (0x0)
+; RELOC64-NEXT: }
+; RELOC64-NEXT: }
+; RELOC64-NEXT: ]
+
+; SYM64:      Symbols [
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: 0
+; SYM64-NEXT:     Name: .file
+; SYM64-NEXT:     Value (SymbolTableIndex): 0x0
+; SYM64-NEXT:     Section: N_DEBUG
+; SYM64-NEXT:     Source Language ID: TB_C (0x0)
+; SYM64-NEXT:     CPU Version ID: 0x0
+; SYM64-NEXT:     StorageClass: C_FILE (0x67)
+; SYM64-NEXT:     NumberOfAuxEntries: 0
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX:]]
+; SYM64-NEXT:     Name: .bar
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: N_UNDEF
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+1]]
+; SYM64-NEXT:       SectionLen: 0
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; SYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+2]]
+; SYM64-NEXT:     Name: bar
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: N_UNDEF
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+3]]
+; SYM64-NEXT:       SectionLen: 0
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_ER (0x0)
+; SYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+4]]
+; SYM64-NEXT:     Name: .text
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: .text
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+5]]
+; SYM64-NEXT:       SectionLen: 64
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 4
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+6]]
+; SYM64-NEXT:     Name: .foo
+; SYM64-NEXT:     Value (RelocatableAddress): 0x0
+; SYM64-NEXT:     Section: .text
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+7]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+4]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+8]]
+; SYM64-NEXT:     Name: .data
+; SYM64-NEXT:     Value (RelocatableAddress): 0x40
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+9]]
+; SYM64-NEXT:       SectionLen: 56
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 3
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+10]]
+; SYM64-NEXT:     Name: globalA
+; SYM64-NEXT:     Value (RelocatableAddress): 0x40
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+11]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+12]]
+; SYM64-NEXT:     Name: globalB
+; SYM64-NEXT:     Value (RelocatableAddress): 0x44
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+13]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+14]]
+; SYM64-NEXT:     Name: arr
+; SYM64-NEXT:     Value (RelocatableAddress): 0x48
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+15]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+16]]
+; SYM64-NEXT:     Name: p
+; SYM64-NEXT:     Value (RelocatableAddress): 0x70
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+17]]
+; SYM64-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 0
+; SYM64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYM64-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+18]]
+; SYM64-NEXT:     Name: foo
+; SYM64-NEXT:     Value (RelocatableAddress): 0x78
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_EXT (0x2)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+19]]
+; SYM64-NEXT:       SectionLen: 24
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 3
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+20]]
+; SYM64-NEXT:     Name: TOC
+; SYM64-NEXT:     Value (RelocatableAddress): 0x90
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+21]]
+; SYM64-NEXT:       SectionLen: 0
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 2
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+22]]
+; SYM64-NEXT:     Name: globalA
+; SYM64-NEXT:     Value (RelocatableAddress): 0x90
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+23]]
+; SYM64-NEXT:       SectionLen: 8
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 3
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT:   Symbol {
+; SYM64-NEXT:     Index: [[#INDX+24]]
+; SYM64-NEXT:     Name: globalB
+; SYM64-NEXT:     Value (RelocatableAddress): 0x98
+; SYM64-NEXT:     Section: .data
+; SYM64-NEXT:     Type: 0x0
+; SYM64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM64-NEXT:     NumberOfAuxEntries: 1
+; SYM64-NEXT:     CSECT Auxiliary Entry {
+; SYM64-NEXT:       Index: [[#INDX+25]]
+; SYM64-NEXT:       SectionLen: 8
+; SYM64-NEXT:       ParameterHashIndex: 0x0
+; SYM64-NEXT:       TypeChkSectNum: 0x0
+; SYM64-NEXT:       SymbolAlignmentLog2: 3
+; SYM64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM64-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; SYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYM64-NEXT:     }
+; SYM64-NEXT:   }
+; SYM64-NEXT: ]
+
+
+; DIS64:      {{.*}}aix-xcoff-reloc.ll.tmp.o:   file format aix5coff64-rs6000
+; DIS64:      Disassembly of section .text:
+; DIS64:      00000000 <.text>:
+; 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
+; 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:      00000040 <globalA>:
+; DIS64-NEXT:       40: 00 00 00 01                   <unknown>
+; DIS64:      00000044 <globalB>:
+; DIS64-NEXT:       44: 00 00 00 02                   <unknown>
+; DIS64:      00000048 <arr>:
+; DIS64-NEXT:       48: 00 00 00 03                   <unknown>
+; DIS64-NEXT:                 ...
+; DIS64:      00000070 <p>:
+; DIS64-NEXT:       70: 00 00 00 00                   <unknown>
+; DIS64-NEXT:       74: 00 00 00 58                   <unknown>
+; DIS64:      00000078 <foo>:
+; DIS64-NEXT:                 ...
+; DIS64-NEXT:       84: 00 00 00 90                   <unknown>
+; DIS64:      00000090 <globalA>:
+; DIS64-NEXT:       90: 00 00 00 00                   <unknown>
+; DIS64-NEXT:       94: 00 00 00 40                   <unknown>
+; DIS64:      00000098 <globalB>:
+; DIS64-NEXT:       98: 00 00 00 00                   <unknown>
+; DIS64-NEXT:       9c: 00 00 00 44                   <unknown>
+
+; DIS_REL64:       {{.*}}aix-xcoff-reloc.ll.tmp.o:   file format aix5coff64-rs6000
+; DIS_REL64:       RELOCATION RECORDS FOR [.text]:
+; DIS_REL64-NEXT:  OFFSET   TYPE                     VALUE
+; DIS_REL64-NEXT:  00000010 R_RBR                    .bar
+; DIS_REL64-NEXT:  0000001a R_TOC                    globalA
+; DIS_REL64-NEXT:  0000001e R_TOC                    globalB
+; DIS_REL64:       RELOCATION RECORDS FOR [.data]:
+; DIS_REL64-NEXT:  OFFSET   TYPE                     VALUE
+; DIS_REL64-NEXT:  00000030 R_POS                    arr
+; DIS_REL64-NEXT:  00000038 R_POS                    .foo
+; DIS_REL64-NEXT:  00000040 R_POS                    TOC
+; DIS_REL64-NEXT:  00000050 R_POS                    globalA
+; DIS_REL64-NEXT:  00000058 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: 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-objdump -D %t.o | FileCheck --check-prefix=DIS %s
 
-; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj < %s 2>&1 | \
-; RUN: FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc64-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=OBJ64 %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS64 %s
+; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=DIS64 %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

 ; DIS-NEXT:       30: 3f f0 00 00
 ; DIS-NEXT:       34: 00 00 00 00
 ; DIS-NEXT:       38: 40 00 00 00
 ; DIS-NEXT:       3c: 00 00 00 00
 ; DIS-NEXT:       40: 40 08 00 00
 ; DIS-NEXT:       44: 00 00 00 00
 ; DIS-NEXT:       48: 40 10 00 00
 ; DIS-NEXT:       4c: 00 00 00 00
+
+; OBJ64:      File: {{.*}}aix-xcoff-rodata.ll.tmp.o
+; OBJ64-NEXT: Format: aix5coff64-rs6000
+; OBJ64-NEXT: Arch: powerpc64
+; OBJ64-NEXT: AddressSize: 64bit
+; OBJ64-NEXT: FileHeader {
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ64-NEXT:   NumberOfSections: 1
+; OBJ64-NEXT:   TimeStamp: None (0x0)
+; OBJ64-NEXT:   SymbolTableOffset: 0xB0
+; OBJ64-NEXT:   SymbolTableEntries: 21
+; OBJ64-NEXT:   OptionalHeaderSize: 0x0
+; OBJ64-NEXT:   Flags: 0x0
+; OBJ64-NEXT: }
+
+; OBJ64:      Sections [
+; OBJ64:        Section {
+; OBJ64-NEXT:     Index: 1
+; OBJ64-NEXT:     Name: .text
+; OBJ64-NEXT:     PhysicalAddress: 0x0
+; OBJ64-NEXT:     VirtualAddress: 0x0
+; OBJ64-NEXT:     Size: 0x50
+; OBJ64-NEXT:     RawDataOffset: 0x60
+; OBJ64-NEXT:     RelocationPointer: 0x0
+; OBJ64-NEXT:     LineNumberPointer: 0x0
+; OBJ64-NEXT:     NumberOfRelocations: 0
+; OBJ64-NEXT:     NumberOfLineNumbers: 0
+; OBJ64-NEXT:     Type: STYP_TEXT (0x20)
+; OBJ64-NEXT:   }
+; OBJ64-NEXT: ]
+
+
+; SYMS64:       File: {{.*}}aix-xcoff-rodata.ll.tmp.o
+; SYMS64-NEXT:  Format: aix5coff64-rs6000
+; SYMS64-NEXT:  Arch: powerpc64
+; SYMS64-NEXT:  AddressSize: 64bit
+; SYMS64:       Symbols [
+; SYMS64:        Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .rodata
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+1]]
+; SYMS64-NEXT:       SectionLen: 80
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 5
+; SYMS64-NEXT:       SymbolType: XTY_SD (0x1)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+2]]
+; SYMS64-NEXT:     Name: const_ivar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+3]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+4]]
+; SYMS64-NEXT:     Name: const_llvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x8
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+5]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+6]]
+; SYMS64-NEXT:     Name: const_svar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x10
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+7]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+8]]
+; SYMS64-NEXT:     Name: const_fvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x14
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+9]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+10]]
+; SYMS64-NEXT:     Name: const_dvar
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x18
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+11]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+12]]
+; SYMS64-NEXT:     Name: const_over_aligned
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x20
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+13]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+14]]
+; SYMS64-NEXT:     Name: const_chrarray
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x28
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+15]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+
+; SYMS64:        Symbol {
+; SYMS64-NEXT:     Index: [[#INDX+16]]
+; SYMS64-NEXT:     Name: const_dblarr
+; SYMS64-NEXT:     Value (RelocatableAddress): 0x30
+; SYMS64-NEXT:     Section: .text
+; SYMS64-NEXT:     Type: 0x0
+; SYMS64-NEXT:     StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:     NumberOfAuxEntries: 1
+; SYMS64-NEXT:     CSECT Auxiliary Entry {
+; SYMS64-NEXT:       Index: [[#INDX+17]]
+; SYMS64-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYMS64-NEXT:       ParameterHashIndex: 0x0
+; SYMS64-NEXT:       TypeChkSectNum: 0x0
+; SYMS64-NEXT:       SymbolAlignmentLog2: 0
+; SYMS64-NEXT:       SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+; SYMS64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:     }
+; SYMS64-NEXT:   }
+; SYMS64:      ]
+
+; DIS64: Disassembly of section .text:
+; DIS64: 00000000 <const_ivar>:
+; DIS64-NEXT:        0: 00 00 00 23
+; DIS64-NEXT:        4: 00 00 00 00
+
+; DIS64: 00000008 <const_llvar>:
+; DIS64-NEXT:        8: 00 00 00 00
+; DIS64-NEXT:        c: 00 00 00 24
+
+; DIS64: 00000010 <const_svar>:
+; DIS64-NEXT:       10: 00 25 00 00
+
+; DIS64: 00000014 <const_fvar>:
+; DIS64-NEXT:       14: 44 48 00 00
+
+; DIS64: 00000018 <const_dvar>:
+; DIS64-NEXT:       18: 40 8c 20 00
+; DIS64-NEXT:       1c: 00 00 00 00
+
+; DIS64: 00000020 <const_over_aligned>:
+; DIS64-NEXT:       20: 40 8c 20 00
+; DIS64-NEXT:       24: 00 00 00 00
+
+; DIS64: 00000028 <const_chrarray>:
+; DIS64-NEXT:       28: 61 62 63 64
+; DIS64-NEXT:       2c: 00 00 00 00
+
+; DIS64: 00000030 <const_dblarr>:
+; DIS64-NEXT:       30: 3f f0 00 00
+; DIS64-NEXT:       34: 00 00 00 00
+; DIS64-NEXT:       38: 40 00 00 00
+; DIS64-NEXT:       3c: 00 00 00 00
+; DIS64-NEXT:       40: 40 08 00 00
+; DIS64-NEXT:       44: 00 00 00 00
+; DIS64-NEXT:       48: 40 10 00 00
+; DIS64-NEXT:       4c: 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:      -xcoff-traceback-table=false < %s | 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: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t.o 2>&1 \
-; RUN: < %s | FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     --xcoff-traceback-table=false -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=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
 

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

llvm/tools/llvm-readobj/XCOFFDumper.cpp

private:
   template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
   template <typename T> void printGenericSectionHeader(T &Sec) const;
   template <typename T> void printOverflowSectionHeader(T &Sec) const;
   void printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr);
   void printCsectAuxEnt(XCOFFCsectAuxRef AuxEntRef);
   void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
   void printSymbol(const SymbolRef &);
   void printRelocations(ArrayRef<XCOFFSectionHeader32> Sections);
+  void printRelocations64(ArrayRef<XCOFFSectionHeader64> Sections);
   const XCOFFObjectFile &Obj;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
void XCOFFDumper::printSectionHeaders() {
   if (Obj.is64Bit())
     printSectionHeaders(Obj.sections64());
   else
     printSectionHeaders(Obj.sections32());
 }
 
 void XCOFFDumper::printRelocations() {
   if (Obj.is64Bit())
-    llvm_unreachable("64-bit relocation output not implemented!");
+    printRelocations64(Obj.sections64());
   else
     printRelocations(Obj.sections32());
 }
 
 static const EnumEntry<XCOFF::RelocationType> RelocationTypeNameclass[] = {
 #define ECase(X)                                                               \
   { #X, XCOFF::X }
     ECase(R_POS),    ECase(R_RL),     ECase(R_RLA),    ECase(R_NEG),
void XCOFFDumper::printRelocations(ArrayRef<XCOFFSectionHeader32> Sections) {
   ListScope LS(W, "Relocations");
   uint16_t Index = 0;
   for (const auto &Sec : Sections) {
     ++Index;
     // Only the .text, .data, .tdata, and STYP_DWARF sections have relocation.
     if (Sec.Flags != XCOFF::STYP_TEXT && Sec.Flags != XCOFF::STYP_DATA &&
         Sec.Flags != XCOFF::STYP_TDATA && Sec.Flags != XCOFF::STYP_DWARF)
       continue;
-    auto Relocations = unwrapOrError(Obj.getFileName(), Obj.relocations(Sec));
+    auto Relocations = unwrapOrError(Obj.getFileName(), Obj.relocations32(Sec));
+    if (Relocations.empty())
+      continue;
+
+    W.startLine() << "Section (index: " << Index << ") " << Sec.getName()
+                  << " {\n";
+    for (auto Reloc : Relocations) {
+      StringRef SymbolName = unwrapOrError(
+          Obj.getFileName(), Obj.getSymbolNameByIndex(Reloc.SymbolIndex));
+
+      DictScope RelocScope(W, "Relocation");
+      W.printHex("Virtual Address", Reloc.VirtualAddress);
+      W.printNumber("Symbol", SymbolName, Reloc.SymbolIndex);
+      W.printString("IsSigned", Reloc.isRelocationSigned() ? "Yes" : "No");
+      W.printNumber("FixupBitValue", Reloc.isFixupIndicated() ? 1 : 0);
+      W.printNumber("Length", Reloc.getRelocatedLength());
+      W.printEnum("Type", (uint8_t)Reloc.Type,
+                  makeArrayRef(RelocationTypeNameclass));
+    }
+    W.unindent();
+    W.startLine() << "}\n";
+  }
+}
+
+void XCOFFDumper::printRelocations64(ArrayRef<XCOFFSectionHeader64> Sections) {
+  if (!opts::ExpandRelocs)
+    report_fatal_error("Unexpanded relocation output not implemented.");
+
+  ListScope LS(W, "Relocations");
+  uint16_t Index = 0;
+  for (const auto &Sec : Sections) {
+    ++Index;
+    // Only the .text, .data, .tdata, and STYP_DWARF sections have relocation.
+    if (Sec.Flags != XCOFF::STYP_TEXT && Sec.Flags != XCOFF::STYP_DATA &&
+        Sec.Flags != XCOFF::STYP_TDATA && Sec.Flags != XCOFF::STYP_DWARF)
+      continue;
+    auto Relocations = unwrapOrError(Obj.getFileName(), Obj.relocations64(Sec));
     if (Relocations.empty())
       continue;
 
     W.startLine() << "Section (index: " << Index << ") " << Sec.getName()
                   << " {\n";
     for (auto Reloc : Relocations) {
       StringRef SymbolName = unwrapOrError(
           Obj.getFileName(), Obj.getSymbolNameByIndex(Reloc.SymbolIndex));