[MLIR] Make MLIR cmake variable names consistent

[bondhugula]

Summary

Fix inconsistent MLIR CMake variable names. Consistently name them as
MLIR_ENABLE_<feature>.

Eg: MLIR_CUDA_RUNNER_ENABLED -> MLIR_ENABLE_CUDA_RUNNER

MLIR follows (or has mostly followed) the convention of naming
cmake enabling variables in the from MLIR_ENABLE_... etc. Using a
convention here is easy and also important for convenience. A counter
pattern was started with variables named MLIR_..._ENABLED. This led to a
sequence of related counter patterns: MLIR_CUDA_RUNNER_ENABLED,
MLIR_ROCM_RUNNER_ENABLED, etc.. From a naming standpoint, the imperative
form is more meaningful. Additional discussion at:
https://llvm.discourse.group/t/mlir-cmake-enable-variable-naming-convention/3520

Switch all inconsistent ones to the ENABLE form. Keep the couple of old
mappings needed until buildbot config is migrated.

[bondhugula]

Simplify cmake var check.

[stellaraccident]

mlir/CMakeLists.txt

123

I don't think this will actually override the cached setting. I think the more robust idiom is to move this above Ave use it to define a MLIR_ENABLE_BINDINGS_PYTHON_DEFAULT. And use that as the default value for the new cache variable.

There are some examples of this idiom in the root llvm cmake file.

[bondhugula]

Address review comments.

mlir/CMakeLists.txt

123

Thanks. A normal CMake variable actually hides any cache variables, but it isn't good practice to have a normal and cache variable with the same name. https://cmake.org/cmake/help/v3.0/command/set.html#set
I've now fixed it I believe in the way you are recommending.

[stellaraccident]

mlir/CMakeLists.txt

123

Thanks, and yes, I've washed a bunch of time with the shadowing in the past and try to avoid it.

mlir/CMakeLists.txt

 add_custom_target(mlir-headers)
 set_target_properties(mlir-headers PROPERTIES FOLDER "Misc")
 add_dependencies(mlir-headers mlir-generic-headers)
 add_custom_target(mlir-doc)
 
 # Build the CUDA conversions and run according tests if the NVPTX backend
 # is available
 if ("NVPTX" IN_LIST LLVM_TARGETS_TO_BUILD)
-  set(MLIR_CUDA_CONVERSIONS_ENABLED 1)
+  set(MLIR_ENABLE_CUDA_CONVERSIONS 1)
 else()
-  set(MLIR_CUDA_CONVERSIONS_ENABLED 0)
+  set(MLIR_ENABLE_CUDA_CONVERSIONS 0)
 endif()
 # TODO: we should use a config.h file like LLVM does
-add_definitions(-DMLIR_CUDA_CONVERSIONS_ENABLED=${MLIR_CUDA_CONVERSIONS_ENABLED})
+add_definitions(-DMLIR_CUDA_CONVERSIONS_ENABLED=${MLIR_ENABLE_CUDA_CONVERSIONS})
 
 # Build the ROCm conversions and run according tests if the AMDGPU backend
 # is available
 if ("AMDGPU" IN_LIST LLVM_TARGETS_TO_BUILD)
-  set(MLIR_ROCM_CONVERSIONS_ENABLED 1)
+  set(MLIR_ENABLE_ROCM_CONVERSIONS 1)
 else()
-  set(MLIR_ROCM_CONVERSIONS_ENABLED 0)
+  set(MLIR_ENABLE_ROCM_CONVERSIONS 0)
 endif()
-add_definitions(-DMLIR_ROCM_CONVERSIONS_ENABLED=${MLIR_ROCM_CONVERSIONS_ENABLED})
+add_definitions(-DMLIR_ROCM_CONVERSIONS_ENABLED=${MLIR_ENABLE_ROCM_CONVERSIONS})
 
-set(MLIR_CUDA_RUNNER_ENABLED 0 CACHE BOOL "Enable building the mlir CUDA runner")
-set(MLIR_ROCM_RUNNER_ENABLED 0 CACHE BOOL "Enable building the mlir ROCm runner")
-set(MLIR_SPIRV_CPU_RUNNER_ENABLED 0 CACHE BOOL "Enable building the mlir SPIR-V cpu runner")
-set(MLIR_VULKAN_RUNNER_ENABLED 0 CACHE BOOL "Enable building the mlir Vulkan runner")
+# Until the buildbot configuration is updated, preserve old names.
+if (${MLIR_CUDA_RUNNER_ENABLED})
+  set(MLIR_ENABLE_CUDA_RUNNER_DEFAULT ${MLIR_CUDA_RUNNER_ENABLED})
+else()
+  set(MLIR_ENABLE_CUDA_RUNNER_DEFAULT 0)
+endif()
+
+set(MLIR_ENABLE_CUDA_RUNNER ${MLIR_ENABLE_CUDA_RUNNER_DEFAULT} CACHE BOOL "Enable building the mlir CUDA runner")
+set(MLIR_ENABLE_ROCM_RUNNER 0 CACHE BOOL "Enable building the mlir ROCm runner")
+set(MLIR_ENABLE_SPIRV_CPU_RUNNER 0 CACHE BOOL "Enable building the mlir SPIR-V cpu runner")
+set(MLIR_ENABLE_VULKAN_RUNNER 0 CACHE BOOL "Enable building the mlir Vulkan runner")
 
 option(MLIR_INCLUDE_TESTS
        "Generate build targets for the MLIR unit tests."
        ${LLVM_INCLUDE_TESTS})
 
 option(MLIR_INCLUDE_INTEGRATION_TESTS
        "Generate build targets for the MLIR integration tests.")
 
 #-------------------------------------------------------------------------------
 # Python Bindings Configuration
 # Requires:
 #   The pybind11 library can be found (set with -DPYBIND_DIR=...)
 #   The python executable is correct (set with -DPython3_EXECUTABLE=...)
 #
 # Version locking
 # ---------------
 # By default, python extensions are version locked to specific Python libraries.
 # This linking mode is somewhat more consistent across platforms and surfaces
 # undefined symbols at link time (vs runtime). It is suitable for development
 # workflows but can be disabled for more flexible deployment by
-# setting -DMLIR_PYTHON_BINDINGS_VERSION_LOCKED=OFF
+# setting -DMLIR_BINDINGS_PYTHON_LOCK_VERSION=OFF
 #-------------------------------------------------------------------------------
 
-set(MLIR_BINDINGS_PYTHON_ENABLED 0 CACHE BOOL
+# Until the buildbot configuration is updated, support old name.
+if (${MLIR_BINDINGS_PYTHON_ENABLED})
+  set(MLIR_ENABLE_BINDINGS_PYTHON_DEFAULT ${MLIR_BINDINGS_PYTHON_ENABLED})
+else()
+  set(MLIR_ENABLE_BINDINGS_PYTHON_DEFAULT 0)
+endif()
+
+set(MLIR_ENABLE_BINDINGS_PYTHON ${MLIR_ENABLE_BINDINGS_PYTHON_DEFAULT} CACHE BOOL
        "Enables building of Python bindings.")
-set(MLIR_PYTHON_BINDINGS_VERSION_LOCKED 1 CACHE BOOL
+set(MLIR_BINDINGS_PYTHON_LOCK_VERSION 1 CACHE BOOL
        "Links to specific python libraries, resolving all symbols.")
 
-if(MLIR_BINDINGS_PYTHON_ENABLED)
+if(MLIR_ENABLE_BINDINGS_PYTHON)
   include(MLIRDetectPythonEnv)
   find_package(Python3 ${LLVM_MINIMUM_PYTHON_VERSION}
     COMPONENTS Interpreter Development NumPy REQUIRED)
   message(STATUS "Found python include dirs: ${Python3_INCLUDE_DIRS}")
   message(STATUS "Found python libraries: ${Python3_LIBRARIES}")
   message(STATUS "Found numpy v${Python3_NumPy_VERSION}: ${Python3_NumPy_INCLUDE_DIRS}")
   mlir_detect_pybind11_install()
   find_package(pybind11 2.6 CONFIG REQUIRED)
   message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIR}")
   message(STATUS "Python prefix = '${PYTHON_MODULE_PREFIX}', "
else()
     message(WARNING "gtest not found, unittests will not be available")
   endif()
   add_subdirectory(test)
 endif()
 # Tools needs to come late to ensure that MLIR_ALL_LIBS is populated.
 # Generally things after this point may depend on MLIR_ALL_LIBS or libMLIR.so.
 add_subdirectory(tools)
 
-if(MLIR_BINDINGS_PYTHON_ENABLED)
+if(MLIR_ENABLE_BINDINGS_PYTHON)
   # Python sources: built extensions come in via lib/Bindings/Python
   add_subdirectory(python)
 endif()
 
 if( LLVM_INCLUDE_EXAMPLES )
   add_subdirectory(examples)
 endif()
 

mlir/cmake/modules/AddMLIRPython.cmake

function(add_mlir_python_extension libname extname)
   # some greater deployment flexibility since the extension will bind to
   # symbols in the python interpreter on load. However, it also keeps the
   # linker from erroring on undefined symbols, leaving this to (usually obtuse)
   # runtime errors. Building in "SHARED" mode with an explicit link to the
   # python libraries allows us to build with the expectation of no undefined
   # symbols, which is better for development. Note that not all python
   # configurations provide build-time libraries to link against, in which
   # case, we fall back to MODULE linking.
-  if(Python3_LIBRARIES STREQUAL "" OR NOT MLIR_PYTHON_BINDINGS_VERSION_LOCKED)
+  if(Python3_LIBRARIES STREQUAL "" OR NOT MLIR_BINDINGS_PYTHON_LOCK_VERSION)
     set(PYEXT_LINK_MODE MODULE)
     set(PYEXT_LIBADD)
   else()
     set(PYEXT_LINK_MODE SHARED)
     set(PYEXT_LIBADD ${Python3_LIBRARIES})
   endif()
 
   # The actual extension library produces a shared-object or DLL and has

mlir/docs/Bindings/Python.md

 # MLIR Python Bindings
 
 Current status: Under development and not enabled by default
 
 ## Building
 
 ### Pre-requisites
 
 * A relatively recent Python3 installation
 * Installation of python dependencies as specified in
   `mlir/python/requirements.txt`
 
 ### CMake variables
 
-* **`MLIR_BINDINGS_PYTHON_ENABLED`**`:BOOL`
+* **`MLIR_ENABLE_BINDINGS_PYTHON`**`:BOOL`
 
   Enables building the Python bindings. Defaults to `OFF`.
 
 * **`Python3_EXECUTABLE`**:`STRING`
 
   Specifies the `python` executable used for the LLVM build, including for
   determining header/link flags for the Python bindings. On systems with
   multiple Python implementations, setting this explicitly to the preferred
   `python3` executable is strongly recommended.
 
-* **`MLIR_PYTHON_BINDINGS_VERSION_LOCKED`**`:BOOL`
+* **`MLIR_BINDINGS_PYTHON_LOCK_VERSION`**`:BOOL`
 
   Links the native extension against the Python runtime library, which is
   optional on some platforms. While setting this to `OFF` can yield some greater
   deployment flexibility, linking in this way allows the linker to report
   compile time errors for unresolved symbols on all platforms, which makes for a
   smoother development workflow. Defaults to `ON`.
 
 ### Recommended development practices

mlir/docs/SPIRVToLLVMDialectConversion.md

 ## `mlir-spirv-cpu-runner`
 
 `mlir-spirv-cpu-runner` allows to execute `gpu` dialect kernel on the CPU via
 SPIR-V to LLVM dialect conversion. Currently, only single-threaded kernel is
 supported.
 
 To build the runner, add the following option to `cmake`:
 ```bash
--DMLIR_SPIRV_CPU_RUNNER_ENABLED=1
+-DMLIR_ENABLE_SPIRV_CPU_RUNNER=1
 ```
 
 ### Pipeline
 
 The `gpu` module with the kernel and the host code undergo the following
 transformations:
 
 *   Convert the `gpu` module into SPIR-V dialect, lower ABI attributes and

mlir/docs/Tools/LinalgOpDsl.md

 # linalg_opdsl tool
 
 Python based DSL for authoring Linalg op definitions and generating
 `linalg.generic` IR based on them for samples.
 
 The tool `linalg_opdsl` provides a high level DSL for constructing
 structured op definitions in a way that can be exported to built-in, named
 structured ops via the above YAML-based definitions or used interactively to
 emit corresponding `linalg.generic` IR for the composition.
 
 ## Basic usage
 
 The tool is bundled with the MLIR Python bindings. To use from the CMake build
 tree, MLIR must be build with Python bindings enabled
-(`-DMLIR_BINDINGS_PYTHON_ENABLED=ON`). Then add the `python` directory in the
+(`-DMLIR_ENALBE_BINDINGS_PYTHON=ON`). Then add the `python` directory in the
 build tree to your `PYTHONPATH` environment variable (i.e.
 `export PYTHONPATH=$PWD/build/python`). Optionally, use an installed MLIR
 package, if available, to avoid building.
 
 ```shell
 # Dump the `core_named_ops.py` module as YAML.
 python -m python -m mlir.tools.linalg_opdsl.dump_oplib .ops.core_named_ops
 ```

mlir/lib/Bindings/CMakeLists.txt

-if(MLIR_BINDINGS_PYTHON_ENABLED)
+if(MLIR_ENABLE_BINDINGS_PYTHON)
   add_subdirectory(Python)
 endif()

mlir/lib/Conversion/GPUCommon/CMakeLists.txt

-if (MLIR_CUDA_CONVERSIONS_ENABLED)
+if (MLIR_ENABLE_CUDA_CONVERSIONS)
   set(NVPTX_LIBS
     NVPTXCodeGen
     NVPTXDesc
     NVPTXInfo
   )
 endif()
 
-if (MLIR_ROCM_CONVERSIONS_ENABLED)
+if (MLIR_ENABLE_ROCM_CONVERSIONS)
   set(AMDGPU_LIBS
     AMDGPUCodeGen
     AMDGPUDesc
     AMDGPUInfo
   )
 endif()
 
 add_mlir_conversion_library(MLIRGPUToGPURuntimeTransforms

mlir/lib/Dialect/GPU/CMakeLists.txt

-if (MLIR_CUDA_CONVERSIONS_ENABLED)
+if (MLIR_ENABLE_CUDA_CONVERSIONS)
   set(NVPTX_LIBS
     NVPTXCodeGen
     NVPTXDesc
     NVPTXInfo
   )
 endif()
 
-if (MLIR_ROCM_CONVERSIONS_ENABLED)
+if (MLIR_ENABLE_ROCM_CONVERSIONS)
   set(AMDGPU_LIBS
     MCParser
     AMDGPUAsmParser
     AMDGPUCodeGen
     AMDGPUDesc
     AMDGPUInfo
   )
 endif()
add_mlir_dialect_library(MLIRGPU
   MLIRSCF
   MLIRPass
   MLIRSideEffectInterfaces
   MLIRStandard
   MLIRSupport
   MLIRTransformUtils
   )
 
-if(MLIR_CUDA_RUNNER_ENABLED)
-  if(NOT MLIR_CUDA_CONVERSIONS_ENABLED)
+if(MLIR_ENABLE_CUDA_RUNNER)
+  if(NOT MLIR_ENABLE_CUDA_CONVERSIONS)
     message(SEND_ERROR
       "Building mlir with cuda support requires the NVPTX backend")
   endif()
 
   # Configure CUDA language support. Using check_language first allows us to
   # give a custom error message.
   include(CheckLanguage)
   check_language(CUDA)
if(MLIR_ENABLE_CUDA_RUNNER)
   target_link_libraries(MLIRGPU
     PRIVATE
     MLIRNVVMToLLVMIRTranslation
     ${CUDA_DRIVER_LIBRARY}
   )
 
 endif()
 
-if(MLIR_ROCM_RUNNER_ENABLED)
+if(MLIR_ENABLE_ROCM_RUNNER)
   if (NOT ("AMDGPU" IN_LIST LLVM_TARGETS_TO_BUILD))
     message(SEND_ERROR
       "Building mlir with ROCm support requires the AMDGPU backend")
   endif()
 
   # Ensure lld is enabled.
   if (NOT "lld" IN_LIST LLVM_ENABLE_PROJECTS)
     message(SEND_ERROR "lld is not enabled. Please revise LLVM_ENABLE_PROJECTS")

mlir/lib/ExecutionEngine/CMakeLists.txt

add_mlir_library(mlir_async_runtime
   EXCLUDE_FROM_LIBMLIR
 
   LINK_LIBS PUBLIC
   ${LLVM_PTHREAD_LIB}
 )
 set_property(TARGET mlir_async_runtime PROPERTY CXX_VISIBILITY_PRESET hidden)
 target_compile_definitions(mlir_async_runtime PRIVATE mlir_async_runtime_EXPORTS)
 
-if(MLIR_CUDA_RUNNER_ENABLED)
+if(MLIR_ENABLE_CUDA_RUNNER)
   # Configure CUDA support. Using check_language first allows us to give a
   # custom error message.
   include(CheckLanguage)
   check_language(CUDA)
   if (CMAKE_CUDA_COMPILER)
     enable_language(CUDA)
   else()
     message(SEND_ERROR
target_include_directories(mlir_cuda_runtime
     ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
   )
   target_link_libraries(mlir_cuda_runtime
     PRIVATE
     ${CUDA_RUNTIME_LIBRARY}
   )
 endif()
 
-if(MLIR_ROCM_RUNNER_ENABLED)
+if(MLIR_ENABLE_ROCM_RUNNER)
   # Configure ROCm support.
   if (NOT DEFINED ROCM_PATH)
     if (NOT DEFINED ENV{ROCM_PATH})
       set(ROCM_PATH "/opt/rocm" CACHE PATH "Path to which ROCm has been installed")
     else()
       set(ROCM_PATH $ENV{ROCM_PATH} CACHE PATH "Path to which ROCm has been installed")
     endif()
     set(HIP_PATH "${ROCM_PATH}/hip" CACHE PATH "Path to which HIP has been installed")

mlir/test/CMakeLists.txt

 add_subdirectory(CAPI)
 add_subdirectory(SDBM)
 add_subdirectory(lib)
 
-if(MLIR_BINDINGS_PYTHON_ENABLED)
+if(MLIR_ENABLE_BINDINGS_PYTHON)
   add_subdirectory(python)
 endif()
 
 llvm_canonicalize_cmake_booleans(
-  MLIR_BINDINGS_PYTHON_ENABLED
+  MLIR_ENABLE_BINDINGS_PYTHON
   LLVM_BUILD_EXAMPLES
-  MLIR_CUDA_CONVERSIONS_ENABLED
-  MLIR_CUDA_RUNNER_ENABLED
-  MLIR_ROCM_CONVERSIONS_ENABLED
-  MLIR_ROCM_RUNNER_ENABLED
-  MLIR_SPIRV_CPU_RUNNER_ENABLED
-  MLIR_VULKAN_RUNNER_ENABLED
+  MLIR_ENABLE_CUDA_CONVERSIONS
+  MLIR_ENABLE_CUDA_RUNNER
+  MLIR_ENABLE_ROCM_CONVERSIONS
+  MLIR_ENABLE_ROCM_RUNNER
+  MLIR_ENABLE_SPIRV_CPU_RUNNER
+  MLIR_ENABLE_VULKAN_RUNNER
   )
 
 # Passed to lit.site.cfg.py.in to set up the path where to find the libraries
 # for linalg integration tests.
 set(MLIR_DIALECT_LINALG_INTEGRATION_TEST_LIB_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 set(MLIR_RUNNER_UTILS_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 
 # Passed to lit.site.cfg.py.in to set up the path where to find the libraries
set(MLIR_TEST_DEPENDS
   mlir-sdbm-api-test
   mlir-tblgen
   mlir-translate
   mlir_runner_utils
   mlir_c_runner_utils
   mlir_async_runtime
   )
 
-if(MLIR_CUDA_RUNNER_ENABLED)
+if(MLIR_ENABLE_CUDA_RUNNER)
   list(APPEND MLIR_TEST_DEPENDS mlir_cuda_runtime)
 endif()
 
-if(MLIR_ROCM_RUNNER_ENABLED)
+if(MLIR_ENABLE_ROCM_RUNNER)
   list(APPEND MLIR_TEST_DEPENDS mlir_rocm_runtime)
 endif()
 
 list(APPEND MLIR_TEST_DEPENDS MLIRUnitTests)
 
 if(LLVM_BUILD_EXAMPLES)
   list(APPEND MLIR_TEST_DEPENDS
     toyc-ch1
     toyc-ch2
     toyc-ch3
     toyc-ch4
     toyc-ch5
     toyc-ch6
     toyc-ch7
     )
 endif()
 
-if(MLIR_SPIRV_CPU_RUNNER_ENABLED)
+if(MLIR_ENABLE_SPIRV_CPU_RUNNER)
   add_subdirectory(mlir-spirv-cpu-runner)
   list(APPEND MLIR_TEST_DEPENDS
     mlir-spirv-cpu-runner
     mlir_test_spirv_cpu_runner_c_wrappers
   )
 endif()
 
-if(MLIR_VULKAN_RUNNER_ENABLED)
+if(MLIR_ENABLE_VULKAN_RUNNER)
   list(APPEND MLIR_TEST_DEPENDS
     mlir-vulkan-runner
   )
 endif()
 
-if(MLIR_BINDINGS_PYTHON_ENABLED)
+if(MLIR_ENABLE_BINDINGS_PYTHON)
   list(APPEND MLIR_TEST_DEPENDS
     MLIRBindingsPythonExtension
     MLIRBindingsPythonSources
     MLIRBindingsPythonTestOps
     MLIRTransformsBindingsPythonExtension
     MLIRConversionsBindingsPythonExtension
   )
 endif()

mlir/test/lit.site.cfg.py.in

 config.llvm_host_triple = '@LLVM_HOST_TRIPLE@'
 config.host_arch = "@HOST_ARCH@"
 config.mlir_src_root = "@MLIR_SOURCE_DIR@"
 config.mlir_obj_root = "@MLIR_BINARY_DIR@"
 config.mlir_runner_utils_dir = "@MLIR_RUNNER_UTILS_DIR@"
 config.mlir_tools_dir = "@MLIR_TOOLS_DIR@"
 config.linalg_test_lib_dir = "@MLIR_DIALECT_LINALG_INTEGRATION_TEST_LIB_DIR@"
 config.build_examples = @LLVM_BUILD_EXAMPLES@
-config.run_cuda_tests = @MLIR_CUDA_CONVERSIONS_ENABLED@
-config.enable_cuda_runner = @MLIR_CUDA_RUNNER_ENABLED@
-config.run_rocm_tests = @MLIR_ROCM_CONVERSIONS_ENABLED@
-config.enable_rocm_runner = @MLIR_ROCM_RUNNER_ENABLED@
+config.run_cuda_tests = @MLIR_ENABLE_CUDA_CONVERSIONS@
+config.enable_cuda_runner = @MLIR_ENABLE_CUDA_RUNNER@
+config.run_rocm_tests = @MLIR_ENABLE_ROCM_CONVERSIONS@
+config.enable_rocm_runner = @MLIR_ENABLE_ROCM_RUNNER@
 config.spirv_wrapper_library_dir = "@MLIR_SPIRV_WRAPPER_LIBRARY_DIR@"
-config.enable_spirv_cpu_runner = @MLIR_SPIRV_CPU_RUNNER_ENABLED@
+config.enable_spirv_cpu_runner = @MLIR_ENABLE_SPIRV_CPU_RUNNER@
 config.vulkan_wrapper_library_dir = "@MLIR_VULKAN_WRAPPER_LIBRARY_DIR@"
-config.enable_vulkan_runner = @MLIR_VULKAN_RUNNER_ENABLED@
-config.enable_bindings_python = @MLIR_BINDINGS_PYTHON_ENABLED@
+config.enable_vulkan_runner = @MLIR_ENABLE_VULKAN_RUNNER@
+config.enable_bindings_python = @MLIR_ENABLE_BINDINGS_PYTHON@
 config.mlir_integration_test_dir = "@MLIR_INTEGRATION_TEST_DIR@"
 config.intel_sde_executable = "@INTEL_SDE_EXECUTABLE@"
 config.mlir_run_amx_tests = "@MLIR_RUN_AMX_TESTS@"
 config.mlir_run_x86vector_tests = "@MLIR_RUN_X86VECTOR_TESTS@"
 config.mlir_run_cuda_tensor_core_tests = "@MLIR_RUN_CUDA_TENSOR_CORE_TESTS@"
 config.mlir_include_integration_tests = "@MLIR_INCLUDE_INTEGRATION_TESTS@"
 
 # Support substitution of the tools_dir with user parameters. This is