[XCOFF][1/3] support fileHeader and sectionHeaders in 64-bit XCOFF.

[Esme]

Summary

This is the first patch to enable the XCOFF64 object writer.
Currently only fileHeader and sectionHeaders are supported.
The second patch will be to support 64-bit section data and relocations, followed by the third patch to support 64-bit symbols.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

765–766

if (!IsDwarf) {
  writeWord(Sec->Address); // s_paddr = s_vaddr
  writeWord(Sec->Address);
} else {
  writeWord(0);
  writeWord(0);
}

change to

writeWord(IsDwarf? Sec->Address:0);
writeWord(IsDwarf? Sec->Address:0);

767

from line 756 ~ 758 , all the field name are self_explain, we amy not need comments from them .

768

ditto

771

ditto for comment.

773

ditto for comment.

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

14

I do not think there is anything to remind us to delete the ";; FIXME:..." in later patch and and add 64bit object file test.
maybe we can add writeSymbolEntry for 64 bit in the patch , and using

if (TargetObjectWriter->is64Bit())
   report_fatal_error("64-bit XCOFF object files are not supported yet.");

in the function.

and then you do not need to modify all the test cases.

[DiggerLin]

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

14

please ignore above comment

[jhenderson]

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

15

Indent slightly to make it obvious this is a continuation of the line before.

[Esme]

Addressed comments.

[jhenderson]

No further comments from me. @DiggerLin should be the one to finish off this review thouh.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1046–1052

why there is no "+auxiliaryHeaderSize() "

[Esme]

llvm/lib/MC/XCOFFObjectWriter.cpp

1046–1052

As I understand, we don't need to support auxiliary header in ObjectWriter?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1046–1052

I think we need the support support auxiliary header later when we want to support visibility in symbol.

the function auxiliaryHeaderSize() only be used here. I think you can keep "+auxiliaryHeaderSize()" here. otherwise the definition of the function will be deleted too.

[Esme]

Addressed @DiggerLin 's comments, ie. auxiliaryHeaderSize() is kept.

[jhenderson]

llvm/lib/MC/XCOFFObjectWriter.cpp

297–298

Put the TODO comment either on a new line within the function (as suggested inline), or immediately before it as a commetnt, using // rather than block comments, then use clang-format to reformat it appropriately.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

316

change to

return (is64Bit()) ? W.write<uint64_t>(Word): W.write<uint32_t>(Word);

?

[Esme]

Addressed comments.

[DiggerLin]

LGTM.
I do not have further comment, but please wait for James approve.

llvm/lib/MC/XCOFFObjectWriter.cpp

297–298

James ask for put the comment within the function , not sure whether meet James comment. @jhenderson

[jhenderson]

LGTM.

llvm/lib/MC/XCOFFObjectWriter.cpp

297–298

I said either inside, or immediately before, so this is fine.

llvm/lib/MC/XCOFFObjectWriter.cpp

struct Symbol {
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
 // It can be a Csect or debug section or DWARF section and so on.
 struct XCOFFSection {
   const MCSectionXCOFF *const MCSec;
   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 MCSec->getSymbolTableName(); }
   XCOFFSection(const MCSectionXCOFF *MCSec)
       : MCSec(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<XCOFFSection>;
 using CsectGroups = std::deque<CsectGroup *>;
 
 // The basic section entry defination. This Section represents a section entry
 // in XCOFF section header table.
 struct SectionEntry {
   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;
 
   // XCOFF has special section numbers for symbols:
   // -2 Specifies N_DEBUG, a special symbolic debugging symbol.
   // -1 Specifies N_ABS, an absolute symbol. The symbol has a value but is not
struct DwarfSectionEntry : public SectionEntry {
   DwarfSectionEntry(DwarfSectionEntry &&s) = default;
 
   virtual ~DwarfSectionEntry() = default;
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
-  uint32_t SymbolTableOffset = 0;
+  uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
-  uint32_t RelocationEntryOffset = 0;
+  uint64_t RelocationEntryOffset = 0;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   const uint64_t MaxRawDataSize =
       TargetObjectWriter->is64Bit() ? UINT64_MAX : UINT32_MAX;
 
class XCOFFObjectWriter : public MCObjectWriter {
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
   void assignAddressesAndIndices(const MCAsmLayout &);
   void finalizeSectionInfo();
 
-  bool
-  needsAuxiliaryHeader() const { /* TODO aux header support not implemented. */
-    return false;
-  }
+  // TODO aux header support not implemented.
+  bool needsAuxiliaryHeader() const { return false; }
 
   // Returns the size of the auxiliary header to be written to the object file.
   size_t auxiliaryHeaderSize() const {
     assert(!needsAuxiliaryHeader() &&
            "Auxiliary header support not implemented.");
     return 0;
   }
 
 public:
   XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                     raw_pwrite_stream &OS);
+
+  void writeWord(uint64_t Word) {
+    is64Bit() ? W.write<uint64_t>(Word) : W.write<uint32_t>(Word);
+  }
 };
 
 XCOFFObjectWriter::XCOFFObjectWriter(
     std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
     : W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
       Strings(StringTableBuilder::XCOFF),
       Text(".text", XCOFF::STYP_TEXT, /* IsVirtual */ false,
            CsectGroups{&ProgramCodeCsects, &ReadOnlyCsects}),
       Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false,
            CsectGroups{&DataCsects, &FuncDSCsects, &TOCCsects}),

 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) {
-  if (is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
-
   for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
            "Cannot add a section twice.");
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(MCSec->getSymbolTableName()))

 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 (is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
-
   finalizeSectionInfo();
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
+
+  if (!is64Bit()) {
     writeSections(Asm, Layout);
     writeRelocations();
 
     writeSymbolTable(Layout);
     // Write the string table.
     Strings.write(W.OS);
+  }
 
   return W.OS.tell() - StartOffset;
 }
 
 bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
   return SymbolName.size() > XCOFF::NameSize;
 }
 
void XCOFFObjectWriter::writeSymbolEntryForControlSection(
   writeSymbolEntry(CSectionRef.getSymbolTableName(), CSectionRef.Address,
                    SectionIndex, /*SymbolType=*/0, StorageClass);
 
   writeSymbolAuxCsectEntry(CSectionRef.Size, getEncodedType(CSectionRef.MCSec),
                            CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeFileHeader() {
-  assert(!is64Bit() && "Writing 64-bit file header is not yet supported.");
-  W.write<uint16_t>(XCOFF::XCOFF32);
+  W.write<uint16_t>(is64Bit() ? XCOFF::XCOFF64 : XCOFF::XCOFF32);
   W.write<uint16_t>(SectionCount);
   W.write<int32_t>(0); // TimeStamp
-  W.write<uint32_t>(SymbolTableOffset);
+  writeWord(SymbolTableOffset);
+  if (is64Bit()) {
+    W.write<uint16_t>(0); // AuxHeaderSize. No optional header for an object
+                          // file that is not to be loaded.
+    W.write<uint16_t>(0); // Flags
+    W.write<int32_t>(0);  // SymbolTableEntryCount. Not supported yet.
+  } else {
     W.write<int32_t>(SymbolTableEntryCount);
-  W.write<uint16_t>(0); // AuxHeaderSize
+    W.write<uint16_t>(0); // AuxHeaderSize. No optional header for an object
+                          // file that is not to be loaded.
     W.write<uint16_t>(0); // Flags
   }
+}
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
-  assert(!is64Bit() && "Writing 64-bit section headers is not yet supported.");
   auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
     // Nothing to write for this Section.
     if (Sec->Index == SectionEntry::UninitializedIndex)
       return false;
 
     // 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.
     // We use 0 for DWARF sections' Physical and Virtual Addresses.
-    W.write<uint32_t>(IsDwarf ? 0 : Sec->Address);
-    W.write<uint32_t>(IsDwarf ? 0 : Sec->Address);
-
-    W.write<uint32_t>(Sec->Size);
-    W.write<uint32_t>(Sec->FileOffsetToData);
-    W.write<uint32_t>(Sec->FileOffsetToRelocations);
-    W.write<uint32_t>(0); // FileOffsetToLineNumberInfo. Not supported yet.
+    writeWord(IsDwarf ? 0 : Sec->Address);
+    writeWord(IsDwarf ? 0 : Sec->Address);
 
+    writeWord(Sec->Size);
+    writeWord(Sec->FileOffsetToData);
+    writeWord(Sec->FileOffsetToRelocations);
+    writeWord(0); // FileOffsetToLineNumberInfo. Not supported yet.
+
+    if (is64Bit()) {
+      W.write<uint32_t>(0); // NumberOfRelocations. Not yet supported in 64-bit.
+      W.write<uint32_t>(0); // NumberOfLineNumbers. Not supported yet.
+      W.write<int32_t>(Sec->Flags);
+      W.OS.write_zeros(4);
+    } else {
       W.write<uint16_t>(Sec->RelocationCount);
       W.write<uint16_t>(0); // NumberOfLineNumbers. Not supported yet.
       W.write<int32_t>(Sec->Flags);
+    }
 
     return true;
   };
 
   for (const auto *CsectSec : Sections)
     writeSectionHeader(CsectSec, /* IsDwarf */ false);
   for (const auto &DwarfSec : DwarfSections)
     writeSectionHeader(&DwarfSec, /* IsDwarf */ true);
for (auto &DwarfSection : DwarfSections) {
 
     // Make the Address align to default alignment for follow section.
     Address = alignTo(DwarfSect.Address + DwarfSect.Size, DefaultSectionAlign);
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
-  uint64_t RawPointer = XCOFF::FileHeaderSize32 + auxiliaryHeaderSize() +
-                        SectionCount * XCOFF::SectionHeaderSize32;
+  uint64_t RawPointer =
+      (is64Bit() ? (XCOFF::FileHeaderSize64 +
+                    SectionCount * XCOFF::SectionHeaderSize64)
+                 : (XCOFF::FileHeaderSize32 +
+                    SectionCount * XCOFF::SectionHeaderSize32)) +
+      auxiliaryHeaderSize();
+
   for (auto *Sec : Sections) {
     if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
       continue;
 
     Sec->FileOffsetToData = RawPointer;
     RawPointer += Sec->Size;
     if (RawPointer > MaxRawDataSize)
       report_fatal_error("Section raw data overflowed this object file.");

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:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @_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

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.
-
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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:

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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 define i32 @foo()  align 32 {
 entry:
   ret i32 0
 }
 
 define i32 @bar()  align 64 {
 entry:

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
+
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 define internal i32 @foo() {
   ret i32 1
 }
 
 ; CHECK:  Symbol {
 ; CHECK:       Name: .foo
 ; CHECK-NEXT:  Value (RelocatableAddress):

 ; CHECK-NEXT:  ParameterHashIndex:
 ; CHECK-NEXT:  TypeChkSectNum:
 ; CHECK-NEXT:  SymbolAlignmentLog2:
 ; CHECK-NEXT:  SymbolType: XTY_SD (0x1)
 ; CHECK-NEXT:  StorageMappingClass: XMC_DS (0xA)
 
 ; Make sure no label is emitted.
 ; CHECK-NOT: Name: foo
-
-;64-CHECK: LLVM ERROR: 64-bit XCOFF object files are not supported yet.

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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 %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

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.
+## FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 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):

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

 ; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc-ibm-aix-xcoff \
 ; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false < %s | FileCheck %s
 ; RUN: llc -mcpu=pwr4 -mattr=-altivec -mtriple=powerpc-ibm-aix-xcoff \
 ; RUN:     -verify-machineinstrs -data-sections=false -xcoff-traceback-table=false -filetype=obj -o %t.o < %s
 ; RUN: llvm-objdump -D %t.o | FileCheck --check-prefix=CHECKOBJ %s
 ; RUN: llvm-readobj -S %t.o | FileCheck --check-prefix=CHECKSECT %s
 
-; RUN: 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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 ; 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

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:   -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:   --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:   -mcpu=pwr4 -mattr=-altivec < %s | 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
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 ; 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:       14: 90 01 00 08                   stw 0, 8(1)
 ; 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.

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:   -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:   -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:   -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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s 2>&1 | FileCheck %s
 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYMS %s
 
-; 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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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:   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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t64.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t64.o | \
+; RUN:   FileCheck --check-prefix=OBJ64 %s
 
 @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

 ; 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:      ]
+
+; OBJ64:      Format: aix5coff64-rs6000
+; OBJ64-NEXT: Arch: powerpc64
+; OBJ64-NEXT: AddressSize: 64bit
+; OBJ64-NEXT: FileHeader {
+; OBJ64-NEXT:   Magic: 0x1F7
+; OBJ64-NEXT:   NumberOfSections: 3
+; OBJ64-NEXT:   TimeStamp: None (0x0)
+; OBJ64-NEXT:   SymbolTableOffset: 0x170
+; OBJ64-NEXT:   SymbolTableEntries: 0
+; OBJ64-NEXT:   OptionalHeaderSize: 0x0
+; OBJ64-NEXT:   Flags: 0x0
+; OBJ64-NEXT: }
+
+; OBJ64:      Sections [
+; OBJ64-NEXT:   Section {
+; OBJ64-NEXT:     Index: [[#OBJ64_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-NEXT:   Section {
+; OBJ64-NEXT:     Index: [[#OBJ64_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-NEXT:   Section {
+; OBJ64-NEXT:     Index: [[#OBJ64_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-NEXT: ]

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:   FileCheck --check-prefix=XCOFF64 %s
-; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @La = external global i32, align 4
 
 declare i32 @Lb(...)
 
 define void @foo() {
 entry:
   store i32 1, i32* @La, align 4

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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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:   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: FileCheck --check-prefix=OBJ64 %s
-; OBJ64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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

 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,ASM32 %s
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff -data-sections=false < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK,ASM64 %s
 
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -data-sections=false -filetype=obj -o %t.o < %s
 ; RUN: llvm-readobj -r --expand-relocs --syms %t.o | FileCheck --check-prefixes=RELOC,SYM %s
 
-; 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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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:   FileCheck --check-prefix=OBJ %s
 ; RUN: llvm-readobj --relocs --expand-relocs %t.o | FileCheck --check-prefix=RELOC %s
 ; RUN: llvm-readobj --syms %t.o | FileCheck --check-prefix=SYM %s
 ; RUN: llvm-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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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:

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:   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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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

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

 ; This file tests TOC entry generation and undefined symbol generation.
 
 ; RUN: llc  -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:      -xcoff-traceback-table=false < %s | FileCheck --check-prefixes CHECK,CHECK32 %s
 ; RUN: llc  -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc64-ibm-aix-xcoff \
 ; RUN:      -xcoff-traceback-table=false < %s 2>&1 | FileCheck --check-prefixes CHECK,CHECK64  %s
 
 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     --xcoff-traceback-table=false -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.
+;; FIXME: currently only fileHeader and sectionHeaders are supported in XCOFF64.
 
 @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
 

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

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