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-dwp",
 194         "llvm-dlltool",
 195         "llvm-exegesis",
 196         "llvm-extract",
 197         "llvm-isel-fuzzer",
 198         "llvm-ifs",
 199         "llvm-install-name-tool",
 200         "llvm-jitlink",
 201         "llvm-opt-fuzzer",
 202         "llvm-lib",
 203         "llvm-link",
 204         "llvm-lto",
 205         "llvm-lto2",
 206         "llvm-mc",
 207         "llvm-mca",
 208         "llvm-modextract",
 209         "llvm-nm",
 210         "llvm-objcopy",
 211         "llvm-objdump",
 212         "llvm-otool",
 213         "llvm-pdbutil",
 214         "llvm-profdata",
 215         "llvm-profgen",
 216         "llvm-ranlib",
 217         "llvm-rc",
 218         "llvm-readelf",
 219         "llvm-readobj",
 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-readtapi",
 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             (12, 2),
 310             (12, 3),
 311             (12, 4),
 312         ]
 313
 314         def version_int(ver):
 315             return ver[0] * 100 + ver[1]
 316
 317         # ignore ptxas if its version is below the minimum supported
 318         # version
 319         min_version = ptxas_known_versions[0]
 320         if version_int(version) < version_int(min_version):
 321             print(
 322                 "Warning: ptxas version {}.{} is not supported".format(
 323                     version[0], version[1]
 324                 )
 325             )
 326             return
 327
 328         for known_version in ptxas_known_versions:
 329             if version_int(known_version) <= version_int(version):
 330                 major, minor = known_version
 331                 config.available_features.add("ptxas-{}.{}".format(major, minor))
 332
 333     config.available_features.add("ptxas")
 334     tools.extend(
 335         [
 336             ToolSubst("%ptxas", ptxas_executable),
 337             ToolSubst("%ptxas-verify", "{} -arch=sm_60 -c -".format(ptxas_executable)),
 338         ]
 339     )
 340
 341
 342 ptxas_executable = (
 343     os.environ.get("LLVM_PTXAS_EXECUTABLE", None) or config.ptxas_executable
 344 )
 345 if ptxas_executable:
 346     enable_ptxas(ptxas_executable)
 347
 348 llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 349
 350 # Targets
 351
 352 config.targets = frozenset(config.targets_to_build.split())
 353
 354 for arch in config.targets_to_build.split():
 355     config.available_features.add(arch.lower() + "-registered-target")
 356
 357 # Features
 358 known_arches = ["x86_64", "mips64", "ppc64", "aarch64"]
 359 if config.host_ldflags.find("-m32") < 0 and any(
 360     config.llvm_host_triple.startswith(x) for x in known_arches
 361 ):
 362     config.available_features.add("llvm-64-bits")
 363
 364 config.available_features.add("host-byteorder-" + sys.byteorder + "-endian")
 365
 366 if sys.platform in ["win32"]:
 367     # ExecutionEngine, no weak symbols in COFF.
 368     config.available_features.add("uses_COFF")
 369 else:
 370     # Others/can-execute.txt
 371     config.available_features.add("can-execute")
 372
 373 # Loadable module
 374 if config.has_plugins:
 375     config.available_features.add("plugins")
 376
 377 if config.build_examples:
 378     config.available_features.add("examples")
 379
 380 if config.linked_bye_extension:
 381     config.substitutions.append(("%llvmcheckext", "CHECK-EXT"))
 382     config.substitutions.append(("%loadbye", ""))
 383     config.substitutions.append(("%loadnewpmbye", ""))
 384 else:
 385     config.substitutions.append(("%llvmcheckext", "CHECK-NOEXT"))
 386     config.substitutions.append(
 387         (
 388             "%loadbye",
 389             "-load={}/Bye{}".format(config.llvm_shlib_dir, config.llvm_shlib_ext),
 390         )
 391     )
 392     config.substitutions.append(
 393         (
 394             "%loadnewpmbye",
 395             "-load-pass-plugin={}/Bye{}".format(
 396                 config.llvm_shlib_dir, config.llvm_shlib_ext
 397             ),
 398         )
 399     )
 400
 401 if config.linked_exampleirtransforms_extension:
 402     config.substitutions.append(("%loadexampleirtransforms", ""))
 403 else:
 404     config.substitutions.append(
 405         (
 406             "%loadexampleirtransforms",
 407             "-load-pass-plugin={}/ExampleIRTransforms{}".format(
 408                 config.llvm_shlib_dir, config.llvm_shlib_ext
 409             ),
 410         )
 411     )
 412
 413 # Static libraries are not built if BUILD_SHARED_LIBS is ON.
 414 if not config.build_shared_libs and not config.link_llvm_dylib:
 415     config.available_features.add("static-libs")
 416
 417 if config.link_llvm_dylib:
 418     config.available_features.add("llvm-dylib")
 419     config.substitutions.append(
 420         (
 421             # libLLVM.so.19.0git
 422             "%llvmdylib",
 423             "{}/libLLVM{}.{}".format(
 424                 config.llvm_shlib_dir, config.llvm_shlib_ext, config.llvm_dylib_version
 425             )
 426         )
 427     )
 428
 429 if config.have_tf_aot:
 430     config.available_features.add("have_tf_aot")
 431
 432 if config.have_tflite:
 433     config.available_features.add("have_tflite")
 434
 435 if config.llvm_inliner_model_autogenerated:
 436     config.available_features.add("llvm_inliner_model_autogenerated")
 437
 438 if config.llvm_raevict_model_autogenerated:
 439     config.available_features.add("llvm_raevict_model_autogenerated")
 440
 441
 442 def have_cxx_shared_library():
 443     readobj_exe = lit.util.which("llvm-readobj", config.llvm_tools_dir)
 444     if not readobj_exe:
 445         print("llvm-readobj not found")
 446         return False
 447
 448     try:
 449         readobj_cmd = subprocess.Popen(
 450             [readobj_exe, "--needed-libs", readobj_exe], stdout=subprocess.PIPE
 451         )
 452     except OSError:
 453         print("could not exec llvm-readobj")
 454         return False
 455
 456     readobj_out = readobj_cmd.stdout.read().decode("ascii")
 457     readobj_cmd.wait()
 458
 459     regex = re.compile(r"(libc\+\+|libstdc\+\+|msvcp).*\.(so|dylib|dll)")
 460     needed_libs = False
 461     for line in readobj_out.splitlines():
 462         if "NeededLibraries [" in line:
 463             needed_libs = True
 464         if "]" in line:
 465             needed_libs = False
 466         if needed_libs and regex.search(line.lower()):
 467             return True
 468     return False
 469
 470
 471 if have_cxx_shared_library():
 472     config.available_features.add("cxx-shared-library")
 473
 474 if config.libcxx_used:
 475     config.available_features.add("libcxx-used")
 476
 477 # LLVM can be configured with an empty default triple
 478 # Some tests are "generic" and require a valid default triple
 479 if config.target_triple:
 480     config.available_features.add("default_triple")
 481     # Direct object generation
 482     if not config.target_triple.startswith(("nvptx", "xcore")):
 483         config.available_features.add("object-emission")
 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 if not hasattr(sys, "getwindowsversion") or sys.getwindowsversion().build >= 17063:
 581     config.available_features.add("unix-sockets")
 582
 583 # .debug_frame is not emitted for targeting Windows x64, aarch64/arm64, AIX, or Apple Silicon Mac.
 584 if not re.match(
 585     r"^(x86_64|aarch64|arm64|powerpc|powerpc64).*-(windows-gnu|windows-msvc|aix)",
 586     config.target_triple,
 587 ) and not re.match(r"^arm64(e)?-apple-(macos|darwin)", config.target_triple):
 588     config.available_features.add("debug_frame")
 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 # Some tools support an environment variable "OBJECT_MODE" on AIX OS, which
 613 # controls the kind of objects they will support. If there is no "OBJECT_MODE"
 614 # environment variable specified, the default behaviour is to support 32-bit
 615 # objects only. In order to not affect most test cases, which expect to support
 616 # 32-bit and 64-bit objects by default, set the environment variable
 617 # "OBJECT_MODE" to 'any' by default on AIX OS.
 618 if "system-aix" in config.available_features:
 619     config.environment["OBJECT_MODE"] = "any"
 620
 621 if config.has_logf128:
 622     config.available_features.add("has_logf128")