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-rtdyld",
 220         "llvm-sim",
 221         "llvm-size",
 222         "llvm-split",
 223         "llvm-stress",
 224         "llvm-strings",
 225         "llvm-strip",
 226         "llvm-tblgen",
 227         "llvm-readtapi",
 228         "llvm-undname",
 229         "llvm-windres",
 230         "llvm-c-test",
 231         "llvm-cxxfilt",
 232         "llvm-xray",
 233         "yaml2obj",
 234         "obj2yaml",
 235         "yaml-bench",
 236         "verify-uselistorder",
 237         "bugpoint",
 238         "llc",
 239         "llvm-symbolizer",
 240         "opt",
 241         "sancov",
 242         "sanstats",
 243         "llvm-remarkutil",
 244     ]
 245 )
 246
 247 # The following tools are optional
 248 tools.extend(
 249     [
 250         ToolSubst("llvm-mt", unresolved="ignore"),
 251         ToolSubst("llvm-debuginfod", unresolved="ignore"),
 252         ToolSubst("Kaleidoscope-Ch3", unresolved="ignore"),
 253         ToolSubst("Kaleidoscope-Ch4", unresolved="ignore"),
 254         ToolSubst("Kaleidoscope-Ch5", unresolved="ignore"),
 255         ToolSubst("Kaleidoscope-Ch6", unresolved="ignore"),
 256         ToolSubst("Kaleidoscope-Ch7", unresolved="ignore"),
 257         ToolSubst("Kaleidoscope-Ch8", unresolved="ignore"),
 258         ToolSubst("LLJITWithThinLTOSummaries", unresolved="ignore"),
 259         ToolSubst("LLJITWithRemoteDebugging", unresolved="ignore"),
 260         ToolSubst("OrcV2CBindingsBasicUsage", unresolved="ignore"),
 261         ToolSubst("OrcV2CBindingsAddObjectFile", unresolved="ignore"),
 262         ToolSubst("OrcV2CBindingsRemovableCode", unresolved="ignore"),
 263         ToolSubst("OrcV2CBindingsLazy", unresolved="ignore"),
 264         ToolSubst("OrcV2CBindingsVeryLazy", unresolved="ignore"),
 265         ToolSubst("dxil-dis", unresolved="ignore"),
 266     ]
 267 )
 268
 269 # Find (major, minor) version of ptxas
 270 def ptxas_version(ptxas):
 271     ptxas_cmd = subprocess.Popen([ptxas, "--version"], stdout=subprocess.PIPE)
 272     ptxas_out = ptxas_cmd.stdout.read().decode("ascii")
 273     ptxas_cmd.wait()
 274     match = re.search("release (\d+)\.(\d+)", ptxas_out)
 275     if match:
 276         return (int(match.group(1)), int(match.group(2)))
 277     print("couldn't determine ptxas version")
 278     return None
 279
 280
 281 # Enable %ptxas and %ptxas-verify tools.
 282 # %ptxas-verify defaults to sm_60 architecture. It can be overriden
 283 # by specifying required one, for instance: %ptxas-verify -arch=sm_80.
 284 def enable_ptxas(ptxas_executable):
 285     version = ptxas_version(ptxas_executable)
 286     if version:
 287         # ptxas is supposed to be backward compatible with previous
 288         # versions, so add a feature for every known version prior to
 289         # the current one.
 290         ptxas_known_versions = [
 291             (9, 0),
 292             (9, 1),
 293             (9, 2),
 294             (10, 0),
 295             (10, 1),
 296             (10, 2),
 297             (11, 0),
 298             (11, 1),
 299             (11, 2),
 300             (11, 3),
 301             (11, 4),
 302             (11, 5),
 303             (11, 6),
 304             (11, 7),
 305             (11, 8),
 306             (12, 0),
 307             (12, 1),
 308         ]
 309
 310         def version_int(ver):
 311             return ver[0] * 100 + ver[1]
 312
 313         # ignore ptxas if its version is below the minimum supported
 314         # version
 315         min_version = ptxas_known_versions[0]
 316         if version_int(version) < version_int(min_version):
 317             print(
 318                 "Warning: ptxas version {}.{} is not supported".format(
 319                     version[0], version[1]
 320                 )
 321             )
 322             return
 323
 324         for known_version in ptxas_known_versions:
 325             if version_int(known_version) <= version_int(version):
 326                 major, minor = known_version
 327                 config.available_features.add("ptxas-{}.{}".format(major, minor))
 328
 329     config.available_features.add("ptxas")
 330     tools.extend(
 331         [
 332             ToolSubst("%ptxas", ptxas_executable),
 333             ToolSubst("%ptxas-verify", "{} -arch=sm_60 -c -".format(ptxas_executable)),
 334         ]
 335     )
 336
 337
 338 ptxas_executable = (
 339     os.environ.get("LLVM_PTXAS_EXECUTABLE", None) or config.ptxas_executable
 340 )
 341 if ptxas_executable:
 342     enable_ptxas(ptxas_executable)
 343
 344 llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 345
 346 # Targets
 347
 348 config.targets = frozenset(config.targets_to_build.split())
 349
 350 for arch in config.targets_to_build.split():
 351     config.available_features.add(arch.lower() + "-registered-target")
 352
 353 # Features
 354 known_arches = ["x86_64", "mips64", "ppc64", "aarch64"]
 355 if config.host_ldflags.find("-m32") < 0 and any(
 356     config.llvm_host_triple.startswith(x) for x in known_arches
 357 ):
 358     config.available_features.add("llvm-64-bits")
 359
 360 config.available_features.add("host-byteorder-" + sys.byteorder + "-endian")
 361
 362 if sys.platform in ["win32"]:
 363     # ExecutionEngine, no weak symbols in COFF.
 364     config.available_features.add("uses_COFF")
 365 else:
 366     # Others/can-execute.txt
 367     config.available_features.add("can-execute")
 368
 369 # Loadable module
 370 if config.has_plugins:
 371     config.available_features.add("plugins")
 372
 373 if config.build_examples:
 374     config.available_features.add("examples")
 375
 376 if config.linked_bye_extension:
 377     config.substitutions.append(("%llvmcheckext", "CHECK-EXT"))
 378     config.substitutions.append(("%loadbye", ""))
 379     config.substitutions.append(("%loadnewpmbye", ""))
 380 else:
 381     config.substitutions.append(("%llvmcheckext", "CHECK-NOEXT"))
 382     config.substitutions.append(
 383         (
 384             "%loadbye",
 385             "-load={}/Bye{}".format(config.llvm_shlib_dir, config.llvm_shlib_ext),
 386         )
 387     )
 388     config.substitutions.append(
 389         (
 390             "%loadnewpmbye",
 391             "-load-pass-plugin={}/Bye{}".format(
 392                 config.llvm_shlib_dir, config.llvm_shlib_ext
 393             ),
 394         )
 395     )
 396
 397 if config.linked_exampleirtransforms_extension:
 398     config.substitutions.append(("%loadexampleirtransforms", ""))
 399 else:
 400     config.substitutions.append(
 401         (
 402             "%loadexampleirtransforms",
 403             "-load-pass-plugin={}/ExampleIRTransforms{}".format(
 404                 config.llvm_shlib_dir, config.llvm_shlib_ext
 405             ),
 406         )
 407     )
 408
 409 # Static libraries are not built if BUILD_SHARED_LIBS is ON.
 410 if not config.build_shared_libs and not config.link_llvm_dylib:
 411     config.available_features.add("static-libs")
 412
 413 if config.link_llvm_dylib:
 414     config.available_features.add("llvm-dylib")
 415     config.substitutions.append(
 416         (
 417             "%llvmdylib",
 418             "{}/libLLVM-{}{}".format(
 419                 config.llvm_shlib_dir, config.llvm_dylib_version, config.llvm_shlib_ext
 420             ),
 421         )
 422     )
 423
 424 if config.have_tf_aot:
 425     config.available_features.add("have_tf_aot")
 426
 427 if config.have_tflite:
 428     config.available_features.add("have_tflite")
 429
 430 if config.llvm_inliner_model_autogenerated:
 431     config.available_features.add("llvm_inliner_model_autogenerated")
 432
 433 if config.llvm_raevict_model_autogenerated:
 434     config.available_features.add("llvm_raevict_model_autogenerated")
 435
 436
 437 def have_cxx_shared_library():
 438     readobj_exe = lit.util.which("llvm-readobj", config.llvm_tools_dir)
 439     if not readobj_exe:
 440         print("llvm-readobj not found")
 441         return False
 442
 443     try:
 444         readobj_cmd = subprocess.Popen(
 445             [readobj_exe, "--needed-libs", readobj_exe], stdout=subprocess.PIPE
 446         )
 447     except OSError:
 448         print("could not exec llvm-readobj")
 449         return False
 450
 451     readobj_out = readobj_cmd.stdout.read().decode("ascii")
 452     readobj_cmd.wait()
 453
 454     regex = re.compile(r"(libc\+\+|libstdc\+\+|msvcp).*\.(so|dylib|dll)")
 455     needed_libs = False
 456     for line in readobj_out.splitlines():
 457         if "NeededLibraries [" in line:
 458             needed_libs = True
 459         if "]" in line:
 460             needed_libs = False
 461         if needed_libs and regex.search(line.lower()):
 462             return True
 463     return False
 464
 465
 466 if have_cxx_shared_library():
 467     config.available_features.add("cxx-shared-library")
 468
 469 if config.libcxx_used:
 470     config.available_features.add("libcxx-used")
 471
 472 # LLVM can be configured with an empty default triple
 473 # Some tests are "generic" and require a valid default triple
 474 if config.target_triple:
 475     config.available_features.add("default_triple")
 476     # Direct object generation
 477     if not config.target_triple.startswith(("nvptx", "xcore")):
 478         config.available_features.add("object-emission")
 479
 480 # Allow checking for specific details in the host triple
 481 if config.host_triple:
 482     config.available_features.add('host=%s' % config.host_triple)
 483
 484 if config.have_llvm_driver:
 485     config.available_features.add("llvm-driver")
 486
 487 import subprocess
 488
 489
 490 def have_ld_plugin_support():
 491     if not os.path.exists(
 492         os.path.join(config.llvm_shlib_dir, "LLVMgold" + config.llvm_shlib_ext)
 493     ):
 494         return False
 495
 496     ld_cmd = subprocess.Popen(
 497         [config.gold_executable, "--help"], stdout=subprocess.PIPE, env={"LANG": "C"}
 498     )
 499     ld_out = ld_cmd.stdout.read().decode()
 500     ld_cmd.wait()
 501
 502     if not "-plugin" in ld_out:
 503         return False
 504
 505     # check that the used emulations are supported.
 506     emu_line = [l for l in ld_out.split("\n") if "supported emulations" in l]
 507     if len(emu_line) != 1:
 508         return False
 509     emu_line = emu_line[0]
 510     fields = emu_line.split(":")
 511     if len(fields) != 3:
 512         return False
 513     emulations = fields[2].split()
 514     if "elf_x86_64" not in emulations:
 515         return False
 516     if "elf32ppc" in emulations:
 517         config.available_features.add("ld_emu_elf32ppc")
 518
 519     ld_version = subprocess.Popen(
 520         [config.gold_executable, "--version"], stdout=subprocess.PIPE, env={"LANG": "C"}
 521     )
 522     if not "GNU gold" in ld_version.stdout.read().decode():
 523         return False
 524     ld_version.wait()
 525
 526     return True
 527
 528
 529 if have_ld_plugin_support():
 530     config.available_features.add("ld_plugin")
 531
 532
 533 def have_ld64_plugin_support():
 534     if not os.path.exists(
 535         os.path.join(config.llvm_shlib_dir, "libLTO" + config.llvm_shlib_ext)
 536     ):
 537         return False
 538
 539     if config.ld64_executable == "":
 540         return False
 541
 542     ld_cmd = subprocess.Popen([config.ld64_executable, "-v"], stderr=subprocess.PIPE)
 543     ld_out = ld_cmd.stderr.read().decode()
 544     ld_cmd.wait()
 545
 546     if "ld64" not in ld_out or "LTO" not in ld_out:
 547         return False
 548
 549     return True
 550
 551
 552 if have_ld64_plugin_support():
 553     config.available_features.add("ld64_plugin")
 554
 555 # Ask llvm-config about asserts
 556 llvm_config.feature_config(
 557     [
 558         ("--assertion-mode", {"ON": "asserts"}),
 559         ("--build-mode", {"[Dd][Ee][Bb][Uu][Gg]": "debug"}),
 560     ]
 561 )
 562
 563 if "darwin" == sys.platform:
 564     cmd = ["sysctl", "hw.optional.fma"]
 565     sysctl_cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 566
 567     # Non zero return, probably a permission issue
 568     if sysctl_cmd.wait():
 569         print(
 570             'Warning: sysctl exists but calling "{}" failed, defaulting to no fma3.'.format(
 571                 " ".join(cmd)
 572             )
 573         )
 574     else:
 575         result = sysctl_cmd.stdout.read().decode("ascii")
 576         if "hw.optional.fma: 1" in result:
 577             config.available_features.add("fma3")
 578
 579 # .debug_frame is not emitted for targeting Windows x64, aarch64/arm64, AIX, or Apple Silicon Mac.
 580 if not re.match(
 581     r"^(x86_64|aarch64|arm64|powerpc|powerpc64).*-(windows-gnu|windows-msvc|aix)",
 582     config.target_triple,
 583 ) and not re.match(r"^arm64(e)?-apple-(macos|darwin)", config.target_triple):
 584     config.available_features.add("debug_frame")
 585
 586 if config.have_libxar:
 587     config.available_features.add("xar")
 588
 589 if config.enable_threads:
 590     config.available_features.add("thread_support")
 591
 592 if config.have_libxml2:
 593     config.available_features.add("libxml2")
 594
 595 if config.have_curl:
 596     config.available_features.add("curl")
 597
 598 if config.have_httplib:
 599     config.available_features.add("httplib")
 600
 601 if config.have_opt_viewer_modules:
 602     config.available_features.add("have_opt_viewer_modules")
 603
 604 if config.expensive_checks:
 605     config.available_features.add("expensive_checks")
 606
 607 if "MemoryWithOrigins" in config.llvm_use_sanitizer:
 608     config.available_features.add("use_msan_with_origins")
 609
 610
 611 def exclude_unsupported_files_for_aix(dirname):
 612     for filename in os.listdir(dirname):
 613         source_path = os.path.join(dirname, filename)
 614         if os.path.isdir(source_path):
 615             continue
 616         f = open(source_path, "r")
 617         try:
 618             data = f.read()
 619             # 64-bit object files are not supported on AIX, so exclude the tests.
 620             if (
 621                 "-emit-obj" in data or "-filetype=obj" in data
 622             ) and "64" in config.target_triple:
 623                 config.excludes += [filename]
 624         finally:
 625             f.close()
 626
 627
 628 if "aix" in config.target_triple:
 629     for directory in (
 630         "/CodeGen/X86",
 631         "/DebugInfo",
 632         "/DebugInfo/X86",
 633         "/DebugInfo/Generic",
 634         "/LTO/X86",
 635         "/Linker",
 636     ):
 637         exclude_unsupported_files_for_aix(config.test_source_root + directory)
 638
 639 # Some tools support an environment variable "OBJECT_MODE" on AIX OS, which
 640 # controls the kind of objects they will support. If there is no "OBJECT_MODE"
 641 # environment variable specified, the default behaviour is to support 32-bit
 642 # objects only. In order to not affect most test cases, which expect to support
 643 # 32-bit and 64-bit objects by default, set the environment variable
 644 # "OBJECT_MODE" to 'any' by default on AIX OS.
 645 if "system-aix" in config.available_features:
 646     config.environment["OBJECT_MODE"] = "any"