llvm/test/lit.cfg.py

   1 # -*- Python -*-
   2
   3 # Configuration file for the 'lit' test runner.
   4
   5 import os
   6 import sys
   7 import re
   8 import platform
   9 import subprocess
  10
  11 import lit.util
  12 import lit.formats
  13 from lit.llvm import llvm_config
  14 from lit.llvm.subst import FindTool
  15 from lit.llvm.subst import ToolSubst
  16
  17 # name: The name of this test suite.
  18 config.name = "LLVM"
  19
  20 # testFormat: The test format to use to interpret tests.
  21 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
  22
  23 # suffixes: A list of file extensions to treat as test files. This is overriden
  24 # by individual lit.local.cfg files in the test subdirectories.
  25 config.suffixes = [".ll", ".c", ".test", ".txt", ".s", ".mir", ".yaml"]
  26
  27 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
  28 # subdirectories contain auxiliary inputs for various tests in their parent
  29 # directories.
  30 config.excludes = ["Inputs", "CMakeLists.txt", "README.txt", "LICENSE.txt"]
  31
  32 # test_source_root: The root path where tests are located.
  33 config.test_source_root = os.path.dirname(__file__)
  34
  35 # test_exec_root: The root path where tests should be run.
  36 config.test_exec_root = os.path.join(config.llvm_obj_root, "test")
  37
  38 # Tweak the PATH to include the tools dir.
  39 llvm_config.with_environment("PATH", config.llvm_tools_dir, append_path=True)
  40
  41 # Propagate some variables from the host environment.
  42 llvm_config.with_system_environment(["HOME", "INCLUDE", "LIB", "TMP", "TEMP"])
  43
  44
  45 # Set up OCAMLPATH to include newly built OCaml libraries.
  46 top_ocaml_lib = os.path.join(config.llvm_lib_dir, "ocaml")
  47 llvm_ocaml_lib = os.path.join(top_ocaml_lib, "llvm")
  48
  49 llvm_config.with_system_environment("OCAMLPATH")
  50 llvm_config.with_environment("OCAMLPATH", top_ocaml_lib, append_path=True)
  51 llvm_config.with_environment("OCAMLPATH", llvm_ocaml_lib, append_path=True)
  52
  53 llvm_config.with_system_environment("CAML_LD_LIBRARY_PATH")
  54 llvm_config.with_environment("CAML_LD_LIBRARY_PATH", llvm_ocaml_lib, append_path=True)
  55
  56 # Set up OCAMLRUNPARAM to enable backtraces in OCaml tests.
  57 llvm_config.with_environment("OCAMLRUNPARAM", "b")
  58
  59 # Provide the path to asan runtime lib 'libclang_rt.asan_osx_dynamic.dylib' if
  60 # available. This is darwin specific since it's currently only needed on darwin.
  61
  62
  63 def get_asan_rtlib():
  64     if (
  65         not "Address" in config.llvm_use_sanitizer
  66         or not "Darwin" in config.host_os
  67         or not "x86" in config.host_triple
  68     ):
  69         return ""
  70     try:
  71         import glob
  72     except:
  73         print("glob module not found, skipping get_asan_rtlib() lookup")
  74         return ""
  75     # The libclang_rt.asan_osx_dynamic.dylib path is obtained using the relative
  76     # path from the host cc.
  77     host_lib_dir = os.path.join(os.path.dirname(config.host_cc), "../lib")
  78     asan_dylib_dir_pattern = (
  79         host_lib_dir + "/clang/*/lib/darwin/libclang_rt.asan_osx_dynamic.dylib"
  80     )
  81     found_dylibs = glob.glob(asan_dylib_dir_pattern)
  82     if len(found_dylibs) != 1:
  83         return ""
  84     return found_dylibs[0]
  85
  86
  87 llvm_config.use_default_substitutions()
  88
  89 # Add site-specific substitutions.
  90 config.substitutions.append(("%llvmshlibdir", config.llvm_shlib_dir))
  91 config.substitutions.append(("%shlibext", config.llvm_shlib_ext))
  92 config.substitutions.append(("%pluginext", config.llvm_plugin_ext))
  93 config.substitutions.append(("%exeext", config.llvm_exe_ext))
  94
  95
  96 lli_args = []
  97 # The target triple used by default by lli is the process target triple (some
  98 # triple appropriate for generating code for the current process) but because
  99 # we don't support COFF in MCJIT well enough for the tests, force ELF format on
 100 # Windows.  FIXME: the process target triple should be used here, but this is
 101 # difficult to obtain on Windows.
 102 if re.search(r"cygwin|windows-gnu|windows-msvc", config.host_triple):
 103     lli_args = ["-mtriple=" + config.host_triple + "-elf"]
 104
 105 llc_args = []
 106
 107 # Similarly, have a macro to use llc with DWARF even when the host is Windows
 108 if re.search(r"windows-msvc", config.target_triple):
 109     llc_args = [" -mtriple=" + config.target_triple.replace("-msvc", "-gnu")]
 110
 111 # Provide the path to asan runtime lib if available. On darwin, this lib needs
 112 # to be loaded via DYLD_INSERT_LIBRARIES before libLTO.dylib in case the files
 113 # to be linked contain instrumented sanitizer code.
 114 ld64_cmd = config.ld64_executable
 115 asan_rtlib = get_asan_rtlib()
 116 if asan_rtlib:
 117     ld64_cmd = "DYLD_INSERT_LIBRARIES={} {}".format(asan_rtlib, ld64_cmd)
 118 if config.osx_sysroot:
 119     ld64_cmd = "{} -syslibroot {}".format(ld64_cmd, config.osx_sysroot)
 120
 121 ocamlc_command = "%s ocamlc -cclib -L%s %s" % (
 122     config.ocamlfind_executable,
 123     config.llvm_lib_dir,
 124     config.ocaml_flags,
 125 )
 126 ocamlopt_command = "true"
 127 if config.have_ocamlopt:
 128     ocamlopt_command = "%s ocamlopt -cclib -L%s -cclib -Wl,-rpath,%s %s" % (
 129         config.ocamlfind_executable,
 130         config.llvm_lib_dir,
 131         config.llvm_lib_dir,
 132         config.ocaml_flags,
 133     )
 134
 135 opt_viewer_cmd = "%s %s/tools/opt-viewer/opt-viewer.py" % (
 136     sys.executable,
 137     config.llvm_src_root,
 138 )
 139
 140 llvm_original_di_preservation_cmd = os.path.join(
 141     config.llvm_src_root, "utils", "llvm-original-di-preservation.py"
 142 )
 143 config.substitutions.append(
 144     (
 145         "%llvm-original-di-preservation",
 146         "'%s' %s" % (config.python_executable, llvm_original_di_preservation_cmd),
 147     )
 148 )
 149
 150 llvm_locstats_tool = os.path.join(config.llvm_tools_dir, "llvm-locstats")
 151 config.substitutions.append(
 152     ("%llvm-locstats", "'%s' %s" % (config.python_executable, llvm_locstats_tool))
 153 )
 154 config.llvm_locstats_used = os.path.exists(llvm_locstats_tool)
 155
 156 tools = [
 157     ToolSubst("%llvm", FindTool("llvm"), unresolved="ignore"),
 158     ToolSubst("%lli", FindTool("lli"), post=".", extra_args=lli_args),
 159     ToolSubst("%llc_dwarf", FindTool("llc"), extra_args=llc_args),
 160     ToolSubst("%gold", config.gold_executable, unresolved="ignore"),
 161     ToolSubst("%ld64", ld64_cmd, unresolved="ignore"),
 162     ToolSubst("%ocamlc", ocamlc_command, unresolved="ignore"),
 163     ToolSubst("%ocamlopt", ocamlopt_command, unresolved="ignore"),
 164     ToolSubst("%opt-viewer", opt_viewer_cmd),
 165     ToolSubst("%llvm-objcopy", FindTool("llvm-objcopy")),
 166     ToolSubst("%llvm-strip", FindTool("llvm-strip")),
 167     ToolSubst("%llvm-install-name-tool", FindTool("llvm-install-name-tool")),
 168     ToolSubst("%llvm-bitcode-strip", FindTool("llvm-bitcode-strip")),
 169     ToolSubst("%split-file", FindTool("split-file")),
 170 ]
 171
 172 # FIXME: Why do we have both `lli` and `%lli` that do slightly different things?
 173 tools.extend(
 174     [
 175         "dsymutil",
 176         "lli",
 177         "lli-child-target",
 178         "llvm-ar",
 179         "llvm-as",
 180         "llvm-addr2line",
 181         "llvm-bcanalyzer",
 182         "llvm-bitcode-strip",
 183         "llvm-config",
 184         "llvm-cov",
 185         "llvm-cxxdump",
 186         "llvm-cvtres",
 187         "llvm-debuginfod-find",
 188         "llvm-debuginfo-analyzer",
 189         "llvm-diff",
 190         "llvm-dis",
 191         "llvm-dwarfdump",
 192         "llvm-dwarfutil",
 193         "llvm-dlltool",
 194         "llvm-exegesis",
 195         "llvm-extract",
 196         "llvm-isel-fuzzer",
 197         "llvm-ifs",
 198         "llvm-install-name-tool",
 199         "llvm-jitlink",
 200         "llvm-opt-fuzzer",
 201         "llvm-lib",
 202         "llvm-link",
 203         "llvm-lto",
 204         "llvm-lto2",
 205         "llvm-mc",
 206         "llvm-mca",
 207         "llvm-modextract",
 208         "llvm-nm",
 209         "llvm-objcopy",
 210         "llvm-objdump",
 211         "llvm-otool",
 212         "llvm-pdbutil",
 213         "llvm-profdata",
 214         "llvm-profgen",
 215         "llvm-ranlib",
 216         "llvm-rc",
 217         "llvm-readelf",
 218         "llvm-readobj",
 219         "llvm-remark-size-diff",
 220         "llvm-rtdyld",
 221         "llvm-sim",
 222         "llvm-size",
 223         "llvm-split",
 224         "llvm-stress",
 225         "llvm-strings",
 226         "llvm-strip",
 227         "llvm-tblgen",
 228         "llvm-tapi-diff",
 229         "llvm-undname",
 230         "llvm-windres",
 231         "llvm-c-test",
 232         "llvm-cxxfilt",
 233         "llvm-xray",
 234         "yaml2obj",
 235         "obj2yaml",
 236         "yaml-bench",
 237         "verify-uselistorder",
 238         "bugpoint",
 239         "llc",
 240         "llvm-symbolizer",
 241         "opt",
 242         "sancov",
 243         "sanstats",
 244         "llvm-remarkutil",
 245     ]
 246 )
 247
 248 # The following tools are optional
 249 tools.extend(
 250     [
 251         ToolSubst("llvm-mt", unresolved="ignore"),
 252         ToolSubst("llvm-debuginfod", unresolved="ignore"),
 253         ToolSubst("Kaleidoscope-Ch3", unresolved="ignore"),
 254         ToolSubst("Kaleidoscope-Ch4", unresolved="ignore"),
 255         ToolSubst("Kaleidoscope-Ch5", unresolved="ignore"),
 256         ToolSubst("Kaleidoscope-Ch6", unresolved="ignore"),
 257         ToolSubst("Kaleidoscope-Ch7", unresolved="ignore"),
 258         ToolSubst("Kaleidoscope-Ch8", unresolved="ignore"),
 259         ToolSubst("LLJITWithThinLTOSummaries", unresolved="ignore"),
 260         ToolSubst("LLJITWithRemoteDebugging", unresolved="ignore"),
 261         ToolSubst("OrcV2CBindingsBasicUsage", unresolved="ignore"),
 262         ToolSubst("OrcV2CBindingsAddObjectFile", unresolved="ignore"),
 263         ToolSubst("OrcV2CBindingsRemovableCode", unresolved="ignore"),
 264         ToolSubst("OrcV2CBindingsLazy", unresolved="ignore"),
 265         ToolSubst("OrcV2CBindingsVeryLazy", unresolved="ignore"),
 266         ToolSubst("dxil-dis", unresolved="ignore"),
 267     ]
 268 )
 269
 270 # Find (major, minor) version of ptxas
 271 def ptxas_version(ptxas):
 272     ptxas_cmd = subprocess.Popen([ptxas, "--version"], stdout=subprocess.PIPE)
 273     ptxas_out = ptxas_cmd.stdout.read().decode("ascii")
 274     ptxas_cmd.wait()
 275     match = re.search(r"release (\d+)\.(\d+)", ptxas_out)
 276     if match:
 277         return (int(match.group(1)), int(match.group(2)))
 278     print("couldn't determine ptxas version")
 279     return None
 280
 281
 282 # Enable %ptxas and %ptxas-verify tools.
 283 # %ptxas-verify defaults to sm_60 architecture. It can be overriden
 284 # by specifying required one, for instance: %ptxas-verify -arch=sm_80.
 285 def enable_ptxas(ptxas_executable):
 286     version = ptxas_version(ptxas_executable)
 287     if version:
 288         # ptxas is supposed to be backward compatible with previous
 289         # versions, so add a feature for every known version prior to
 290         # the current one.
 291         ptxas_known_versions = [
 292             (9, 0),
 293             (9, 1),
 294             (9, 2),
 295             (10, 0),
 296             (10, 1),
 297             (10, 2),
 298             (11, 0),
 299             (11, 1),
 300             (11, 2),
 301             (11, 3),
 302             (11, 4),
 303             (11, 5),
 304             (11, 6),
 305             (11, 7),
 306             (11, 8),
 307             (12, 0),
 308             (12, 1),
 309         ]
 310
 311         def version_int(ver):
 312             return ver[0] * 100 + ver[1]
 313
 314         # ignore ptxas if its version is below the minimum supported
 315         # version
 316         min_version = ptxas_known_versions[0]
 317         if version_int(version) < version_int(min_version):
 318             print(
 319                 "Warning: ptxas version {}.{} is not supported".format(
 320                     version[0], version[1]
 321                 )
 322             )
 323             return
 324
 325         for known_version in ptxas_known_versions:
 326             if version_int(known_version) <= version_int(version):
 327                 major, minor = known_version
 328                 config.available_features.add("ptxas-{}.{}".format(major, minor))
 329
 330     config.available_features.add("ptxas")
 331     tools.extend(
 332         [
 333             ToolSubst("%ptxas", ptxas_executable),
 334             ToolSubst("%ptxas-verify", "{} -arch=sm_60 -c -".format(ptxas_executable)),
 335         ]
 336     )
 337
 338
 339 ptxas_executable = (
 340     os.environ.get("LLVM_PTXAS_EXECUTABLE", None) or config.ptxas_executable
 341 )
 342 if ptxas_executable:
 343     enable_ptxas(ptxas_executable)
 344
 345 llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 346
 347 # Targets
 348
 349 config.targets = frozenset(config.targets_to_build.split())
 350
 351 for arch in config.targets_to_build.split():
 352     config.available_features.add(arch.lower() + "-registered-target")
 353
 354 # Features
 355 known_arches = ["x86_64", "mips64", "ppc64", "aarch64"]
 356 if config.host_ldflags.find("-m32") < 0 and any(
 357     config.llvm_host_triple.startswith(x) for x in known_arches
 358 ):
 359     config.available_features.add("llvm-64-bits")
 360
 361 config.available_features.add("host-byteorder-" + sys.byteorder + "-endian")
 362
 363 if sys.platform in ["win32"]:
 364     # ExecutionEngine, no weak symbols in COFF.
 365     config.available_features.add("uses_COFF")
 366 else:
 367     # Others/can-execute.txt
 368     config.available_features.add("can-execute")
 369
 370 # Loadable module
 371 if config.has_plugins:
 372     config.available_features.add("plugins")
 373
 374 if config.build_examples:
 375     config.available_features.add("examples")
 376
 377 if config.linked_bye_extension:
 378     config.substitutions.append(("%llvmcheckext", "CHECK-EXT"))
 379     config.substitutions.append(("%loadbye", ""))
 380     config.substitutions.append(("%loadnewpmbye", ""))
 381 else:
 382     config.substitutions.append(("%llvmcheckext", "CHECK-NOEXT"))
 383     config.substitutions.append(
 384         (
 385             "%loadbye",
 386             "-load={}/Bye{}".format(config.llvm_shlib_dir, config.llvm_shlib_ext),
 387         )
 388     )
 389     config.substitutions.append(
 390         (
 391             "%loadnewpmbye",
 392             "-load-pass-plugin={}/Bye{}".format(
 393                 config.llvm_shlib_dir, config.llvm_shlib_ext
 394             ),
 395         )
 396     )
 397
 398 if config.linked_exampleirtransforms_extension:
 399     config.substitutions.append(("%loadexampleirtransforms", ""))
 400 else:
 401     config.substitutions.append(
 402         (
 403             "%loadexampleirtransforms",
 404             "-load-pass-plugin={}/ExampleIRTransforms{}".format(
 405                 config.llvm_shlib_dir, config.llvm_shlib_ext
 406             ),
 407         )
 408     )
 409
 410 # Static libraries are not built if BUILD_SHARED_LIBS is ON.
 411 if not config.build_shared_libs and not config.link_llvm_dylib:
 412     config.available_features.add("static-libs")
 413
 414 if config.link_llvm_dylib:
 415     config.available_features.add("llvm-dylib")
 416     config.substitutions.append(
 417         (
 418             "%llvmdylib",
 419             "{}/libLLVM-{}{}".format(
 420                 config.llvm_shlib_dir, config.llvm_dylib_version, config.llvm_shlib_ext
 421             ),
 422         )
 423     )
 424
 425 if config.have_tf_aot:
 426     config.available_features.add("have_tf_aot")
 427
 428 if config.have_tflite:
 429     config.available_features.add("have_tflite")
 430
 431 if config.llvm_inliner_model_autogenerated:
 432     config.available_features.add("llvm_inliner_model_autogenerated")
 433
 434 if config.llvm_raevict_model_autogenerated:
 435     config.available_features.add("llvm_raevict_model_autogenerated")
 436
 437
 438 def have_cxx_shared_library():
 439     readobj_exe = lit.util.which("llvm-readobj", config.llvm_tools_dir)
 440     if not readobj_exe:
 441         print("llvm-readobj not found")
 442         return False
 443
 444     try:
 445         readobj_cmd = subprocess.Popen(
 446             [readobj_exe, "--needed-libs", readobj_exe], stdout=subprocess.PIPE
 447         )
 448     except OSError:
 449         print("could not exec llvm-readobj")
 450         return False
 451
 452     readobj_out = readobj_cmd.stdout.read().decode("ascii")
 453     readobj_cmd.wait()
 454
 455     regex = re.compile(r"(libc\+\+|libstdc\+\+|msvcp).*\.(so|dylib|dll)")
 456     needed_libs = False
 457     for line in readobj_out.splitlines():
 458         if "NeededLibraries [" in line:
 459             needed_libs = True
 460         if "]" in line:
 461             needed_libs = False
 462         if needed_libs and regex.search(line.lower()):
 463             return True
 464     return False
 465
 466
 467 if have_cxx_shared_library():
 468     config.available_features.add("cxx-shared-library")
 469
 470 if config.libcxx_used:
 471     config.available_features.add("libcxx-used")
 472
 473 # LLVM can be configured with an empty default triple
 474 # Some tests are "generic" and require a valid default triple
 475 if config.target_triple:
 476     config.available_features.add("default_triple")
 477     # Direct object generation
 478     if not config.target_triple.startswith(("nvptx", "xcore")):
 479         config.available_features.add("object-emission")
 480
 481 # Allow checking for specific details in the host triple
 482 if config.host_triple:
 483     config.available_features.add('host=%s' % config.host_triple)
 484
 485 if config.have_llvm_driver:
 486     config.available_features.add("llvm-driver")
 487
 488 import subprocess
 489
 490
 491 def have_ld_plugin_support():
 492     if not os.path.exists(
 493         os.path.join(config.llvm_shlib_dir, "LLVMgold" + config.llvm_shlib_ext)
 494     ):
 495         return False
 496
 497     ld_cmd = subprocess.Popen(
 498         [config.gold_executable, "--help"], stdout=subprocess.PIPE, env={"LANG": "C"}
 499     )
 500     ld_out = ld_cmd.stdout.read().decode()
 501     ld_cmd.wait()
 502
 503     if not "-plugin" in ld_out:
 504         return False
 505
 506     # check that the used emulations are supported.
 507     emu_line = [l for l in ld_out.split("\n") if "supported emulations" in l]
 508     if len(emu_line) != 1:
 509         return False
 510     emu_line = emu_line[0]
 511     fields = emu_line.split(":")
 512     if len(fields) != 3:
 513         return False
 514     emulations = fields[2].split()
 515     if "elf_x86_64" not in emulations:
 516         return False
 517     if "elf32ppc" in emulations:
 518         config.available_features.add("ld_emu_elf32ppc")
 519
 520     ld_version = subprocess.Popen(
 521         [config.gold_executable, "--version"], stdout=subprocess.PIPE, env={"LANG": "C"}
 522     )
 523     if not "GNU gold" in ld_version.stdout.read().decode():
 524         return False
 525     ld_version.wait()
 526
 527     return True
 528
 529
 530 if have_ld_plugin_support():
 531     config.available_features.add("ld_plugin")
 532
 533
 534 def have_ld64_plugin_support():
 535     if not os.path.exists(
 536         os.path.join(config.llvm_shlib_dir, "libLTO" + config.llvm_shlib_ext)
 537     ):
 538         return False
 539
 540     if config.ld64_executable == "":
 541         return False
 542
 543     ld_cmd = subprocess.Popen([config.ld64_executable, "-v"], stderr=subprocess.PIPE)
 544     ld_out = ld_cmd.stderr.read().decode()
 545     ld_cmd.wait()
 546
 547     if "ld64" not in ld_out or "LTO" not in ld_out:
 548         return False
 549
 550     return True
 551
 552
 553 if have_ld64_plugin_support():
 554     config.available_features.add("ld64_plugin")
 555
 556 # Ask llvm-config about asserts
 557 llvm_config.feature_config(
 558     [
 559         ("--assertion-mode", {"ON": "asserts"}),
 560         ("--build-mode", {"[Dd][Ee][Bb][Uu][Gg]": "debug"}),
 561     ]
 562 )
 563
 564 if "darwin" == sys.platform:
 565     cmd = ["sysctl", "hw.optional.fma"]
 566     sysctl_cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 567
 568     # Non zero return, probably a permission issue
 569     if sysctl_cmd.wait():
 570         print(
 571             'Warning: sysctl exists but calling "{}" failed, defaulting to no fma3.'.format(
 572                 " ".join(cmd)
 573             )
 574         )
 575     else:
 576         result = sysctl_cmd.stdout.read().decode("ascii")
 577         if "hw.optional.fma: 1" in result:
 578             config.available_features.add("fma3")
 579
 580 # .debug_frame is not emitted for targeting Windows x64, aarch64/arm64, AIX, or Apple Silicon Mac.
 581 if not re.match(
 582     r"^(x86_64|aarch64|arm64|powerpc|powerpc64).*-(windows-gnu|windows-msvc|aix)",
 583     config.target_triple,
 584 ) and not re.match(r"^arm64(e)?-apple-(macos|darwin)", config.target_triple):
 585     config.available_features.add("debug_frame")
 586
 587 if config.have_libxar:
 588     config.available_features.add("xar")
 589
 590 if config.enable_threads:
 591     config.available_features.add("thread_support")
 592
 593 if config.have_libxml2:
 594     config.available_features.add("libxml2")
 595
 596 if config.have_curl:
 597     config.available_features.add("curl")
 598
 599 if config.have_httplib:
 600     config.available_features.add("httplib")
 601
 602 if config.have_opt_viewer_modules:
 603     config.available_features.add("have_opt_viewer_modules")
 604
 605 if config.expensive_checks:
 606     config.available_features.add("expensive_checks")
 607
 608 if "MemoryWithOrigins" in config.llvm_use_sanitizer:
 609     config.available_features.add("use_msan_with_origins")
 610
 611
 612 def exclude_unsupported_files_for_aix(dirname):
 613     for filename in os.listdir(dirname):
 614         source_path = os.path.join(dirname, filename)
 615         if os.path.isdir(source_path):
 616             continue
 617         f = open(source_path, "r")
 618         try:
 619             data = f.read()
 620             # 64-bit object files are not supported on AIX, so exclude the tests.
 621             if (
 622                 "-emit-obj" in data or "-filetype=obj" in data
 623             ) and "64" in config.target_triple:
 624                 config.excludes += [filename]
 625         finally:
 626             f.close()
 627
 628
 629 if "aix" in config.target_triple:
 630     for directory in (
 631         "/CodeGen/X86",
 632         "/DebugInfo",
 633         "/DebugInfo/X86",
 634         "/DebugInfo/Generic",
 635         "/LTO/X86",
 636         "/Linker",
 637     ):
 638         exclude_unsupported_files_for_aix(config.test_source_root + directory)
 639
 640 # Some tools support an environment variable "OBJECT_MODE" on AIX OS, which
 641 # controls the kind of objects they will support. If there is no "OBJECT_MODE"
 642 # environment variable specified, the default behaviour is to support 32-bit
 643 # objects only. In order to not affect most test cases, which expect to support
 644 # 32-bit and 64-bit objects by default, set the environment variable
 645 # "OBJECT_MODE" to 'any' by default on AIX OS.
 646 if "system-aix" in config.available_features:
 647     config.environment["OBJECT_MODE"] = "any"