[lldb/test] Automatically find debug servers to test

[labath]

Summary

Our test configuration logic assumes that the tests can be run either
with debugserver or with lldb-server. This is not entirely correct,
since lldb server has two "personalities" (platform server and debug
server) and debugserver is only a replacement for the latter.

A consequence of this is that it's not possible to test the platform
behavior of lldb-server on macos, as it is not possible to get a hold of
the lldb-server binary.

One solution to that would be to duplicate the server configuration
logic to be able to specify both executables. However, that seems
excessively redundant.

A well-behaved lldb should be able to find the debug server on its own,
and testing lldb with a different (lldb-|debug)server does not seem very
useful (even in the out-of-tree debugserver setup, we copy the server
into the build tree to make it appear "real").

Therefore, this patch deletes the configuration altogether and changes
the low-level server retrieval functions to be able to both lldb-server
and debugserver paths. They do this by consulting the "support
executable" directory of the lldb under test.

[labath]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–79

@rupprecht : I'm adding you mainly because my last attempt to change this function broke some google integration stuff.

[JDevlieghere]

This will break my "run the tests against an Xcode install", but it seems like I should be able to work around that looking for debugserver in the LLDB.framework in get_debugserver_exe. Overall this is a pretty nice cleanup so seems like a fair trade-off. LGTM.

[labath]

In D96202#2549497, @JDevlieghere wrote:

This will break my "run the tests against an Xcode install", but it seems like I should be able to work around that looking for debugserver in the LLDB.framework in get_debugserver_exe. Overall this is a pretty nice cleanup so seems like a fair trade-off. LGTM.

What exactly is that use case? Do you want to run the tests with the debugserver that comes with that xcode install? If that's the case, then I would expect this to just work, as lldb knows that in a framework build, the "support executable directory" is located inside the framework: https://github.com/llvm/llvm-project/blob/main/lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm#L138

[JDevlieghere]

In D96202#2550712, @labath wrote:

In D96202#2549497, @JDevlieghere wrote:

This will break my "run the tests against an Xcode install", but it seems like I should be able to work around that looking for debugserver in the LLDB.framework in get_debugserver_exe. Overall this is a pretty nice cleanup so seems like a fair trade-off. LGTM.

What exactly is that use case? Do you want to run the tests with the debugserver that comes with that xcode install? If that's the case, then I would expect this to just work, as lldb knows that in a framework build, the "support executable directory" is located inside the framework: https://github.com/llvm/llvm-project/blob/main/lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm#L138

Even better, that's exactly the logic I had in mind, but I was going to add it in dotest based on the --framework argument. Cool, cool, cool.

[rupprecht]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–79

Thanks, patching this in now! (Sorry for the delay, I was out a couple days)

[labath]

In D96202#2551546, @JDevlieghere wrote:

In D96202#2550712, @labath wrote:

What exactly is that use case? Do you want to run the tests with the debugserver that comes with that xcode install? If that's the case, then I would expect this to just work, as lldb knows that in a framework build, the "support executable directory" is located inside the framework: https://github.com/llvm/llvm-project/blob/main/lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm#L138

Even better, that's exactly the logic I had in mind, but I was going to add it in dotest based on the --framework argument. Cool, cool, cool.

Cool, I'm glad that this works out.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–79

Sure, np. Let me know how it works out.

[rupprecht]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–79

Everything I've tried to throw this against seems to be working. I'm not sure exactly what the problem was before though. Seems fine to land and I can take a closer look if something fails later. Thanks for the heads up!

[labath]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–79

Thanks for checking it out.

The previous patch simply removed the LLDB_DEBUGSERVER_PATH thingy, and left the original logic logic in place (which was calculating the lldb server location based on realpath(3) of the lldb binary, which does not work well inside google).

[stella.stamenova]

It looks like this change resulted in a failing test on the Windows LLDB bot:

http://lab.llvm.org:8011/#/builders/83/builds/3602

It seems like one of the tests is trying to re-use the same log names within a single run and they are still being used by the previous instance from the same test run. Can you have a look?

[labath]

In D96202#2557365, @stella.stamenova wrote:

It looks like this change resulted in a failing test on the Windows LLDB bot:

http://lab.llvm.org:8011/#/builders/83/builds/3602

It seems like one of the tests is trying to re-use the same log names within a single run and they are still being used by the previous instance from the same test run. Can you have a look?

I don't understand yet what is going on, but it does seem like this patch is to blame. I'll revert while I try to understand this.

[goncharov]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–76

hi @labath ! Sorry for ignorance but what is the reason to remove this resolution through env? For me (due to complicated build system) lldb-server is located in completely different location and "which lldb-server" finds nothing. cc @rupprecht

[labath]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

75–76

The main reason is that the variable was overloaded to mean both the path to the debugserver and lldb-server binaries (which meant that it was not possible to find both), though one could also argue this environment variable override is a gross hack in itself.

Where does GetLLDBPath(lldb.ePathTypeSupportExecutableDir) point to in your case? Could it be fixed (maybe via the new SharedLibraryDirectoryHelper (D96779)), or lldb-server moved so that the result is correct. If the support executable directory is not correct, then you're likely to run into other problems besides failing tests.

[teemperor]

lldb/test/API/CMakeLists.txt

115

I believe this removed line is causing us to have missing dependencies. I just did a clean build of LLDB and it turns out that debugserver is no longer a dependency of check-lldb, which causes a bunch of weird test failures such as:

********************
FAIL: lldb-unit :: tools/lldb-server/tests/./LLDBServerTests/StandardStartupTest.TestStopReplyContainsThreadPcs (2268 of 2282)
******************** TEST 'lldb-unit :: tools/lldb-server/tests/./LLDBServerTests/StandardStartupTest.TestStopReplyContainsThreadPcs' FAILED ********************
Note: Google Test filter = StandardStartupTest.TestStopReplyContainsThreadPcs
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from StandardStartupTest
[ RUN      ] StandardStartupTest.TestStopReplyContainsThreadPcs
/Users/teemperor/3llvm/llvm-project/lldb/unittests/tools/lldb-server/tests/TestBase.h:49: Failure
Value of: llvm::detail::TakeExpected(ClientOr)
Expected: succeeded
  Actual: failed  (executable doesn't exist: '/Users/teemperor/3llvm/rel/bin/debugserver')
[  FAILED  ] StandardStartupTest.TestStopReplyContainsThreadPcs (5 ms)
[----------] 1 test from StandardStartupTest (5 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (5 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] StandardStartupTest.TestStopReplyContainsThreadPcs

 1 FAILED TEST

I haven't bisected yet what exactly did remove the debugserver dependency but I'm pretty sure it's this patch (due to being landed recently and me not finding any other place where we added this dependency)

[labath]

lldb/test/API/CMakeLists.txt

115

Thanks for letting me know, and sorry about the breakage. Your analysis sounds believable.
I guess this should be replaced by something like

if(TARGET debugserver)
  add_lldb_test_dependency(debugserver)
endif()
if(TARGET lldb-server)
  add_lldb_test_dependency(lldb-server)
endif()

I can do that tomorrow.

[teemperor]

lldb/test/API/CMakeLists.txt

115

I'm still in office for a while so I can do it now :)

[teemperor]

re-adding debugserver deps here: https://reviews.llvm.org/D98196

lldb/packages/Python/lldbsuite/test/dotest.py

if args.executable:
         if not is_exe(lldbtest_config.lldbExec):
             lldbtest_config.lldbExec = which(args.executable)
         if not is_exe(lldbtest_config.lldbExec):
             logging.error(
                     '%s is not a valid executable to test; aborting...',
                     args.executable)
             sys.exit(-1)
 
-    if args.server and args.out_of_tree_debugserver:
-        logging.warning('Both --server and --out-of-tree-debugserver are set')
-
-    if args.server and not args.out_of_tree_debugserver:
-        os.environ['LLDB_DEBUGSERVER_PATH'] = args.server
-
     if args.excluded:
         for excl_file in args.excluded:
             parseExclusion(excl_file)
 
     if args.p:
         if args.p.startswith('-'):
             usage(parser)
         configuration.regexp = args.p

lldb/packages/Python/lldbsuite/test/dotest_args.py

group.add_argument(
         '--framework',
         metavar='framework-path',
         help='The path to LLDB.framework')
     group.add_argument(
         '--executable',
         metavar='executable-path',
         help='The path to the lldb executable')
     group.add_argument(
-        '--server',
-        metavar='server-path',
-        help='The path to the debug server executable to use')
-    group.add_argument(
         '--out-of-tree-debugserver',
         dest='out_of_tree_debugserver',
         action='store_true',
         help='A flag to indicate an out-of-tree debug server is being used')
     group.add_argument(
         '--dwarf-version',
         metavar='dwarf_version',
         dest='dwarf_version',

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

 import re
 import six
 import socket
 import subprocess
 from lldbsuite.support import seven
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import configuration
 from textwrap import dedent
+import shutil
 
-def _get_debug_monitor_from_lldb(lldb_exe, debug_monitor_basename):
-    """Return the debug monitor exe path given the lldb exe path.
+def _get_support_exe(basename):
+    support_dir = lldb.SBHostOS.GetLLDBPath(lldb.ePathTypeSupportExecutableDir)
 
-    This method attempts to construct a valid debug monitor exe name
-    from a given lldb exe name.  It will return None if the synthesized
-    debug monitor name is not found to exist.
-
-    The debug monitor exe path is synthesized by taking the directory
-    of the lldb exe, and replacing the portion of the base name that
-    matches "lldb" (case insensitive) and replacing with the value of
-    debug_monitor_basename.
-
-    Args:
-        lldb_exe: the path to an lldb executable.
-
-        debug_monitor_basename: the base name portion of the debug monitor
-            that will replace 'lldb'.
-
-    Returns:
-        A path to the debug monitor exe if it is found to exist; otherwise,
-        returns None.
-
-    """
-    if not lldb_exe:
-        return None
-
-    exe_dir = os.path.dirname(lldb_exe)
-    exe_base = os.path.basename(lldb_exe)
-
-    # we'll rebuild the filename by replacing lldb with
-    # the debug monitor basename, keeping any prefix or suffix in place.
-    regex = re.compile(r"lldb", re.IGNORECASE)
-    new_base = regex.sub(debug_monitor_basename, exe_base)
-
-    debug_monitor_exe = os.path.join(exe_dir, new_base)
-    if os.path.exists(debug_monitor_exe):
-        return debug_monitor_exe
-
-    new_base = regex.sub(
-        'LLDB.framework/Versions/A/Resources/' +
-        debug_monitor_basename,
-        exe_base)
-    debug_monitor_exe = os.path.join(exe_dir, new_base)
-    if os.path.exists(debug_monitor_exe):
-        return debug_monitor_exe
-
-    return None
+    return shutil.which(basename, path=support_dir.GetDirectory())
 
 
 def get_lldb_server_exe():
     """Return the lldb-server exe path.
 
     Returns:
         A path to the lldb-server exe if it is found to exist; otherwise,
         returns None.
     """
-    if "LLDB_DEBUGSERVER_PATH" in os.environ:
-        return os.environ["LLDB_DEBUGSERVER_PATH"]
 
-    return _get_debug_monitor_from_lldb(
-        lldbtest_config.lldbExec, "lldb-server")
+    return _get_support_exe("lldb-server")
 
 
 def get_debugserver_exe():
     """Return the debugserver exe path.
 
     Returns:
         A path to the debugserver exe if it is found to exist; otherwise,
         returns None.
     """
-    if "LLDB_DEBUGSERVER_PATH" in os.environ:
-        return os.environ["LLDB_DEBUGSERVER_PATH"]
-
     if configuration.arch and configuration.arch == "x86_64" and \
        platform.machine().startswith("arm64"):
         return '/Library/Apple/usr/libexec/oah/debugserver'
 
-    return _get_debug_monitor_from_lldb(
-        lldbtest_config.lldbExec, "debugserver")
+    return _get_support_exe("debugserver")
 
 _LOG_LINE_REGEX = re.compile(r'^(lldb-server|debugserver)\s+<\s*(\d+)>' +
                              '\s+(read|send)\s+packet:\s+(.+)$')
 
 
 def _is_packet_lldb_gdbserver_input(packet_type, llgs_input_is_read):
     """Return whether a given packet is input for lldb-gdbserver.
 

lldb/test/API/CMakeLists.txt

if(LLDB_USE_SYSTEM_DEBUGSERVER)
     lldb_find_system_debugserver(system_debugserver_path)
     add_custom_target(debugserver
       COMMAND ${CMAKE_COMMAND} -E copy_if_different
       ${system_debugserver_path} ${LLVM_RUNTIME_OUTPUT_INTDIR}
       COMMENT "Copying the system debugserver to LLDB's binaries directory for testing.")
     message(STATUS "LLDB tests use out-of-tree debugserver: ${system_debugserver_path}")
     list(APPEND LLDB_TEST_COMMON_ARGS --out-of-tree-debugserver)
     add_lldb_test_dependency(debugserver)
-  elseif(TARGET debugserver)
-    set(debugserver_path ${LLVM_RUNTIME_OUTPUT_INTDIR}/debugserver)
-    message(STATUS "LLDB Tests use just-built debugserver: ${debugserver_path}")
-    set(LLDB_TEST_SERVER ${debugserver_path})
-    add_lldb_test_dependency(debugserver)
-  elseif(TARGET lldb-server)
-    set(lldb_server_path ${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb-server)
-    message(STATUS "LLDB Tests use just-built lldb-server: ${lldb_server_path}")
-    set(LLDB_TEST_SERVER ${lldb_server_path})
-    add_lldb_test_dependency(lldb-server)
   else()
-    message(WARNING "LLDB Tests enabled, but no server available")
+    message(STATUS "LLDB Tests use just-built debug server")
   endif()
 endif()
 
 set(LLDB_DOTEST_ARGS ${LLDB_TEST_COMMON_ARGS};${LLDB_TEST_USER_ARGS} CACHE INTERNAL STRING)
 set(dotest_args_replacement ${LLVM_BUILD_MODE})
 
 if(LLDB_BUILT_STANDALONE)
   # In paths to our build-tree, replace CMAKE_CFG_INTDIR with our configuration name placeholder.
   string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} config_runtime_output_dir ${LLVM_RUNTIME_OUTPUT_INTDIR})
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_DOTEST_ARGS "${LLDB_DOTEST_ARGS}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_SOURCE_DIR "${LLDB_SOURCE_DIR}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_FRAMEWORK_DIR "${LLDB_FRAMEWORK_DIR}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_TEST_BUILD_DIRECTORY "${LLDB_TEST_BUILD_DIRECTORY}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_TEST_EXECUTABLE "${LLDB_TEST_EXECUTABLE}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_TEST_COMPILER "${LLDB_TEST_COMPILER}")
   string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_TEST_DSYMUTIL "${LLDB_TEST_DSYMUTIL}")
-  string(REPLACE ${LLVM_RUNTIME_OUTPUT_INTDIR} ${config_runtime_output_dir} LLDB_TEST_SERVER "${LLDB_TEST_SERVER}")
 
   # Remaining ones must be paths to the provided LLVM build-tree.
   if(LLVM_CONFIGURATION_TYPES)
     # LLDB uses single-config; LLVM multi-config; pick one and prefer Release types.
     # Otherwise, if both use multi-config the default is fine.
     if(NOT CMAKE_CONFIGURATION_TYPES)
       if(RelWithDebInfo IN_LIST LLVM_CONFIGURATION_TYPES)
         set(dotest_args_replacement RelWithDebInfo)

 endif()
 
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_DOTEST_ARGS "${LLDB_DOTEST_ARGS}")
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_SOURCE_DIR "${LLDB_SOURCE_DIR}")
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_TEST_BUILD_DIRECTORY "${LLDB_TEST_BUILD_DIRECTORY}")
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_TEST_EXECUTABLE "${LLDB_TEST_EXECUTABLE}")
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_TEST_COMPILER "${LLDB_TEST_COMPILER}")
 string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_TEST_DSYMUTIL "${LLDB_TEST_DSYMUTIL}")
-string(REPLACE ${CMAKE_CFG_INTDIR} ${dotest_args_replacement} LLDB_TEST_SERVER "${LLDB_TEST_SERVER}")
 
 # Configure the API test suite.
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py)
 
 if (CMAKE_GENERATOR STREQUAL "Xcode")
   # Xcode does not get the auto-generated targets. We need to create
   # check-lldb-api manually.
   add_lit_testsuite(check-lldb-api "Running lldb api test suite"
     ${CMAKE_CURRENT_BINARY_DIR}
     DEPENDS lldb-test-deps)
 endif()

lldb/test/API/commands/platform/sdk/TestPlatformSDK.py

 import lldb
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
+from lldbgdbserverutils import get_debugserver_exe
 
 import os
 import platform
 import shutil
 import time
 import socket
 
 
class PlatformSDKTestCase(TestBase):
     ATTEMPTS = 10
 
     # Time given to the binary to launch and to debugserver to attach to it for
     # every attempt. We'll wait a maximum of 10 times 2 seconds while the
     # inferior will wait 10 times 10 seconds.
     TIMEOUT = 2
 
     def no_debugserver(self):
-        if os.getenv('LLDB_DEBUGSERVER_PATH') is None:
+        if get_debugserver_exe() is None:
             return 'no debugserver'
         return None
 
     def port_not_available(self):
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         if s.connect_ex(('127.0.0.1', self.PORT)) == 0:
             return '{} not available'.format(self.PORT)
         return None
def test_macos_sdk(self):
 
         # Move the binary into the 'SDK'.
         rel_exe_path = os.path.relpath(exe, '/')
         exe_sdk_path = os.path.join(symbols_dir, rel_exe_path)
         lldbutil.mkdir_p(os.path.dirname(exe_sdk_path))
         shutil.move(exe, exe_sdk_path)
 
         # Attach to it with debugserver.
-        debugserver = os.getenv('LLDB_DEBUGSERVER_PATH')
+        debugserver = get_debugserver_exe()
         debugserver_args = [
             'localhost:{}'.format(self.PORT), '--attach={}'.format(pid)
         ]
         self.spawnSubprocess(debugserver, debugserver_args)
 
         # Select the platform.
         self.expect('platform select remote-macosx', substrs=[sdk_dir])
 

lldb/test/API/lit.site.cfg.py.in

 config.dotest_args_str = "@LLDB_DOTEST_ARGS@"
 config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.dotest_lit_args_str = None
 config.enabled_plugins = []
 config.lldb_executable = '@LLDB_TEST_EXECUTABLE@'
 config.test_arch = '@LLDB_TEST_ARCH@'
 config.test_compiler = '@LLDB_TEST_COMPILER@'
 config.dsymutil = '@LLDB_TEST_DSYMUTIL@'
-config.server = '@LLDB_TEST_SERVER@'
 # The API tests use their own module caches.
 config.lldb_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_LLDB@", "lldb-api")
 config.clang_module_cache = os.path.join("@LLDB_TEST_MODULE_CACHE_CLANG@", "lldb-api")
 
 # Plugins
 lldb_build_intel_pt = '@LLDB_BUILD_INTEL_PT@'
 if lldb_build_intel_pt == '1':
     config.enabled_plugins.append('intel-pt')

 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
     config.llvm_build_mode = config.llvm_build_mode % lit_config.params
     config.lldb_executable = config.lldb_executable % lit_config.params
     config.lldb_libs_dir = config.lldb_libs_dir % lit_config.params
     config.test_compiler = config.test_compiler % lit_config.params
-    config.server = config.server % lit_config.params
     config.lldb_framework_dir = config.lldb_framework_dir % lit_config.params
     config.dotest_args_str = config.dotest_args_str % lit_config.params
 except KeyError as e:
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 # Let the main config do the real work.
 lit_config.load_config(config, os.path.join(config.lldb_src_root, "test", "API", "lit.cfg.py"))

lldb/utils/lldb-dotest/CMakeLists.txt

 set(vars
   LLDB_DOTEST_ARGS
   LLDB_SOURCE_DIR
   LLDB_FRAMEWORK_DIR
   LLDB_TEST_BUILD_DIRECTORY
   LLDB_TEST_EXECUTABLE
   LLDB_TEST_COMPILER
   LLDB_TEST_DSYMUTIL
-  LLDB_TEST_SERVER
   LLDB_LIBS_DIR
   LLVM_TOOLS_DIR
   )
 
 # Generate lldb-dotest Python driver script for each build mode.
 if(LLDB_BUILT_STANDALONE)
   set(config_types ".")
   if(CMAKE_CONFIGURATION_TYPES)

lldb/utils/lldb-dotest/lldb-dotest.in

 #!@Python3_EXECUTABLE@
 import subprocess
 import sys
 
 dotest_path = '@LLDB_SOURCE_DIR_CONFIGURED@/test/API/dotest.py'
 dotest_args_str = '@LLDB_DOTEST_ARGS_CONFIGURED@'
 arch = '@LLDB_TEST_ARCH@'
 executable = '@LLDB_TEST_EXECUTABLE_CONFIGURED@'
 compiler = '@LLDB_TEST_COMPILER_CONFIGURED@'
 dsymutil = '@LLDB_TEST_DSYMUTIL_CONFIGURED@'
-server = '@LLDB_TEST_SERVER_CONFIGURED@'
 lldb_build_dir = '@LLDB_TEST_BUILD_DIRECTORY_CONFIGURED@'
 lldb_build_intel_pt = "@LLDB_BUILD_INTEL_PT@"
 lldb_framework_dir = "@LLDB_FRAMEWORK_DIR_CONFIGURED@"
 lldb_libs_dir = "@LLDB_LIBS_DIR_CONFIGURED@"
 llvm_tools_dir = "@LLVM_TOOLS_DIR_CONFIGURED@"
 
 if __name__ == '__main__':
     wrapper_args = sys.argv[1:]
     dotest_args = dotest_args_str.split(';')
     # Build dotest.py command.
     cmd = [sys.executable, dotest_path]
     cmd.extend(['--arch', arch])
     cmd.extend(dotest_args)
     cmd.extend(['--build-dir', lldb_build_dir])
     cmd.extend(['--executable', executable])
     cmd.extend(['--compiler', compiler])
     cmd.extend(['--dsymutil', dsymutil])
     cmd.extend(['--lldb-libs-dir', lldb_libs_dir])
     cmd.extend(['--llvm-tools-dir', llvm_tools_dir])
-    if server:
-        cmd.extend(['--server', server])
     if lldb_framework_dir:
         cmd.extend(['--framework', lldb_framework_dir])
     if lldb_build_intel_pt == "1":
         cmd.extend(['--enable-plugin', 'intel-pt'])
     cmd.extend(wrapper_args)
     # Invoke dotest.py and return exit code.
     print(' '.join(cmd))
     sys.exit(subprocess.call(cmd))