[lldb] Require x86 backend for a bunch of DWARF tests

[DavidSpickett]

Summary

By moving them into a folder with a local lit config
requiring x86. All these tests use x86 target triples.

There are two tests that require target-x86_64 because
they run program files (instead of just needing the backend).
Those are moved to the x86 folder also but their REQUIRES are
unchanged.

[JDevlieghere]

Rather than updating all the these tests, please move them into an x86 subdirectory and add a lit.local.cfg to mark the whole folder as unsupported without x86 support. Something like:

if not 'x86' in config.available_features:
  config.unsupported = True

[DavidSpickett]

• Add x86 folder with lit config to require x86
• Remove x86 requirement from indiviual tests in that folder (but not for the target-x86_64 tests which need to run program files)
• Tests that don't need x86 remain in the top level Shell/SymbolFile/DWARF folder

[JDevlieghere]

Thanks, LGTM.

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_const_value.s

 # Test handling of (optimized-out/location-less) variables whose value is
 # specified by DW_AT_const_value
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
 # RUN: %lldb %t \
 # RUN:   -o "target variable udata data1 data2 data4 data8 string strp ref4 udata_ptr" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: target variable
 ## Variable specified via DW_FORM_udata. This is typical for clang (10).
 # CHECK: (unsigned long) udata = 4742474247424742

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_decl_file-DW_AT_specification-crosscu.s

 # Check that DW_AT_decl_file inherited by DW_AT_specification from a different
 # DW_TAG_compile_unit is using the DW_TAG_compile_unit->DW_AT_stmt_list where the
 # DW_AT_decl_file is located (and not where the DW_AT_specification is located).
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
 # RUN: %lldb %t \
 # RUN:   -o "image lookup -v -n main" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK: FuncType: id = {0x0000002a}, byte-size = 0, decl = filename1:1, compiler_type = "int (void)"
 
   .text

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_declaration-with-children.s

 # Test handling of forward-declared (DW_AT_declaration) structures. These types
 # can be produced due to vtable-based type homing, or other -flimit-debug-info
 # optimizations.
 
-# REQUIRES: x86
-
 # RUN: split-file %s %t
 # RUN: llvm-mc --triple x86_64-pc-linux %t/asm --filetype=obj -o %t.o
 # RUN: %lldb -o "settings set interpreter.stop-command-source-on-error false" \
 # RUN:   -s %t/commands -o exit %t.o 2>&1 | FileCheck %s
 
 #--- commands
 # Type A should be treated as a forward-declaration even though it has a child.
 target var a

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_location-DW_AT_const_value.s

 ## Test that we don't get confused by variables with both location and
 ## const_value attributes. Such values are produced in C++ for class-level
 ## static constexpr variables.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
 # RUN: %lldb %t -o "target variable A::x A::y" -o exit | FileCheck %s
 
 # CHECK-LABEL: target variable
 # CHECK: (const int) A::x = 142
 # CHECK: (const int) A::y = 242
 
         .section        .rodata,"a",@progbits

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_loclists_base.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_loclists" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_loclists
 # CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
 # CHECK-NOT: Variable:
 
 loclists:

lldb/test/Shell/SymbolFile/DWARF/x86/DW_AT_low_pc-addrx.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
 # CHECK:  Function: id = {0x0000002d}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
 # CHECK:    Blocks: id = {0x0000002d}, range = [0x00000000-0x00000003)
 # CHECK-NEXT:       id = {0x00000043}, range = [0x00000001-0x00000002)

lldb/test/Shell/SymbolFile/DWARF/x86/DW_OP_piece-smaller-than-struct.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
 # RUN: %lldb %t -o "target variable reset" -b | FileCheck %s
 
 # CHECK: (lldb) target variable reset
 # CHECK: (auto_reset) reset = {
 # CHECK:   ptr = 0xdeadbeefbaadf00d
 # Note: We need to find some way to represent "prev" as unknown/undefined.
 # CHECK:   prev = false

lldb/test/Shell/SymbolFile/DWARF/x86/DW_TAG_variable-DW_AT_const_value.s

 # This tests that lldb is able to print DW_TAG_variable using DW_AT_const_value.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
 # RUN: %lldb %t.o -o "p/x magic64" -o exit | FileCheck %s
 
 # CHECK: (const long) $0 = 0xed9a924c00011151
 
 # The DW_TAG_variable using DW_AT_const_value can be compiled from:
 # static const long magic64 = 0xed9a924c00011151;
 # int main(void) { return magic64; }

lldb/test/Shell/SymbolFile/DWARF/x86/array-sizes.s

 # This tests a bug where we would incorrectly parse the size of an array if that
 # size happened to match an existing DIE offset. This happened because we
 # misinterpreted that value as a reference to a DIE specifying the VLA size even
 # though the form was a data form (as it should be).
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: lldb-test symbols %t | FileCheck %s
 
 # CHECK: Variable{0x0000001e}, name = "X"
 # CHECK-SAME: type = {0000000000000033} 0x{{[0-9A-F]*}} (char [56])
 

lldb/test/Shell/SymbolFile/DWARF/x86/childless-compile-unit.s

 # Test that we don't crash when parsing slightly invalid DWARF.  The compile
 # unit in this file sets DW_CHILDREN_no, but it still includes an
 # end-of-children marker in its contribution.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: lldb-test symbols %t.o
 
   .section  .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz  "Hand-written DWARF"
 .Linfo_string1:
   .asciz  "-"

lldb/test/Shell/SymbolFile/DWARF/x86/debug-line-basic.s

 # Test basics of debug_line parsing. This test uses a linker script which
 # ensures the code is placed at the end of a module to test the boundary
 # condition when the final end-of-sequence line table entry points to an address
 # that is outside the range of memory covered by the module.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld --script=%S/Inputs/debug-line-basic.script %t.o -o %t
 # RUN: %lldb %t -o "image dump line-table -v a.c" -o exit | FileCheck %s
 
   .text
   .globl  _start
 _start:

lldb/test/Shell/SymbolFile/DWARF/x86/debug-types-address-ranges.s

 # Check address lookup works correctly in the presence of type units.
 # Specifically check that we don't use the line table pointed to by the
 # DW_AT_stmt_list of the type unit (which used only for the file names) to
 # compute address range for the type unit as type units don't describe any
 # addresses. The addresses should always resolve to the relevant compile units.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -dwarf-version=5 -triple x86_64-pc-linux %s -filetype=obj >%t.o
 # RUN: ld.lld %t.o -o %t -image-base=0x47000 -z separate-code
 # RUN: %lldb %t -o "image lookup -a 0x48000 -v" -o exit | FileCheck %s
 
 # CHECK:   CompileUnit: id = {0x00000001}, file = "/tmp/a.cc", language = "c++"
 # CHECK:      Function: id = {0x0000006a}, name = "::_start({{.*}})", range = [0x0000000000048000-0x000000000004800c)
 # CHECK:     LineEntry: [0x0000000000048000-0x000000000004800a): /tmp/a.cc:4

lldb/test/Shell/SymbolFile/DWARF/x86/debug-types-line-tables.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t
 # RUN: lldb-test symbols %t | FileCheck %s
 
         .file   1 "/tmp" "b.cc"
 
         .section        .debug_types,"",@progbits
 
 # CHECK: Types:

lldb/test/Shell/SymbolFile/DWARF/x86/debug-types-signature-loop.s

-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux -o %t.o %s
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -o "target variable e" -b | FileCheck %s
 
 # CHECK: e = <could not resolve type>
 
         .type   e,@object               # @e

lldb/test/Shell/SymbolFile/DWARF/x86/debug_aranges-empty-section.s

 # Test that an empty .debug_aranges section doesn't confuse (or crash) us.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc %s -triple x86_64-pc-linux -filetype=obj >%t
 # RUN: %lldb %t -o "breakpoint set -n f" -b | FileCheck %s
 
 # CHECK: Breakpoint 1: where = {{.*}}`f, address = 0x0000000000000047
 
   .text
   .globl  f                       # -- Begin function f
   .type f,@function

lldb/test/Shell/SymbolFile/DWARF/x86/debug_line-relative_path.s

 # This tests handling of debug info with fully relative paths, such as those
 # produced by "clang -fdebug-compilation-dir <something-relative>". This is one
 # of the techniques used to produce "relocatable" debug info.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux -o %t %s
 # RUN: %lldb %t -o "image dump line-table t.c" | FileCheck %s
 
 # CHECK: 0x0000000000000000: {{q[\\/]w[\\/]e[\\/]r[\\/]t}}.c:1
 
         .text
 main:
         .file   1 "w/e/r" "t.c"

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loc-aslr.s

 # This test checks the handling of location lists in the case when the module is
 # not loaded at the address at which it was linked (as happens with ASLR for
 # instance).
 
-# REQUIRES: x86
-
 # RUN: yaml2obj %S/Inputs/debug_loc-aslr.yaml -o %t.dmp
 # RUN: llvm-mc --triple=x86_64-pc-linux --filetype=obj %s >%t.o
 # RUN: %lldb -c %t.dmp -o "image add %t.o" \
 # RUN:   -o "image load --file %t.o --slide 0x470000" \
 # RUN:   -o "thread info" -o "frame variable" -o exit | FileCheck %s
 
 # CHECK: thread #1: tid = 16001, 0x0000000000470001 {{.*}}`_start
 # CHECK: (int) x = 47

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loc.s

 # Test location list handling, including the cases of invalid input. The exact
 # behavior in the invalid cases is not particularly important, but it should be
 # "reasonable".
 
-# REQUIRES: x86
 # UNSUPPORTED: lldb-repro
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s --defsym LOC=0 > %t
 # RUN: %lldb %t -o "image lookup -v -a 0" -o "image lookup -v -a 2" \
 # RUN:   -o "image dump symfile" -o exit | FileCheck %s
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s --defsym LOCLISTS=0 > %t
 # RUN: %lldb %t -o "image lookup -v -a 0" -o "image lookup -v -a 2" \

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loc_and_loclists.s

 # Test that we can handle DWARF 4 and 5 location lists in the same object file
 # (but different compile units).
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s loc" -o "image lookup -v -s loclists" \
 # RUN:   -o exit | FileCheck %s
 
 
 # CHECK-LABEL: image lookup -v -s loc
 # CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg5 RDI,
 

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loclists-dwo.s

-# REQUIRES: x86
-
 # RUN: cd %T
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s >debug_loclists-dwo.o
 # RUN: %lldb debug_loclists-dwo.o -o "image lookup -v -s lookup_loclists" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_loclists
 # CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
 # CHECK: Variable: {{.*}}, name = "x1", type = "int", location = DW_OP_reg1 RDX,
 

lldb/test/Shell/SymbolFile/DWARF/x86/debug_ranges-missing-section.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_ranges" -o exit 2>&1 | FileCheck %s
 
 # CHECK: DIE has DW_AT_ranges(0x47) attribute, but range extraction failed (No debug_ranges section),
 # CHECK:  Function: id = {0x0000001c}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
 # CHECK:    Blocks: id = {0x0000001c}, range = [0x00000000-0x00000004)
 
         .text

lldb/test/Shell/SymbolFile/DWARF/x86/debug_ranges.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_ranges" -o exit | FileCheck %s
 
 # CHECK:  Function: id = {0x0000002b}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
 # CHECK:    Blocks: id = {0x0000002b}, range = [0x00000000-0x00000004)
 # CHECK-NEXT:       id = {0x0000003f}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)
 
         .text

lldb/test/Shell/SymbolFile/DWARF/x86/debug_rnglists-dwo.s

-# REQUIRES: x86
-
 # RUN: cd %T
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s >debug_rnglists-dwo.o
 # RUN: %lldb debug_rnglists-dwo.o -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
 # CHECK:  Function: id = {0x4000000000000028}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
 # CHECK:    Blocks: id = {0x4000000000000028}, range = [0x00000000-0x00000003)

lldb/test/Shell/SymbolFile/DWARF/x86/debug_rnglists.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o "image lookup -v -s lookup_rnglists2" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
 # CHECK:  Function: id = {0x00000030}, name = "rnglists", range = [0x0000000000000000-0x0000000000000004)
 # CHECK:    Blocks: id = {0x00000030}, range = [0x00000000-0x00000004)
 # CHECK-NEXT:       id = {0x00000046}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)

lldb/test/Shell/SymbolFile/DWARF/x86/dir-separator-no-comp-dir-relative-name.s

 # Test that parsing of line tables works reasonably. In this case the debug info
 # does not have enough information for our heuristics to determine the path
 # style, so we will just treat them as native host paths.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t -z separate-code
 # RUN: %lldb %t -s %S/Inputs/dir-separator-no-comp-dir-relative-name.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for foo{{.}}a.c
 # CHECK-NEXT: 0x0000000000201000: foo{{.}}a.c:1

lldb/test/Shell/SymbolFile/DWARF/x86/dir-separator-no-comp-dir.s

 # Test that we properly determine the path syntax of a compile unit even if the
 # compile unit does not have a DW_AT_comp_dir attribute.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t -z separate-code
 # RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for C:\tmp\a.c
 # CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1

lldb/test/Shell/SymbolFile/DWARF/x86/dir-separator-posix.s

 # Test that parsing of line tables works reasonably, even if the host directory
 # separator does not match the separator of the compile unit.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t -z separate-code
 # RUN: %lldb %t -s %S/Inputs/dir-separator-posix.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for /tmp/a.c
 # CHECK-NEXT: 0x0000000000201000: /tmp/a.c:1

lldb/test/Shell/SymbolFile/DWARF/x86/dir-separator-windows.s

 # Test that parsing of line tables works reasonably, even if the host directory
 # separator does not match the separator of the compile unit.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t -z separate-code
 # RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for C:\tmp\a.c
 # CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-atomic.s

-# REQUIRES: x86
-
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "target variable integer structure" -o exit | FileCheck %s
 
 # CHECK: (_Atomic(int)) integer = 14159
 # CHECK: (_Atomic(struct_type)) structure = (member = 71828)
 
         .data
 integer:

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-debug_line-file-index.s

 # Test handling of DWARF5 file index 0.
-# REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
 # RUN: %lldb %t -o "image lookup -f hello.c -l 1" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK: 2 matches found in hello.c:1
   .text
 .Lfunc_begin0:

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-debug_line.s

 # Test handling of DWARF5 line tables. In particular, test that we handle files
 # which are present in the line table more than once.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
 # RUN: %lldb %t -o "source info -f file0.c" -o "source info -f file1.c" \
 # RUN:   -o "breakpoint set -f file0.c -l 42" \
 # RUN:   -o "breakpoint set -f file0.c -l 47" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: source info -f file0.c
 # CHECK: [0x0000000000000000-0x0000000000000001): /file0.c:42

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-implicit-const.s

 # Test handling of DWARF5 DW_FORM_implicit_const as used by GCC.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
 # RUN: %lldb %t -o "expression -T -- variable_implicit_const" \
 # RUN:   -o exit | FileCheck %s
 
 # Failing case was:
 # error: need to add support for DW_TAG_base_type 'int' encoded with DW_ATE = 0x5, bit_size = 0
 # CHECK: (int) $0 = 0
 

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-line-strp.s

 # Test handling of DWARF5 DW_FORM_line_strp from .debug_info as used by GCC.
 
 # UNSUPPORTED: system-darwin, system-windows
-# REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -o %t -triple x86_64-pc-linux %s
 # RUN: %lldb %t -o "p main" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK: (void (*)()) $0 = 0x0000000000000000
 
   .text

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5_locations.s

 # This tests that lldb is able to process DW_OP_addrx tags introduced in dwarf5.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -g -dwarf-version=5 -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
 # RUN: ld.lld -m elf_x86_64 %t.o -o %t 
 # RUN: lldb-test symbols %t | FileCheck %s
 
 # CHECK: Variable{0x00000011}, name = "color"
 # CHECK-SAME: location = DW_OP_addrx 0x0
 

lldb/test/Shell/SymbolFile/DWARF/x86/dwo-type-in-main-file.s

 # This tests the scenario where a (split) compile unit contains reference to a
 # type, but that type is defined in another compile unit in the main object
 # file.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc %s -o %t --triple=x86_64-pc-linux --filetype=obj --defsym MAIN=0
 # RUN: llvm-mc %s -o %T/dwo-type-in-main-file-cu2.dwo --triple=x86_64-pc-linux --filetype=obj --defsym DWO=0
 # RUN: cd %T
 # RUN: %lldb %t -o "target var a" -b 2>&1 | FileCheck %s
 
 # CHECK: (A) a = (b = 47)
 
 .ifdef MAIN

lldb/test/Shell/SymbolFile/DWARF/x86/dwp-debug-types.s

-# REQUIRES: x86
-
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t --defsym MAIN=0
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t.dwp --defsym DWP=0
 # RUN: %lldb %t -o "type lookup ENUM0" -o "target variable A" -b | FileCheck %s
 # RUN: lldb-test symbols %t | FileCheck %s --check-prefix=SYMBOLS
 
 # CHECK-LABEL: type lookup ENUM0
 # CHECK-NEXT: enum ENUM0 {
 # CHECK-NEXT:   case0

lldb/test/Shell/SymbolFile/DWARF/x86/dwp.s

-# REQUIRES: x86
-
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t --defsym MAIN=0
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t.dwp --defsym DWP=0
 # RUN: %lldb %t -o "target variable A" -o "image lookup -v -n F1" -b | FileCheck %s
 # RUN: lldb-test symbols %t | FileCheck %s --check-prefix=SYMBOLS
 
 # CHECK-LABEL: target variable A
 # CHECK: (INT0) A = 0
 # CHECK: (INT1) A = 1

lldb/test/Shell/SymbolFile/DWARF/x86/find-inline-method.s

-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t -z separate-code
 # RUN: lldb-test symbols --find=function --name=inl --function-flags=method %t \
 # RUN:   | FileCheck %s
 
 # CHECK: Function: {{.*}} mangled = "_Z8externali"
 # CHECK: Blocks: {{.*}} range = [0x00201000-0x00201002)

lldb/test/Shell/SymbolFile/DWARF/x86/inline-function-address-shared.test

-# REQUIRES: lld, x86
+# REQUIRES: lld
 ; RUN: llc -mtriple x86_64-pc-linux %S/inline-function-address.ll -filetype=obj -o %t.o
 ; RUN: ld.lld %t.o %t.o -o %t -shared
 ; RUN: lldb-test symbols --find=function --name=foo --function-flags=full %t | FileCheck %s
 ; CHECK: Function: {{.*}} "foo"
 ; CHECK-NOT: Function: {{.*}} "foo"

lldb/test/Shell/SymbolFile/DWARF/x86/inline-function-address.ll

-; REQUIRES: lld, x86
+; REQUIRES: lld
 ; RUN: llc -mtriple x86_64-pc-linux %s -filetype=obj -o %t.o
 ; RUN: ld.lld %t.o %t.o -o %t
 ; "foo" is defined in both compilation units, but there should be only one meaningful debuginfo entry
 ; RUN: lldb-test symbols --find=function --name=foo --function-flags=full %t | FileCheck %s
 ; CHECK: Function: {{.*}} "foo"
 ; CHECK-NOT: Function: {{.*}} "foo"
 
 $foo = comdat any

lldb/test/Shell/SymbolFile/DWARF/x86/limit-debug-info.s

-# REQUIRES: lld, x86
+# REQUIRES: lld
 # RUN: llvm-mc --triple=x86_64-pc-windows --filetype=obj --defsym DLL=0 %s >%t.dll.o
 # RUN: llvm-mc --triple=x86_64-pc-windows --filetype=obj --defsym EXE=0 %s >%t.exe.o
 # RUN: lld-link /OUT:%t.dll %t.dll.o /SUBSYSTEM:console /dll /noentry /debug
 # RUN: lld-link /OUT:%t.exe %t.exe.o /SUBSYSTEM:console /debug /force
 # RUN: %lldb %t.exe -o "target modules add %t.dll" -o "p var" \
 # RUN:   -o exit 2>&1 | FileCheck %s
 
 # CHECK: (lldb) p var

lldb/test/Shell/SymbolFile/DWARF/x86/lit.local.cfg

+if not 'x86' in config.available_features:
+  config.unsupported = True

lldb/test/Shell/SymbolFile/DWARF/x86/parallel-indexing-stress.s

 # Stress-test the parallel indexing of compile units.
 
-# REQUIRES: x86
-
 # RUN: llvm-mc -triple x86_64-pc-linux %s -o %t -filetype=obj
 # RUN: %lldb %t -o "target variable A" -b | FileCheck %s
 
 # CHECK-COUNT-256: A = 47
 
   .section  .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz  "Hand-written DWARF"

lldb/test/Shell/SymbolFile/DWARF/x86/static_scope.s

 # Test that the DWARF parser assigns the right scope to the
 # variable `b`, which is `local` and not `static`.
 
-# REQUIRES: x86
-
 # Original test case (for future reference), compiled with:
 # $ clang-10 -g -Og test.c -o test
 # $ cat test.c
 # volatile int a;
 # main() {
 #   int b = 3;
 #   a;
 # }

lldb/test/Shell/SymbolFile/DWARF/x86/subprogram_ranges.test

-# REQUIRES: x86
 # REQUIRES: lld
 # RUN: %clang -target x86_64-pc-linux -g -O0 %S/Inputs/subprogram_ranges.s -o %t.o -c
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb -b -s %s %t 2>&1 | FileCheck %s
 
 # Test breaking on symbols and printing variables when a DW_TAG_subprogram uses
 # DW_AT_ranges instead of DW_AT_low_pc/DW_AT_high_pc.  While the assembly here
 # is a bit unrealistic - it's a single-entry range using DWARFv4 which isn't

lldb/test/Shell/SymbolFile/DWARF/x86/win-i386-line-table.s

 # Test that lldb can read a line table for an architecture with a different
 # address size than the one that of the host.
 
-# REQUIRES: lld, x86
+# REQUIRES: lld
 
 # RUN: llvm-mc -triple i686-windows-gnu %s -filetype=obj > %t.o
 # RUN: lld-link %t.o -out:%t.exe -debug:dwarf -entry:entry -subsystem:console -lldmingw
 # RUN: %lldb %t.exe -o "image dump line-table -v win-i386-line-table.c" -b | FileCheck %s
 
 # CHECK: Line table for win-i386-line-table.c in `win-i386-line-table.s.tmp.exe
 # CHECK: 0x00401000: win-i386-line-table.c:2:1
 # CHECK: 0x00401001: win-i386-line-table.c:2:1