[AIX] Disable tests failing due to lack of 64-bit XCOFF object file support

[Jake-Egan]

Summary

The following tests are failing because 64-bit XCOFF object files are not currently supported on AIX. This patch disables these tests on AIX for now.

[shchenz]

LGTM

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
   typedef AddrType RefAddrType;
   TestAllForms<2, AddrType, RefAddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8AllForms) {
+#endif
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint64_t AddrType;
   // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
   typedef AddrType RefAddrType;
   TestAllForms<2, AddrType, RefAddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4AllForms) {
   // Test that we can decode all forms for DWARF32, version 3, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later.
   typedef uint32_t RefAddrType;
   TestAllForms<3, AddrType, RefAddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8AllForms) {
+#endif
   // Test that we can decode all forms for DWARF32, version 3, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<3, AddrType, RefAddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4AllForms) {
   // Test that we can decode all forms for DWARF32, version 4, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<4, AddrType, RefAddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8AllForms) {
+#endif
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
   typedef uint32_t RefAddrType;
   TestAllForms<4, AddrType, RefAddrType>();
 }
 

 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Children) {
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestChildren<2, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Children) {
+#endif
   // Test that we can decode all forms for DWARF32, version 2, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestChildren<2, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Children) {
   // Test that we can decode all forms for DWARF32, version 3, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestChildren<3, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Children) {
+#endif
   // Test that we can decode all forms for DWARF32, version 3, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestChildren<3, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Children) {
   // Test that we can decode all forms for DWARF32, version 4, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestChildren<4, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) {
+#endif
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestChildren<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestReferences() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));

 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestReferences<2, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8References) {
+#endif
   // Test that we can decode all forms for DWARF32, version 2, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestReferences<2, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4References) {
   // Test that we can decode all forms for DWARF32, version 3, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestReferences<3, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8References) {
+#endif
   // Test that we can decode all forms for DWARF32, version 3, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestReferences<3, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4References) {
   // Test that we can decode all forms for DWARF32, version 4, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestReferences<4, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) {
+#endif
   // Test that we can decode all forms for DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestReferences<4, AddrType>();
 }
 
 template <uint16_t Version, class AddrType> void TestAddresses() {
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));

 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Addresses) {
   // Test that we can decode address values in DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestAddresses<2, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Addresses) {
+#endif
   // Test that we can decode address values in DWARF32, version 2, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestAddresses<2, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Addresses) {
   // Test that we can decode address values in DWARF32, version 3, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestAddresses<3, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Addresses) {
+#endif
   // Test that we can decode address values in DWARF32, version 3, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestAddresses<3, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Addresses) {
   // Test that we can decode address values in DWARF32, version 4, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   TestAddresses<4, AddrType>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Addresses) {
+#endif
   // Test that we can decode address values in DWARF32, version 4, with 8 byte
   // addresses.
   typedef uint64_t AddrType;
   TestAddresses<4, AddrType>();
 }
 
 #ifdef _AIX
 TEST(DWARFDebugInfo, DISABLED_TestStringOffsets) {

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

void checkDefaultPrologue(uint16_t Version, DwarfFormat Format,
   ASSERT_EQ(Prologue.IncludeDirectories[0].getForm(), DW_FORM_string);
   EXPECT_STREQ(*Prologue.IncludeDirectories[0].getAsCString(), "a dir");
   ASSERT_EQ(Prologue.FileNames.size(), 1u);
   ASSERT_EQ(Prologue.FileNames[0].Name.getForm(), DW_FORM_string);
   ASSERT_EQ(Prologue.FileNames[0].DirIdx, 0u);
   EXPECT_STREQ(*Prologue.FileNames[0].Name.getAsCString(), "a file");
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_GetOrParseLineTableAtInvalidOffset) {
+#else
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) {
+#endif
   if (!setupGenerator())
     return;
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
       FailedWithMessage(
           "offset 0x00000000 is not a valid debug line section offset"));
   // Repeat to show that an error is reported each time.
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
       FailedWithMessage(
           "offset 0x00000000 is not a valid debug line section offset"));
 
   // Show that an error is reported for later offsets too.
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(1),
       FailedWithMessage(
           "offset 0x00000001 is not a valid debug line section offset"));
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_GetOrParseLineTableAtInvalidOffsetAfterData) {
+#else
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0, LineTable::Byte}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(0),
       FailedWithMessage(
           "parsing line table prologue at offset 0x00000000: "
           "unexpected end of data at offset 0x1 while reading [0x0, 0x4)"));
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(1),
       FailedWithMessage(
           "offset 0x00000001 is not a valid debug line section offset"));
 }
 
+#ifdef _AIX
+TEST_P(DebugLineParameterisedFixture, DISABLED_PrologueGetLength) {
+#else
 TEST_P(DebugLineParameterisedFixture, PrologueGetLength) {
+#endif
   if (!setupGenerator(Version))
     return;
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   LT.setPrologue(Prologue);
   generate();
 
   // + 10 for sizes of DWARF-32 unit length, version, prologue length.
   uint64_t ExpectedLength = Prologue.PrologueLength + 10;
   if (Version == 5)
     // Add address and segment selector size fields.
     ExpectedLength += 2;
   if (Format == DWARF64)
     // Unit length grows by 8, prologue length by 4.
     ExpectedLength += 12;
 
   auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
                                                     nullptr, RecordRecoverable);
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   EXPECT_EQ((*ExpectedLineTable)->Prologue.getLength(), ExpectedLength);
 }
 
+#ifdef _AIX
+TEST_P(DebugLineParameterisedFixture, DISABLED_GetOrParseLineTableValidTable) {
+#else
 TEST_P(DebugLineParameterisedFixture, GetOrParseLineTableValidTable) {
+#endif
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}});
#endif
   ASSERT_TRUE(ExpectedLineTable4.operator bool());
   EXPECT_FALSE(Recoverable);
   EXPECT_EQ(Expected2, *ExpectedLineTable4);
 
   // TODO: Add tests that show that the body of the programs have been read
   // correctly.
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ErrorForReservedLength) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForReservedLength) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(),
       FailedWithMessage(
           "parsing line table prologue at offset 0x00000000: unsupported "
           "reserved unit length of value 0xfffffff0"));
 }
 
 struct DebugLineUnsupportedVersionFixture : public TestWithParam<uint16_t>,
                                             public CommonFixture {
   void SetUp() override { Version = GetParam(); }
 
   uint16_t Version;
 };
 
+#ifdef _AIX
+TEST_P(DebugLineUnsupportedVersionFixture,
+       DISABLED_ErrorForUnsupportedVersion) {
+#else
 TEST_P(DebugLineUnsupportedVersionFixture, ErrorForUnsupportedVersion) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue(
       {{LineTable::Half, LineTable::Long}, {Version, LineTable::Half}});
 
   generate();
 
   EXPECT_THAT_EXPECTED(
       getOrParseLineTableFatalErrors(),
       FailedWithMessage("parsing line table prologue at offset 0x00000000: "
                         "unsupported version " +
                         std::to_string(Version)));
 }
 
 INSTANTIATE_TEST_SUITE_P(UnsupportedVersionTestParams,
                          DebugLineUnsupportedVersionFixture,
                          Values(/*1 below min */ 1, /* 1 above max */ 6,
                                 /* Maximum possible */ 0xffff));
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ErrorForInvalidV5IncludeDirTable) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) {
+#endif
   if (!setupGenerator(5))
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({
       {19, LineTable::Long}, // unit length
       {5, LineTable::Half},  // version
       {8, LineTable::Byte},  // addr size
EXPECT_THAT_ERROR(
       std::move(Recoverable),
       FailedWithMessage(
           "parsing line table prologue at 0x00000000 found an invalid "
           "directory or file table description at 0x00000014",
           "failed to parse entry content descriptions because no path was "
           "found"));
 }
 
+#ifdef _AIX
+TEST_P(DebugLineParameterisedFixture, DISABLED_ErrorForTooLargePrologueLength) {
+#else
 TEST_P(DebugLineParameterisedFixture, ErrorForTooLargePrologueLength) {
+#endif
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
EXPECT_THAT_ERROR(
           ("unknown data in line table prologue at offset 0x00000000: "
            "parsing ended (at offset 0x000000" +
            Twine::utohexstr(ExpectedEnd - 1) +
            ") before reaching the prologue end at offset 0x000000" +
            Twine::utohexstr(ExpectedEnd))
               .str()));
 }
 
+#ifdef _AIX
+TEST_P(DebugLineParameterisedFixture, DISABLED_ErrorForTooShortPrologueLength) {
+#else
 TEST_P(DebugLineParameterisedFixture, ErrorForTooShortPrologueLength) {
+#endif
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();

 INSTANTIATE_TEST_SUITE_P(
     LineTableTestParams, DebugLineParameterisedFixture,
     Values(std::make_pair(
                2, DWARF32), // Test lower-bound of v2-3 fields and DWARF32.
            std::make_pair(3, DWARF32), // Test upper-bound of v2-3 fields.
            std::make_pair(4, DWARF64), // Test v4 fields and DWARF64.
            std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)));
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ErrorForExtendedOpcodeLengthSmallerThanExpected) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthSmallerThanExpected) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0xaa);
   // The Length should be 1 + sizeof(ULEB) for a set discriminator opcode.
   // The operand will be read for both the discriminator opcode and then parsed
   // again as DW_LNS_negate_stmt, to respect the claimed length.
EXPECT_THAT_ERROR(std::move(Recoverable),
                                       "0x00000031 expected 0x01 found 0x02"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
   EXPECT_EQ((*ExpectedLineTable)->Rows[1].IsStmt, 0u);
   EXPECT_EQ((*ExpectedLineTable)->Rows[1].Discriminator, DW_LNS_negate_stmt);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ErrorForExtendedOpcodeLengthLargerThanExpected) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthLargerThanExpected) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0xaa);
   LT.addStandardOpcode(DW_LNS_const_add_pc, {});
   // The Length should be 1 for an end sequence opcode.
   LT.addExtendedOpcode(2, DW_LNE_end_sequence, {});
EXPECT_THAT_ERROR(std::move(Recoverable),
                                       "0x00000032 expected 0x02 found 0x01"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 4u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 2u);
   ASSERT_EQ((*ExpectedLineTable)->Sequences[1].FirstRowIndex, 2u);
   EXPECT_EQ((*ExpectedLineTable)->Rows[2].IsStmt, 1u);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ErrorForUnitLengthTooLarge) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTooLarge) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &Padding = Gen->addLineTable();
   // Add some padding to show that a non-zero offset is handled correctly.
   Padding.setCustomPrologue({{0, LineTable::Byte}});
   LineTable &LT = Gen->addLineTable();
   LT.addStandardOpcode(DW_LNS_copy, {});
EXPECT_THAT_ERROR(
       std::move(Recoverable),
       FailedWithMessage("line table program with offset 0x00000001 has length "
                         "0x00000034 but only 0x00000033 bytes are available"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ErrorForMismatchedAddressSize) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) {
+#endif
   if (!setupGenerator(4, 8))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // The line data extractor expects size 8 (Quad) addresses.
   uint64_t Addr1 = 0x11223344;
   LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
   LT.addStandardOpcode(DW_LNS_copy, {});
EXPECT_THAT_ERROR(std::move(Recoverable),
                                       "0x00000030 expected 0x08 found 0x04"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
   EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1);
   EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ErrorForMismatchedAddressSizeUnsetInitialAddress) {
+#else
 TEST_F(DebugLineBasicFixture,
        ErrorForMismatchedAddressSizeUnsetInitialAddress) {
+#endif
   if (!setupGenerator(4, 0))
     return;
 
   LineTable &LT = Gen->addLineTable();
   uint64_t Addr1 = 0x11223344;
   LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   uint64_t Addr2 = 0x1122334455667788;
EXPECT_THAT_ERROR(std::move(Recoverable),
                                       "0x00000038 expected 0x04 found 0x08"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
   EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1);
   EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ErrorForUnsupportedAddressSizeInSetAddressLength) {
+#else
 TEST_F(DebugLineBasicFixture,
        ErrorForUnsupportedAddressSizeInSetAddressLength) {
+#endif
   // Use DWARF v4, and 0 for data extractor address size so that the address
   // size is derived from the opcode length.
   if (!setupGenerator(4, 0))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // 4 == length of the extended opcode, i.e. 1 for the opcode itself and 3 for
   // the Half (2) + Byte (1) operand, representing the unsupported address size.
EXPECT_THAT_ERROR(
                         "offset 0x00000030 is unsupported"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
   // Show that the set address opcode is ignored in this case.
   EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, 0u);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ErrorForAddressSizeGreaterThanByteSize) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForAddressSizeGreaterThanByteSize) {
+#endif
   // Use DWARF v4, and 0 for data extractor address size so that the address
   // size is derived from the opcode length.
   if (!setupGenerator(4, 0))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // Specifically use an operand size that has a trailing byte of a supported
   // size (8), so that any potential truncation would result in a valid size.
   std::vector<LineTable::ValueAndLength> Operands(0x108);
   LT.addExtendedOpcode(Operands.size() + 1, DW_LNE_set_address, Operands);
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
 
   generate();
 
   auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
                                                     nullptr, RecordRecoverable);
   EXPECT_THAT_ERROR(
       std::move(Recoverable),
       FailedWithMessage("address size 0x108 of DW_LNE_set_address opcode at "
                         "offset 0x00000031 is unsupported"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ErrorForUnsupportedAddressSizeDefinedInHeader) {
+#else
 TEST_F(DebugLineBasicFixture, ErrorForUnsupportedAddressSizeDefinedInHeader) {
+#endif
   // Use 0 for data extractor address size so that it does not clash with the
   // header address size.
   if (!setupGenerator(5, 0))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // AddressSize + 1 == length of the extended opcode, i.e. 1 for the opcode
   // itself and 9 for the Quad (8) + Byte (1) operand representing the
EXPECT_THAT_ERROR(
                         "offset 0x00000038 is unsupported"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
   // Show that the set address opcode is ignored in this case.
   EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, 0u);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_CallbackUsedForUnterminatedSequence) {
+#else
 TEST_F(DebugLineBasicFixture, CallbackUsedForUnterminatedSequence) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.addExtendedOpcode(9, DW_LNE_set_address,
                        {{0x1122334455667788, LineTable::Quad}});
   LT.addStandardOpcode(DW_LNS_copy, {});
   LT.addByte(0xaa);
uint64_t editPrologue(LineTable &LT) override {
     Prologue.MaxOpsPerInst = MaxOpsPerInst;
     LT.setPrologue(Prologue);
     return Prologue.TotalLength + Prologue.sizeofTotalLength();
   }
 
   uint8_t MaxOpsPerInst;
 };
 
+#ifdef _AIX
+TEST_P(MaxOpsPerInstFixture, DISABLED_MaxOpsPerInstProblemsReportedCorrectly) {
+#else
 TEST_P(MaxOpsPerInstFixture, MaxOpsPerInstProblemsReportedCorrectly) {
+#endif
   runTest(/*CheckAdvancePC=*/true,
           "but the prologue maximum_operations_per_instruction value is " +
               Twine(unsigned(MaxOpsPerInst)) +
               ", which is unsupported. Assuming a value of 1 instead");
 }
 
 INSTANTIATE_TEST_SUITE_P(
     MaxOpsPerInstParams, MaxOpsPerInstFixture,
uint64_t getAdjustedLine(uint64_t Base, uint64_t Incr) override {
     return LineRange != 0
                ? AdjustAddressFixtureBase::getAdjustedLine(Base, Incr)
                : Base;
   }
 
   uint8_t LineRange;
 };
 
+#ifdef _AIX
+TEST_P(LineRangeFixture, DISABLED_LineRangeProblemsReportedCorrectly) {
+#else
 TEST_P(LineRangeFixture, LineRangeProblemsReportedCorrectly) {
+#endif
   runTest(/*CheckAdvancePC=*/false,
           "but the prologue line_range value is 0. The address and line will "
           "not be adjusted");
 }
 
 INSTANTIATE_TEST_SUITE_P(
     LineRangeParams, LineRangeFixture,
     Values(std::make_tuple(0, true),     // Test zero value (error).
uint64_t getAdjustedAddr(uint64_t Base, uint64_t ConstIncr,
     return MinInstLength != 0 ? AdjustAddressFixtureBase::getAdjustedAddr(
                                     Base, ConstIncr, SpecialIncr, AdvanceIncr)
                               : Base;
   }
 
   uint8_t MinInstLength;
 };
 
+#ifdef _AIX
+TEST_P(BadMinInstLenFixture, DISABLED_MinInstLengthProblemsReportedCorrectly) {
+#else
 TEST_P(BadMinInstLenFixture, MinInstLengthProblemsReportedCorrectly) {
+#endif
   runTest(/*CheckAdvancePC=*/true,
           "but the prologue minimum_instruction_length value is 0, which "
           "prevents any address advancing");
 }
 
 INSTANTIATE_TEST_SUITE_P(
     BadMinInstLenParams, BadMinInstLenFixture,
     Values(std::make_tuple(0, true),    // Test zero value (error).
            std::make_tuple(1, false))); // Test non-zero value (no error).
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ParserParsesCorrectly) {
+#else
 TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) {
+#endif
   if (!setupGenerator())
     return;
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());
 
#endif
   EXPECT_EQ(Parsed2.Sequences.size(), 1u);
   EXPECT_EQ(Parser.getOffset(), 136u);
   EXPECT_TRUE(Parser.done());
 
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ParserSkipsCorrectly) {
+#else
 TEST_F(DebugLineBasicFixture, ParserSkipsCorrectly) {
+#endif
   if (!setupGenerator())
     return;
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());
 
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 62u);
   ASSERT_FALSE(Parser.done());
 
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 136u);
   EXPECT_TRUE(Parser.done());
 
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_ParserAlwaysDoneForEmptySection) {
+#else
 TEST_F(DebugLineBasicFixture, ParserAlwaysDoneForEmptySection) {
+#endif
   if (!setupGenerator())
     return;
 
   generate();
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
 
   EXPECT_TRUE(Parser.done());
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserMarkedAsDoneForBadLengthWhenParsing) {
+#else
 TEST_F(DebugLineBasicFixture, ParserMarkedAsDoneForBadLengthWhenParsing) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
   Gen->addLineTable();
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.parseNext(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   EXPECT_TRUE(Parser.done());
   EXPECT_FALSE(Recoverable);
 
   EXPECT_THAT_ERROR(
       std::move(Unrecoverable),
       FailedWithMessage(
           "parsing line table prologue at offset 0x00000000: unsupported "
           "reserved unit length of value 0xfffffff0"));
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserMarkedAsDoneForBadLengthWhenSkipping) {
+#else
 TEST_F(DebugLineBasicFixture, ParserMarkedAsDoneForBadLengthWhenSkipping) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
   Gen->addLineTable();
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   EXPECT_TRUE(Parser.done());
   EXPECT_FALSE(Recoverable);
 
   EXPECT_THAT_ERROR(
       std::move(Unrecoverable),
       FailedWithMessage(
           "parsing line table prologue at offset 0x00000000: unsupported "
           "reserved unit length of value 0xfffffff0"));
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserReportsFirstErrorInEachTableWhenParsing) {
+#else
 TEST_F(DebugLineBasicFixture, ParserReportsFirstErrorInEachTableWhenParsing) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}});
   generate();
#endif
   EXPECT_THAT_ERROR(
       std::move(Unrecoverable),
       FailedWithMessage("parsing line table prologue at offset 0x00000000: "
                         "unsupported version 0",
                         "parsing line table prologue at offset 0x00000006: "
                         "unsupported version 1"));
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserReportsNonPrologueProblemsWhenParsing) {
+#else
 TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.addExtendedOpcode(0x42, DW_LNE_end_sequence, {});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.addExtendedOpcode(9, DW_LNE_set_address,
                         {{0x1234567890abcdef, LineTable::Quad}});
#endif
 
   EXPECT_TRUE(Parser.done());
   EXPECT_THAT_ERROR(std::move(Recoverable),
                     FailedWithMessage("last sequence in debug line table at "
                                       "offset 0x00000031 is not terminated"));
   EXPECT_FALSE(Unrecoverable);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserReportsPrologueErrorsInEachTableWhenSkipping) {
+#else
 TEST_F(DebugLineBasicFixture,
        ParserReportsPrologueErrorsInEachTableWhenSkipping) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}});
   generate();
#endif
   EXPECT_THAT_ERROR(
       std::move(Unrecoverable),
       FailedWithMessage("parsing line table prologue at offset 0x00000000: "
                         "unsupported version 0",
                         "parsing line table prologue at offset 0x00000006: "
                         "unsupported version 1"));
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture,
+       DISABLED_ParserIgnoresNonPrologueErrorsWhenSkipping) {
+#else
 TEST_F(DebugLineBasicFixture, ParserIgnoresNonPrologueErrorsWhenSkipping) {
+#endif
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.addExtendedOpcode(42, DW_LNE_end_sequence, {});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_VerboseOutput) {
+#else
 TEST_F(DebugLineBasicFixture, VerboseOutput) {
+#endif
   if (!setupGenerator(5))
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.addByte(0); // Extended opcode with zero length.
   LT.addByte(0);
   // Zero-value extended opcode.
   LT.addExtendedOpcode(2, 0, {{1, LineTable::Byte}});
struct TruncatedPrologueFixture
 
   uint64_t Length;
   uint64_t ExpectedOffset;
   uint16_t Version;
   DwarfFormat Format;
   StringRef ExpectedErr;
 };
 
+#ifdef _AIX
+TEST_P(TruncatedPrologueFixture, DISABLED_ErrorForTruncatedPrologue) {
+#else
 TEST_P(TruncatedPrologueFixture, ErrorForTruncatedPrologue) {
+#endif
   if (!setupGenerator(Version))
     return;
 
   LineTable &Padding = Gen->addLineTable();
   // Add some padding to show that a non-zero offset is handled correctly.
   Padding.setCustomPrologue({{0, LineTable::Byte}});
 
   // Add a table with only two standard opcodes - we don't need to test the full
struct TruncatedExtendedOpcodeFixture
   void SetUp() override {
     std::tie(BodyLength, OpcodeLength, Opcode, Operands, ExpectedOutput,
              ExpectedErr) = GetParam();
   }
 
   uint64_t OpcodeLength;
 };
 
+#ifdef _AIX
+TEST_P(TruncatedExtendedOpcodeFixture,
+       DISABLED_ErrorForTruncatedExtendedOpcode) {
+#else
 TEST_P(TruncatedExtendedOpcodeFixture, ErrorForTruncatedExtendedOpcode) {
+#endif
   if (!setupGenerator())
     return;
   LineTable &LT = setupTable();
   LT.addExtendedOpcode(OpcodeLength, Opcode, Operands);
   runTest(0);
   EXPECT_THAT_ERROR(std::move(Recoverable),
                     FailedWithMessage(ExpectedErr.str()));
 }
Values(
                         "malformed uleb128, extends past end"),
         std::make_tuple(
             6, 5, /*Unknown=*/0x7f,
             ValueAndLengths{{0x12343412, LineTable::Long}},
             "Unrecognized extended op 0x7f length 5 (<parsing error> 12 34 34)",
             "unexpected end of data at offset 0x35 while reading [0x32, "
             "0x36)")));
 
+#ifdef _AIX
+TEST_P(TruncatedStandardOpcodeFixture,
+       DISABLED_ErrorForTruncatedStandardOpcode) {
+#else
 TEST_P(TruncatedStandardOpcodeFixture, ErrorForTruncatedStandardOpcode) {
+#endif
   if (!setupGenerator())
     return;
   LineTable &LT = setupTable();
   LT.addStandardOpcode(Opcode, Operands);
   runTest(Opcode);
   EXPECT_THAT_ERROR(std::move(Unrecoverable),
                     FailedWithMessage(ExpectedErr.str()));
 }
Values(
                         "malformed uleb128, extends past end"),
         std::make_tuple(
             4, 0xd,
             ValueAndLengths{{0x900, LineTable::ULEB}, {0xa00, LineTable::ULEB}},
             "Unrecognized standard opcode (operands: 0x0000000000000900)",
             "unable to decode LEB128 at offset 0x00000032: "
             "malformed uleb128, extends past end")));
 
+#ifdef _AIX
+TEST_F(DebugLineBasicFixture, DISABLED_PrintPathsProperly) {
+#else
 TEST_F(DebugLineBasicFixture, PrintPathsProperly) {
+#endif
   if (!setupGenerator(5))
     return;
 
   LineTable &LT = Gen->addLineTable();
   DWARFDebugLine::Prologue P = LT.createBasicPrologue();
   P.IncludeDirectories.push_back(
       DWARFFormValue::createFromPValue(DW_FORM_string, "b dir"));
   P.FileNames.push_back(DWARFDebugLine::FileNameEntry());