[AIX] Disable tests failing due to assert on DWARF object writing

[Jake-Egan]

Summary

The following tests fail due to assert on DWARF object writing. Temporarily disable these tests on AIX until D97184 goes through.

[Jake-Egan]

Updated to preserve blank lines.

[shchenz]

Thanks for working on this.

Could you please help to rerun the affected cases after applying D97184? That patch is approved and I will deliver it soon.

[Jake-Egan]

In D111169#3047761, @shchenz wrote:

Thanks for working on this.

Could you please help to rerun the affected cases after applying D97184? That patch is approved and I will deliver it soon.

I reran the tests with the patch. All the tests pass.

[shchenz]

In D111169#3048311, @Jake-Egan wrote:

In D111169#3047761, @shchenz wrote:

Thanks for working on this.

Could you please help to rerun the affected cases after applying D97184? That patch is approved and I will deliver it soon.

I reran the tests with the patch. All the tests pass.

Thanks, D97184 is committed as https://reviews.llvm.org/rG5f4c91583ee772a6ce2c4f192e25b07e6075eb00
This patch should not be needed now.

[Jake-Egan]

Abandoning this patch because D97184 is already committed.

clang/test/ClangScanDeps/modules-full-by-mod-name.cpp

+// XFAIL: -aix
 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: cp %s %t.dir/modules_cdb_input2.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h

clang/test/ClangScanDeps/modules-pch.c

+// XFAIL: -aix
 // RUN: rm -rf %t && mkdir %t
 // RUN: cp %S/Inputs/modules-pch/* %t
 
 // Scan dependencies of the PCH:
 //
 // RUN: sed "s|DIR|%/t|g" %S/Inputs/modules-pch/cdb_pch.json > %t/cdb.json
 // RUN: echo -%t > %t/result_pch.json
 // RUN: clang-scan-deps -compilation-database %t/cdb.json -format experimental-full \

clang/test/CodeGenCXX/crash.cpp

+// XFAIL: -aix
 // RUN: %clang_cc1 %s -std=c++11 -emit-llvm-only
 // RUN: %clang_cc1 -emit-obj -o %t -debug-info-kind=line-tables-only -std=c++11 %s
 // RUN: %clang_cc1 -emit-obj -o %t -debug-info-kind=line-directives-only -std=c++11 %s
 // CHECK that we don't crash.
 
 // PR11676's example is ill-formed:
 /*
 union _XEvent {

clang/test/Modules/DebugInfoSubmodules.c

+// XFAIL: -aix
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fmodules -fmodule-format=obj -debug-info-kind=limited -dwarf-ext-refs \
 // RUN:     -fimplicit-module-maps -x c -fmodules-cache-path=%t -I %S/Inputs \
 // RUN:     %s -mllvm -debug-only=pchcontainer -emit-llvm -o %t.ll \
 // RUN:     2>&1 | FileCheck %s
 // REQUIRES: asserts
 #include "DebugSubmoduleA.h"
 

clang/test/Modules/ModuleDebugInfo.m

+// XFAIL: -aix
 // Test that debug info is emitted for an Objective-C module and
 // a precompiled header.
 
 // REQUIRES: asserts
 
 // Modules:
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -x objective-c -fmodules -fmodule-format=obj \

clang/test/Modules/lsv-debuginfo.cpp

+// XFAIL: -aix
 // Test C++ -gmodules debug info in the PCMs with local submodule visibility.
 // REQUIRES: asserts
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 \
 // RUN:   -fmodules-local-submodule-visibility %s \
 // RUN:   -dwarf-ext-refs -fmodule-format=obj -debug-info-kind=standalone \
 // RUN:   -dwarf-version=4 -fmodules -fimplicit-module-maps \
 // RUN:   -fmodules-cache-path="%t" -o %t.ll -I%S/Inputs/lsv-debuginfo \

clang/test/PCH/debug-info-pch-container-path.c

+// XFAIL: -aix
 // REQUIRES: asserts
 
 // Modules:
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cd %t
 
 // RUN: %clang_cc1 -fmodule-format=obj -emit-pch                \

clang/test/PCH/debug-info-pch-path.c

+// XFAIL: -aix
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cd %t
 //
 // ---------------------------------------------------------------------
 // Relative PCH, same directory.
 // ---------------------------------------------------------------------
 //

llvm/test/CodeGen/X86/dbg-distringtype-uint.ll

+; XFAIL: -aix
 ; RUN: llc -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
 ;
 ; CHECK: [[SYM:[a-z0-9]+]]:  DW_TAG_formal_parameter
 ; CHECK:                     DW_AT_name ("esym")
 ; CHECK:                     DW_AT_type ([[TYPE:[a-z0-9]+]] "CHARACTER_1")
 ;
 ; CHECK:                     DW_TAG_formal_parameter
 ; CHECK:                       DW_AT_const_value  (7523094288207667809)

llvm/test/DebugInfo/Generic/2010-04-06-NestedFnDbgInfo.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -o - < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ; Radar 7833483
 ; Do not emit a separate out-of-line definition DIE for the function-local 'foo'
 ; function (member of the function local 'A' type)
 ; CHECK: DW_TAG_class_type
 ; CHECK: DW_TAG_class_type
 ; CHECK-NEXT: DW_AT_name {{.*}} "A"
 ; Check that the subprogram inside the class definition has low_pc, only

llvm/test/DebugInfo/Generic/2010-05-10-MultipleCU.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
 
 ; Check that two compile units are generated
 
 ; CHECK: Compile Unit:
 ; CHECK: Compile Unit:
 
 define i32 @foo() nounwind readnone ssp !dbg !2 {

llvm/test/DebugInfo/Generic/DICommonBlock.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_common_block
 ; CHECK-DAG: DW_AT_name{{.*}}"a"
 ; CHECK-DAG: DW_AT_location
 ; CHECK: DW_TAG_variable
 ; CHECK-DAG: DW_AT_name{{.*}}"c"
 ; CHECK-DAG: DW_AT_location{{.*}}DW_OP_plus_uconst{{.*}}4

llvm/test/DebugInfo/Generic/PR20038.ll

+; XFAIL: -aix
 ; For some reason, the output when targetting sparc is not quite as expected.
 ; XFAIL: sparc
 
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; IR generated from clang -O0 with:
 ; struct C {
 ;   ~C();

llvm/test/DebugInfo/Generic/constant-pointers.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o - | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Ensure that pointer constants are emitted as unsigned data. Alternatively,
 ; these could be signless data (dataN).
 
 ; Built with Clang from:
 ; template <void *V, void (*F)(), int i>
 ; void func() {}

llvm/test/DebugInfo/Generic/containing-type-extension.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Check that any type can have a vtable holder.
 ; CHECK: [[SP:.*]]: DW_TAG_structure_type
 ; CHECK-NOT: TAG
 ; CHECK: DW_AT_containing_type [DW_FORM_ref4]
 ; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "vtable")

llvm/test/DebugInfo/Generic/cross-cu-inlining.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck -implicit-check-not=DW_TAG %s
 ; RUN: %llc_dwarf -accel-tables=Apple -dwarf-linkage-names=All -O0 -filetype=obj < %s | llvm-dwarfdump -v - | FileCheck --check-prefix=CHECK-ACCEL --check-prefix=CHECK %s
 
 ; Build from source:
 ; $ clang++ a.cpp b.cpp -g -c -emit-llvm
 ; $ llvm-link a.bc b.bc -o ab.bc
 ; $ opt -inline ab.bc -o ab-opt.bc
 ; $ cat a.cpp

llvm/test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Testing that two distinct (distinct by writing them in separate files, while
 ; still fulfilling C++'s ODR by having identical token sequences) functions,
 ; linked under LTO, get plausible debug info (and don't crash).
 
 ; Built from source:
 ; $ clang++ a.cpp b.cpp -g -c -emit-llvm

llvm/test/DebugInfo/Generic/cross-cu-linkonce.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Built from source:
 ; $ clang++ a.cpp b.cpp -g -c -emit-llvm
 ; $ llvm-link a.bc b.bc -o ab.bc
 ; $ cat a.cpp
 ; # 1 "func.h"
 ; inline int func(int i) {

llvm/test/DebugInfo/Generic/cu-range-hole.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; Check that we emit ranges for this CU since we have a function with and
 ; without debug info.
 ; Note: This depends upon the order of output in the .o file. Currently it's
 ; in order of the output to make sure that the CU has multiple ranges since
 ; there's a function in the middle. If they were together then it would have

llvm/test/DebugInfo/Generic/cu-ranges.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Check that we emit ranges for this which has a non-traditional section and a normal section.
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_ranges
 ; CHECK: DW_TAG_subprogram

llvm/test/DebugInfo/Generic/dead-argument-order.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Built from the following source with clang -O1
 ; struct S { int i; };
 ; int function(struct S s, int i) { return s.i + i; }
 
 ; Due to the X86_64 ABI, 's' is passed in registers and once optimized, the
 ; entirety of 's' is never reconstituted, since only the int is required, and

llvm/test/DebugInfo/Generic/debug-info-enum.ll

+; XFAIL: -aix
 ; Test enumeration representation in DWARF debug info:
 ; * test value representation for each possible underlying integer type
 ; * test the integer type is as expected
 ; * test the DW_AT_enum_class attribute is present (resp. absent) as expected.
 
 ; RUN: llc -debugger-tune=gdb -dwarf-version=4 -filetype=obj -o %t.o < %s
 ; RUN: llvm-dwarfdump -debug-info %t.o | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DW4
 ; RUN: llc -debugger-tune=gdb -dwarf-version=2 -filetype=obj -o %t.o < %s

llvm/test/DebugInfo/Generic/debug-info-qualifiers.ll

+; XFAIL: -aix
 ; Test (r)value qualifiers on C++11 non-static member functions.
 ; Generated from tools/clang/test/CodeGenCXX/debug-info-qualifiers.cpp
 ;
 ; class A {
 ; public:
 ;   void l() const &;
 ;   void r() const &&;
 ; };

llvm/test/DebugInfo/Generic/debug-label-inline.ll

+; XFAIL: -aix
 ; RUN: llc -O0 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; Bug 47129
 ; XFAIL: sparc
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: [[LABEL_ORIGIN:0x[0-9a-zA-Z]+]]:{{ *}}DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"

llvm/test/DebugInfo/Generic/debug-label.ll

+; XFAIL: -aix
 ; RUN: llc -O0 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
 ; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label.c
 ; CHECK-NEXT: DW_AT_decl_line [DW_FORM_data1] {{.*}}4
 ; CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] {{.*}}{{0x[0-9a-f]+}}

llvm/test/DebugInfo/Generic/def-line.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -debug-info - | FileCheck %s
 
 ; Given the following source, ensure that the decl_line/file is correctly
 ; emitted and omitted on definitions if it mismatches/matches the declaration
 
 ; struct foo {
 ;   static void f1() {
 ;   }

llvm/test/DebugInfo/Generic/discriminated-union.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Check for a variant part that has two members, one of which has a
 ; discriminant value.
 
 ; CHECK: DW_TAG_variant_part
 ;   CHECK-NOT: TAG

llvm/test/DebugInfo/Generic/discriminator.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -debug-info - | FileCheck %s
 
 ; Given the following source, ensure that the discriminator is emitted for
 ; the inlined callsite.
 
 ;void xyz();
 ;static void __attribute__((always_inline)) bar() { xyz(); }
 ;void foo() {

llvm/test/DebugInfo/Generic/disubrange_vla.ll

+; XFAIL: -aix
 ; RUN: rm -rf %t %t2
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -name=vla_expr %t > %t2
 ; RUN: llvm-dwarfdump -verbose %t >> %t2
 ; RUN: cat %t2 | FileCheck %s
 
 ; This test runs llvm-dwarfdump twice:
 ; - First to get the debug entry for 'vla_expr'.

llvm/test/DebugInfo/Generic/disubrange_vla_no_dbgvalue.ll

+; XFAIL: -aix
 ; RUN: rm -rf %t %t2
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -verbose -name=vla %t > %t2
 ; RUN: llvm-dwarfdump -verbose %t >> %t2
 ; RUN: cat %t2 | FileCheck %s
 
 ; This test runs llvm-dwarfdump twice:
 ; - First to get the debug entry for 'vla', to get the array type node.

llvm/test/DebugInfo/Generic/dwarf-public-names.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -debugger-tune=gdb -filetype=obj -o %t.o < %s
 ; RUN: llvm-dwarfdump -debug-pubnames %t.o | FileCheck %s
 ; ModuleID = 'dwarf-public-names.cpp'
 ;
 ; Generated from:
 ;
 ; struct C {
 ;   void member_function();

llvm/test/DebugInfo/Generic/empty.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -v - | FileCheck %s
 ; RUN: %llc_dwarf -split-dwarf-file=foo.dwo < %s -filetype=obj | llvm-dwarfdump -v - | FileCheck --check-prefix=FISSION %s
 
 ; darwin has a workaround for a linker bug so it always emits one line table entry
 ; XFAIL: darwin
 
 ; Expect no line table entry since there are no functions and file references in this compile unit
 ; CHECK: .debug_line contents:

llvm/test/DebugInfo/Generic/enum-types.ll

-;
+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Make sure we can handle enums with the same identifier but in enum types of
 ; different compile units.
 ; rdar://17628609
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: 0x[[ENUM:.*]]: DW_TAG_enumeration_type

llvm/test/DebugInfo/Generic/enum.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; IR generated from the following code compiled with clang -g:
 ; enum e1 { I, J = 0xffffffffU, K = 0xf000000000000000ULL } a;
 ; enum e2 { X };
 ; void func() {
 ;   int b = X;

llvm/test/DebugInfo/Generic/fortran-subprogram-attr.ll

+; XFAIL: -aix
 ; Test for DISPFlagPure, DISPFlagElement and DISPFlagRecursive.  These
 ; three DISPFlags are used to attach DW_AT_pure, DW_AT_element, and
 ; DW_AT_recursive attributes to DW_TAG_subprogram DIEs.
 
 ; -- test the resulting DWARF to make sure we're emitting
 ; DW_AT_{pure,elemental,recursive}.
 
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t.o

llvm/test/DebugInfo/Generic/global.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; Also test that the null streamer doesn't crash with debug info.
 ; RUN: %llc_dwarf -O0 -filetype=null < %s
 
 ; generated from the following source compiled to bitcode with clang -g -O1
 ; static int i;

llvm/test/DebugInfo/Generic/gmlt.test

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %S/../Inputs/gmlt.ll | llvm-dwarfdump -v - | FileCheck %S/../Inputs/gmlt.ll
 
 ; There's a darwin specific test in X86/gmlt, so it's okay to XFAIL this here.
 ; XFAIL: darwin

llvm/test/DebugInfo/Generic/gmlt_profiling.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %S/gmlt_profiling.ll | llvm-dwarfdump -v - | FileCheck %S/gmlt_profiling.ll
 
 ; CHECK: .debug_info
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}} "f1"
 ; With debug-info-for-profiling attribute, we need to emit decl_file and
 ; decl_line of the subprogram.

llvm/test/DebugInfo/Generic/imported-name-inlined.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
 
 ; Generated from the following source:
 ; namespace ns {
 ; void f();
 ; }
 ; inline __attribute__((always_inline)) void f1() {
 ;   using ns::f;

llvm/test/DebugInfo/Generic/incorrect-variable-debugloc.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O2 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; This is a test case that's as reduced as I can get it, though I haven't fully
 ; understood the mechanisms by which this bug occurs, so perhaps there's further
 ; simplification to be had (it's certainly a bit non-obvious what's going on). I
 ; hesitate to hand-craft or otherwise simplify the IR compared to what Clang
 ; generates as this is a particular tickling of optimizations and debug location
 ; propagation I want a realistic example of.

llvm/test/DebugInfo/Generic/incorrect-variable-debugloc1.ll

+; XFAIL: -aix
 ; xfail this test on hexagon because at O2, instructions are bundled in packets
 ; and DW_OP_lit13 is correctly omitted.
 ; XFAIL: hexagon
 
 ; RUN: %llc_dwarf -O2  -dwarf-version 2 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF23
 ; RUN: %llc_dwarf -O2  -dwarf-version 3 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF23
 ; RUN: %llc_dwarf -O2  -dwarf-version 4 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF4
 

llvm/test/DebugInfo/Generic/inline-scopes.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
 
 ; bool f();
 ; inline __attribute__((always_inline)) int f1() {
 ;   if (bool b = f())
 ;     return 1;
 ;   return 2;
 ; }

llvm/test/DebugInfo/Generic/inlined-arguments.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; IR generated from clang -O -g with the following source
 ;
 ; void f1(int x, int y);
 ; void f3(int line);
 ; void f2() {

llvm/test/DebugInfo/Generic/inlined-strings.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s -dwarf-inlined-strings=Enable -o - | llvm-dwarfdump -show-form - | FileCheck %s
 
 ; Also test that the null streamer doesn't crash with debug info.
 ; RUN: %llc_dwarf -O0 -filetype=null < %s -dwarf-inlined-strings=Enable
 
 ; generated from the following source compiled to bitcode with clang -g -O1
 ; static int i;
 ; int main() {

llvm/test/DebugInfo/Generic/line-table-addrx.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ;; In DWARF v5, emit DW_AT_addr_base as DW_AT_addr_base is used for DW_AT_low_pc.
 ; CHECK: DW_AT_low_pc [DW_FORM_addrx]
 ; CHECK: DW_AT_addr_base
 
 define i64 @foo() !dbg !7 {
 entry:

llvm/test/DebugInfo/Generic/linkage-name-abstract.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Abstract < %s | llvm-dwarfdump -v -debug-info - > %t
 ; RUN: FileCheck %s -check-prefix=ONENAME < %t
 ; RUN: FileCheck %s -check-prefix=REF < %t 
 ; Verify tuning for SCE gets us Abstract only.
 ; RUN: %llc_dwarf -O0 -filetype=obj -debugger-tune=sce < %s | llvm-dwarfdump -v -debug-info - > %t
 ; RUN: FileCheck %s -check-prefix=ONENAME < %t
 ; RUN: FileCheck %s -check-prefix=REF < %t 
 

llvm/test/DebugInfo/Generic/lto-comp-dir.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -debug-line - | FileCheck %s
 ; RUN: %llc_dwarf < %s -filetype=asm | FileCheck --check-prefix=ASM %s
 
 ; If multiple line tables are emitted, one per CU, those line tables can
 ; unambiguously rely on the comp_dir of their owning CU and use directory '0'
 ; to refer to it.
 
 ; CHECK: .debug_line contents:

llvm/test/DebugInfo/Generic/mainsubprogram.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Make sure we're emitting DW_AT_main_subprogram.
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_AT_name {{.*}} "main"
 ; CHECK-NOT: {{DW_TAG|NULL}}

llvm/test/DebugInfo/Generic/member-order.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; generated by clang from:
 ; struct foo {
 ;   void f1();
 ;   void f2();
 ; };
 ;

llvm/test/DebugInfo/Generic/member-pointers.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_ptr_to_member_type
 ; CHECK: DW_TAG_ptr_to_member_type
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]}
 ; CHECK: [[TYPE]]:   DW_TAG_subroutine_type
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_type

llvm/test/DebugInfo/Generic/missing-abstract-variable.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; The formal parameter 'b' for Function 'x' when inlined within 'a' is lost on
 ; powerpc64 (and on x86_64 at at least -O2). Presumably this is a SelectionDAG
 ; issue.
 ; FIXME: arm64 is an alias for aarch64 on macs, apparently?
 ; XFAIL: powerpc64, aarch64, arm64, hexagon, riscv
 

llvm/test/DebugInfo/Generic/namespace.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v - | FileCheck %s
 ; CHECK: debug_info contents
 ; CHECK: DW_AT_name{{.*}}= [[F1:.*]])
 ; CHECK: [[NS1:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NOT: DW_AT_decl_file
 ; CHECK-NOT: DW_AT_decl_line
 ; CHECK-NOT: NULL
 ; CHECK: [[NS2:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace

llvm/test/DebugInfo/Generic/namespace_function_definition.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Generated from clang with the following source:
 ; namespace ns {
 ; void func() {
 ; }
 ; }
 

llvm/test/DebugInfo/Generic/namespace_inline_function_definition.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Generate from clang with the following source. Note that the definition of
 ; the inline function follows its use to workaround another bug that should be
 ; fixed soon.
 ; namespace ns {
 ; int func(int i);
 ; }

llvm/test/DebugInfo/Generic/no-empty-child-vars.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -o - -filetype=obj | llvm-dwarfdump - | FileCheck %s -implicit-check-not=DW_TAG
 ;
 ; This tests that we do not create concrete variable DIEs for variables that
 ; have no location -- for both ways that LLVM-IR can express a variable with
 ; no location. It's possible to:
 ;   1) Omit all dbg.values and place the variable in the subprograms retained
 ;      nodes list,
 ;   2) Have a dbg.value with an undef operand, and none with "real" operands.

llvm/test/DebugInfo/Generic/noscopes.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s
 
 ; Just because there are no scopes/locations on any instructions in the
 ; function doesn't mean we can't describe the address range of the function.
 ; Check that we do that
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: TAG

llvm/test/DebugInfo/Generic/pass-by-value.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s -strict-dwarf=true | llvm-dwarfdump -debug-info - \
 ; RUN:   | FileCheck %s --check-prefix=STRICT --implicit-check-not DW_AT_calling_convention
 ;
 ; // S is not trivially copyable.
 ; struct S {
 ;    ~S() {}
 ; };

llvm/test/DebugInfo/Generic/ptrsize.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Check that pointers and references get emitted without size information in
 ; DWARF, even if they are so specified in the IR
 
 ; CHECK: 0x[[O1:[0-9a-f]+]]:   DW_TAG_pointer_type
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]

llvm/test/DebugInfo/Generic/recursive_inlining.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; This isn't a very pretty test case - I imagine there might be other ways to
 ; tickle the optimizers into producing the desired code, but I haven't found
 ; them.
 
 ; The issue is when a function is inlined into itself, the inlined argument
 ; accidentally overwrote the concrete argument and was lost.

llvm/test/DebugInfo/Generic/restrict.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -dwarf-version=2 -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --check-prefix=CHECK --check-prefix=V2 %s
 ; RUN: %llc_dwarf -dwarf-version=3 -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --check-prefix=CHECK --check-prefix=V3 %s
 
 ; CHECK: DW_AT_name {{.*}} "dst"
 ; V2: DW_AT_type {{.*}} {[[PTR:0x.*]]}
 ; V3: DW_AT_type {{.*}} {[[RESTRICT:0x.*]]}
 ; V3: [[RESTRICT]]: {{.*}}DW_TAG_restrict_type
 ; V3-NEXT: DW_AT_type {{.*}} {[[PTR:0x.*]]}

llvm/test/DebugInfo/Generic/skeletoncu.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_GNU_dwo_id {{.*}}abcd
 ; CHECK: DW_AT_GNU_dwo_name {{.*}}"my.dwo"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "LLVM", isOptimized: false, runtimeVersion: 2, splitDebugFilename: "my.dwo", emissionKind: FullDebug, enums: !2, retainedTypes: !5, globals: !2, imports: !2, dwoId: 43981)
 !1 = !DIFile(filename: "<stdin>", directory: "/")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)

llvm/test/DebugInfo/Generic/sugared-constants.ll

+; XFAIL: -aix
 ; xfail this test on hexagon because upstream llc is not emitting the
 ; correct DWARF info. Downstream llc is.
 ; XFAIL: hexagon
 
 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o - | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ; Use correct signedness when emitting constants of derived (sugared) types.
 
 ; CHECK: DW_AT_const_value [DW_FORM_sdata] (42)

llvm/test/DebugInfo/Generic/template-recursive-void.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; This was pulled from clang's debug-info-template-recursive.cpp test.
 ; class base { };
 
 ; template <class T> class foo : public base  {
 ;   void operator=(const foo r) { }

llvm/test/DebugInfo/Generic/thrownTypes.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "f"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_thrown_type
 ; CHECK-NEXT:   DW_AT_type {{.*}} {[[ERROR:.*]]}
 ; CHECK-NOT: DW_TAG

llvm/test/DebugInfo/Generic/tu-composite.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: [[TYPE:.*]]: DW_TAG_structure_type
 ; Make sure we correctly handle containing type of a struct being a type identifier.
 ; CHECK-NEXT: DW_AT_containing_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE]]})
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "C")
 
 ; Make sure we correctly handle context of a subprogram being a type identifier.

llvm/test/DebugInfo/Generic/tu-member-pointer.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_ptr_to_member_type
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]}
 ; CHECK: [[TYPE]]:   DW_TAG_base_type
 ; IR generated from clang -g with the following source:
 ; struct Foo {
 ;   int e;

llvm/test/DebugInfo/Generic/two-cus-from-same-file.ll

+; XFAIL: -aix
 ; For http://llvm.org/bugs/show_bug.cgi?id=12942
 ;   There are two CUs coming from /tmp/foo.c in this module. Make sure it doesn't
 ;   blow llc up and produces something reasonable.
 ;
 
 ; RUN: %llc_dwarf %s -o %t -filetype=obj -O0
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 

llvm/test/DebugInfo/Generic/typedef.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck %s
 
 ; From source:
 ; typedef void x;
 ; x *y;
 
 ; Check that a typedef with no DW_AT_type is produced. The absence of a type is used to imply the 'void' type.
 

llvm/test/DebugInfo/Generic/unconditional-branch.ll

+; XFAIL: -aix
 ; PR 19261
 
 ; RUN: %llc_dwarf -fast-isel=false -O0 -filetype=obj %s -o %t
 ; RUN: llvm-dwarfdump -a %t | FileCheck %s
 
 ; CHECK: {{0x[0-9a-f]+}}      1      0      1   0             0  is_stmt
 ; CHECK: {{0x[0-9a-f]+}}      2      0      1   0             0  is_stmt
 ; CHECK: {{0x[0-9a-f]+}}      4      0      1   0             0  is_stmt

llvm/test/DebugInfo/Generic/univariant-discriminated-union.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Check for a univariant discriminated union -- that is, a variant
 ; part without a discriminant and with just a single variant.
 
 ; CHECK: DW_TAG_variant_part
 ;   CHECK-NOT: DW_AT_discr

llvm/test/DebugInfo/Generic/varargs.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t.o %s
 ; RUN: llvm-dwarfdump -v -debug-info %t.o | FileCheck %s
 ;
 ; Test debug info for variadic function arguments.
 ; Created from tools/clang/tests/CodeGenCXX/debug-info-varargs.cpp
 ;
 ; The ... parameter of variadic should be emitted as
 ; DW_TAG_unspecified_parameters.

llvm/test/DebugInfo/Generic/version.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; Make sure we are generating DWARF version 3 when module flag says so.
 ; CHECK: Compile Unit: length = {{.*}}, version = 0x0003
 
 define i32 @main() #0 !dbg !4 {
 entry:

llvm/test/DebugInfo/Generic/virtual-index.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Generated from the following C++ source code:
 ;
 ; struct A {
 ;   virtual void f();
 ;   virtual void g();

llvm/test/DebugInfo/X86/dwarfdump-generic_subrange.ll

+; XFAIL: -aix
 ;; This test checks whether DW_AT_rank attribute accepts DIExpression.
 
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 
 ; CHECK:  DW_AT_rank (DW_OP_push_object_address, DW_OP_plus_uconst 0x8, DW_OP_deref)

llvm/test/DebugInfo/X86/dwarfdump-generic_subrange_const.ll

+; XFAIL: -aix
 ;; This test checks whether DW_AT_rank attribute accepts constants.
 ;; constants are interally stored as DIExpression.
 
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 

llvm/test/DebugInfo/X86/dwarfdump-generic_subrange_count.ll

+; XFAIL: -aix
 ;; This test checks whether DW_AT_rank attribute accepts DIExpression.
 
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 
 ; CHECK:  DW_AT_rank (DW_OP_push_object_address, DW_OP_plus_uconst 0x8, DW_OP_deref)

llvm/test/DebugInfo/X86/dwarfdump-rankConst.ll

+; XFAIL: -aix
 ;; This test checks whether DW_AT_rank attribute accepts DIExpression.
 
 ; RUN: llc %s -filetype=obj -o %t.o
 ; RUN: llvm-dwarfdump  %t.o | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 

llvm/test/DebugInfo/X86/dwarfdump-rankExp.ll

+; XFAIL: -aix
 ;; This test checks whether DW_AT_rank attribute accepts DIExpression.
 
 ; RUN: llc %s -filetype=obj -o %t.o
 ; RUN: llvm-dwarfdump  %t.o | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 

llvm/test/DebugInfo/X86/dwarfdump-signed_const.ll

+; XFAIL: -aix
 ;; This test checks whether DW_OP_consts is emitted correctly.
 
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 
 ;; Check whether negative values are emitted correctly.

llvm/test/DebugInfo/X86/global-constants.ll

+; XFAIL: -aix
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK-DAG-LABEL:  DW_AT_name ("negconstant")
 ; CHECK:  DW_AT_const_value (-1)
 ; CHECK-DAG-LABEL:  DW_AT_name ("negconstant2")
 ; CHECK:  DW_AT_const_value (-2)
 ; CHECK-DAG-LABEL:  DW_AT_name ("posconstant")
 ; CHECK:  DW_AT_const_value (1)

llvm/test/DebugInfo/X86/objc_direct.ll

+; XFAIL: -aix
 ; RUN: llc < %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Source code to regenerate:
 ; __attribute__((objc_root_class))
 ; @interface Root
 ; - (int)direct_method __attribute__((objc_direct));
 ; @end

llvm/test/DebugInfo/cross-cu-scope.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; REQUIRES: default_triple, object-emission
 
 ; Reduced test case from PR35212. Two DISubprogram belong to a different CU but
 ; share a scope. Both are declarations and end up in the scope's CU. We want to
 ; check that the CU from the context DIE is used (rather than from the IR).
 ; This manifests itself by the DW_base_type ending up in the second CU, rather

llvm/test/DebugInfo/dwo.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; REQUIRES: default_triple, object-emission
 ;
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: dwo_id
 ;
 ; The skeleton must come second or LLDB may get confused.

llvm/test/DebugInfo/skeletoncu.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_GNU_dwo_id {{.*}}abcd
 ; CHECK: DW_AT_GNU_dwo_name {{.*}}"my.dwo"
 ; REQUIRES: default_triple, object-emission
  
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "LLVM", isOptimized: false, runtimeVersion: 2, splitDebugFilename: "my.dwo", emissionKind: FullDebug, enums: !2, retainedTypes: !2, globals: !2, imports: !2, dwoId: 43981)
 !1 = !DIFile(filename: "<stdin>", directory: "/")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 

llvm/test/Linker/subprogram-linkonce-weak.ll

+; XFAIL: -aix
 ; RUN: llvm-link %s %S/Inputs/subprogram-linkonce-weak.ll -S -o %t1
 ; RUN: FileCheck %s -check-prefix=LW -check-prefix=CHECK <%t1
 ; RUN: llvm-link %S/Inputs/subprogram-linkonce-weak.ll %s -S -o %t2
 ; RUN: FileCheck %s -check-prefix=WL -check-prefix=CHECK <%t2
 ; REQUIRES: default_triple
 ;
 ; Bug 47131
 ; XFAIL: sparc

llvm/test/Linker/type-unique-odr-a.ll

+; XFAIL: -aix
 ; REQUIRES: default_triple, object-emission
 ;
 ; RUN: llvm-link %s %p/type-unique-odr-b.ll -S -o - \
 ; RUN:   | %llc_dwarf -dwarf-linkage-names=All -filetype=obj -O0 \
 ; RUN:   | llvm-dwarfdump -v -debug-info - \
 ; RUN:   | FileCheck %s
 ; RUN: llvm-link %p/type-unique-odr-b.ll %s -S -o - \
 ; RUN:   | %llc_dwarf -dwarf-linkage-names=All -filetype=obj -O0 \

llvm/test/Linker/type-unique-simple-a.ll

+; XFAIL: -aix
 ; REQUIRES: default_triple, object-emission
 
 ; RUN: llvm-link %s %p/type-unique-simple-b.ll -S -o %t
 ; RUN: cat %t | FileCheck %s -check-prefix=LINK
 ; RUN: %llc_dwarf -filetype=obj -O0 < %t > %t2
 ; RUN: llvm-dwarfdump -v -debug-info %t2 | FileCheck %s
 
 ; Make sure the backend generates a single DIE and uses ref_addr.

llvm/test/Linker/type-unique-simple2-a.ll

+; XFAIL: -aix
 ; REQUIRES: default_triple, object-emission
 ;
 ; RUN: llvm-link %s %p/type-unique-simple2-b.ll -S -o - | %llc_dwarf -filetype=obj -O0 | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ;
 ; Tests for a merge error where attributes are inserted twice into the same DIE.
 ;
 ; $ cat ab.h
 ; typedef int foo_t;

llvm/test/Linker/type-unique-simple2.ll

+; XFAIL: -aix
 ; REQUIRES: default_triple, object-emission
 
 ; RUN: llvm-link %S/Inputs/type-unique-simple2-a.ll %S/Inputs/type-unique-simple2-b.ll -S -o %t
 ; RUN: cat %t | FileCheck %S/Inputs/type-unique-simple2-a.ll -check-prefix=LINK
 ; RUN: %llc_dwarf -filetype=obj -O0 < %t > %t2
 ; RUN: llvm-dwarfdump -v -debug-info %t2 | FileCheck %S/Inputs/type-unique-simple2-a.ll

llvm/test/Linker/type-unique-type-array-a.ll

+; XFAIL: -aix
 ; REQUIRES: default_triple, object-emission
 ;
 ; RUN: llvm-link %s %p/type-unique-type-array-b.ll -S -o - | %llc_dwarf -filetype=obj -O0 | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ;
 ; rdar://problem/17628609
 ;
 ; cat -n a.cpp
 ;     1 struct SA {

llvm/test/MC/ELF/cfi-version.ll

+; XFAIL: -aix
 ; RUN: %llc_dwarf %s -o - -dwarf-version 2 -filetype=obj | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF2
 ; RUN: %llc_dwarf %s -o - -dwarf-version 3 -filetype=obj | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF3
 ; RUN: %llc_dwarf %s -o - -dwarf-version 4 -filetype=obj | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF4
 ; RUN: %llc_dwarf %s -o - -dwarf-version 5 -filetype=obj | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF4
 
 ; PR46647
 ; XFAIL: arm64-apple
 

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

#define UDATA_1 18446744073709551614ULL
   }
 
   //----------------------------------------------------------------------
   // Add an address at the end to make sure we can decode this value
   //----------------------------------------------------------------------
   EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_Last), 0));
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr4AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr4AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4AllForms) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr4AllForms) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4AllForms) {
+#endif
   // 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>();
 }
 
template <uint16_t Version, class AddrType> void TestChildren() {
   }
 
   // Verify the previous sibling of our subprogram is our integer base type.
   IntDieDG = NullDieDG.getPreviousSibling();
   EXPECT_TRUE(IntDieDG.isValid());
   EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr4Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Children) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr4Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Children) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr4Children) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Children) {
+#endif
   // 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));
template <uint16_t Version, class AddrType> void TestReferences() {
   // DW_AT_type points to our base type DIE.
   auto CU2ToCU1RefAddrDieDG = CU2RefAddrDieDG.getSibling();
   EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
   EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(CU1TypeDieDG.getOffset(),
             toReference(CU2ToCU1RefAddrDieDG.find(DW_AT_type), -1ULL));
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr4References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr4References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4References) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr4References) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4References) {
+#endif
   // 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));
template <uint16_t Version, class AddrType> void TestAddresses() {
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualHighPC);
 
   EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   EXPECT_EQ(LowPC, ActualLowPC);
   EXPECT_EQ(HighPC, ActualHighPC);
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr4Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Addresses) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr4Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Addresses) {
+#endif
   // 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>();
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr4Addresses) {
+#else
 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Addresses) {
+#endif
   // 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>();
 }
 
 TEST(DWARFDebugInfo, TestStringOffsets) {
   Triple Triple = getNormalizedDefaultTargetTriple();
TEST(DWARFDebugInfo, TestStringOffsets) {
   Optional<DWARFFormValue> Form3 = DieDG.find(Attr3);
   ASSERT_TRUE((bool)Form3);
   EXPECT_EQ(1u, Form3->getRawUValue());
   auto Extracted3 = toString(Form3);
   ASSERT_TRUE((bool)Extracted3);
   EXPECT_STREQ(String1, *Extracted3);
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestEmptyStringOffsets) {
+#else
 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   const char *String1 = "Hello";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
#endif
   MemoryBufferRef FileBuffer(FileBytes, "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   ASSERT_TRUE((bool)Obj);
   std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
   EXPECT_TRUE(
       DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty());
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestRelations) {
+#else
 TEST(DWARFDebugInfo, TestRelations) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
TEST(DWARFDebugInfo, TestDWARFDie) {
   // Make sure a default constructed DWARFDie doesn't have any parent, sibling
   // or child;
   DWARFDie DefaultDie;
   EXPECT_FALSE(DefaultDie.getParent().isValid());
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestChildIterators) {
+#else
 TEST(DWARFDebugInfo, TestChildIterators) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   // Test the DWARF APIs related to iterating across the children of a DIE using
   // the DWARFDie::iterator class.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
TEST(DWARFDebugInfo, TestEmptyChildren) {
   EXPECT_TRUE(CUDie.isValid());
 
   // Verify that the CU Die that says it has children, but doesn't, actually
   // has begin and end iterators that are equal. We want to make sure we don't
   // see the Null DIEs during iteration.
   EXPECT_EQ(CUDie.begin(), CUDie.end());
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestAttributeIterators) {
+#else
 TEST(DWARFDebugInfo, TestAttributeIterators) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   // Test the DWARF APIs related to iterating across all attribute values in a
   // a DWARFDie.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
#endif
 
   ASSERT_NE(E, ++I);
   EXPECT_EQ(I->Attr, DW_AT_low_pc);
   EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
 
   EXPECT_EQ(E, ++I);
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestFindRecurse) {
+#else
 TEST(DWARFDebugInfo, TestFindRecurse) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   EXPECT_EQ(InvalidU64, toReference(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt6, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
 
   // Test
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestFindAttrs) {
+#else
 TEST(DWARFDebugInfo, TestFindAttrs) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
   // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
   uint16_t Version = 4;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
#endif
   // Make sure we can extract the name from the specification die when using
   // DWARFDie::findRecursively() since it should recurse through the
   // DW_AT_specification DIE.
   auto NameOpt = FuncDie.findRecursively(Attrs);
   EXPECT_TRUE(NameOpt.hasValue());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 
+#ifdef _AIX
+TEST(DWARFDebugInfo, DISABLED_TestImplicitConstAbbrevs) {
+#else
 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
+#endif
   Triple Triple = getNormalizedDefaultTargetTriple();
   if (!isObjectEmissionSupported(Triple))
     return;
 
   uint16_t Version = 5;
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();

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_ErrorForExtendedOpcodeLengthSmallerThanExpeted) {
+#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
   Parser.parseNext(RecordRecoverable, RecordUnrecoverable);
 
   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();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, Units);
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
   ASSERT_FALSE(Parser.done());
   Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
   EXPECT_FALSE(Recoverable);
 
   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(
                         "unable to decode LEB128 at offset 0x00000030: "
                         "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());

llvm/unittests/DebugInfo/DWARF/DWARFDieManualExtractTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::dwarf;
 using namespace utils;
 
 namespace {
 
+#ifdef _AIX
+TEST(DWARFDie, DISABLED_manualExtractDump) {
+#else
 TEST(DWARFDie, manualExtractDump) {
+#endif
   typedef uint32_t AddrType;
   uint16_t Version = 4;
   Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
   if (!isObjectEmissionSupported(Triple))
     return;
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());

llvm/unittests/Passes/PluginsTest.cpp

#endif
 
   Plugin->registerPassBuilderCallbacks(PB);
   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, "plugin-pass"), Succeeded());
 }
 
 // Test that llvmGetPassPluginInfo from DoublerPlugin is called twice with
 // -fpass-plugin=DoublerPlugin -fpass-plugin=TestPlugin
 // -fpass-plugin=DoublerPlugin.
+#ifdef _AIX
+TEST(PluginsTests, DISABLED_LoadMultiplePlugins) {
+#else
 TEST(PluginsTests, LoadMultiplePlugins) {
+#endif
 #if !defined(LLVM_ENABLE_PLUGINS)
   // Disable the test if plugins are disabled.
   return;
 #endif
 
   auto DoublerPluginPath = LibPath("DoublerPlugin");
   auto TestPluginPath = LibPath("TestPlugin");
   ASSERT_NE("", DoublerPluginPath);