Refactored lldb executable name discovery

[vharron]

Summary

The lldb executable was referenced through the code by 7 different
(effectively) global variables.

global lldbExecutablePath
global lldbExecutable
os.environ['LLDB_EXEC']
os.environ['LLDB_TEST']
dotest.lldbExec
dotest.lldbHere
lldbtest.lldbExec

This change uses one global variable lldbtest_config.lldbExec to
replace them all.

[vharron]

Fixed debugserver path calculation

[clayborg]

lgtm

test/benchmarks/disassembly/TestDisassembly.py

def is_exe(fpath):
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
 class DisassembleDriverMainLoop(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         """
-        Note that lldbExec can be specified with the LLDB_EXEC env variable (see
+        Note that lldbtest_config.lldbExec can be specified with the LLDB_EXEC env variable (see
         dotest.py), and gdbExec can be specified with the GDB_EXEC env variable.
         This provides a flexibility in specifying different versions of gdb for
         comparison purposes.
         """
         BenchBase.setUp(self)
         # If env var GDB_EXEC is specified, use it; otherwise, use gdb in your
         # PATH env var.
         if "GDB_EXEC" in os.environ and is_exe(os.environ["GDB_EXEC"]):
             self.gdbExec = os.environ["GDB_EXEC"]
         else:
             self.gdbExec = "gdb"
 
-        self.exe = self.lldbHere
+        self.exe = lldbtest_config.lldbExec
         self.function = 'Driver::MainLoop()'
         self.lldb_avg = None
         self.gdb_avg = None
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 5
 
     @benchmarks_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_then_gdb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print
-        print "lldb path: %s" % self.lldbExec
+        print "lldb path: %s" % lldbtest_config.lldbExec
         print "gdb path: %s" % self.gdbExec
 
         print
         self.run_lldb_disassembly(self.exe, self.function, self.count)
         print "lldb benchmark:", self.stopwatch
         self.run_gdb_disassembly(self.exe, self.function, self.count)
         print "gdb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     @benchmarks_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_gdb_then_lldb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print
-        print "lldb path: %s" % self.lldbExec
+        print "lldb path: %s" % lldbtest_config.lldbExec
         print "gdb path: %s" % self.gdbExec
 
         print
         self.run_gdb_disassembly(self.exe, self.function, self.count)
         print "gdb benchmark:", self.stopwatch
         self.run_lldb_disassembly(self.exe, self.function, self.count)
         print "lldb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     def run_lldb_disassembly(self, exe, function, count):
         import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         child.expect_exact(prompt)
         child.sendline('breakpoint set -F %s' % function)

test/benchmarks/disassembly/TestDoAttachThenDisassembly.py

class AttachThenDisassemblyBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         if lldb.bmExecutable:
             self.exe = lldb.bmExecutable
         else:
-            self.exe = self.lldbHere
+            self.exe = lldbtest_config.lldbExec
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 10
 
     @benchmarks_test
     def test_attach_then_disassembly(self):
         """Attach to a spawned lldb process then run disassembly benchmarks."""
         print

test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py

 """Disassemble lldb's Driver::MainLoop() functions comparing Xcode 4.1 vs. 4.2's gdb."""
 
 import os, sys
 import unittest2
 import lldb
 from lldbbench import *
 
 class XCode41Vs42GDBDisassembly(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         self.gdb_41_exe = '/Xcode41/usr/bin/gdb'
         self.gdb_42_exe = '/Developer/usr/bin/gdb'
-        self.exe = self.lldbHere
+        self.exe = lldbtest_config.lldbExec
         self.function = 'Driver::MainLoop()'
         self.gdb_41_avg = None
         self.gdb_42_avg = None
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 5
 
     @benchmarks_test

test/benchmarks/expression/TestExpressionCmd.py

def run_lldb_repeated_exprs(self, exe_name, count):
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatch now.
         self.stopwatch.reset()
         for i in range(count):
             # So that the child gets torn down after the test.
-            self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+            self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
             child = self.child
 
             # Turn on logging for what the child sends back.
             if self.TraceOn():
                 child.logfile_read = sys.stdout
 
             child.expect_exact(prompt)
             child.sendline('breakpoint set -f %s -l %d' % (self.source, self.line_to_break))

test/benchmarks/expression/TestRepeatedExprs.py

def run_lldb_repeated_exprs(self, exe_name, count):
         import pexpect
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         child.expect_exact(prompt)
         child.sendline('breakpoint set -f %s -l %d' % (self.source, self.line_to_break))

test/benchmarks/frame_variable/TestFrameVariableResponse.py

 """Test lldb's response time for 'frame variable' command."""
 
 import os, sys
 import unittest2
 import lldb
 from lldbbench import *
 
 class FrameVariableResponseBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         if lldb.bmExecutable:
             self.exe = lldb.bmExecutable
         else:
-            self.exe = self.lldbHere
+            self.exe = lldbtest_config.lldbExec
         if lldb.bmBreakpointSpec:
             self.break_spec = lldb.bmBreakpointSpec
         else:
             self.break_spec = '-n main'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 20
def run_frame_variable_bench(self, exe, break_spec, count):
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatchs now.
         self.stopwatch.reset()
         for i in range(count):
             # So that the child gets torn down after the test.
-            self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+            self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
             child = self.child
 
             # Turn on logging for what the child sends back.
             if self.TraceOn():
                 child.logfile_read = sys.stdout
 
             # Set our breakpoint.
             child.sendline('breakpoint set %s' % break_spec)

test/benchmarks/startup/TestStartupDelays.py

def setUp(self):
         # Create self.stopwatch2 for measuring "set first breakpoint".
         # The default self.stopwatch is for "create fresh target".
         self.stopwatch2 = Stopwatch()
         # Create self.stopwatch3 for measuring "run to breakpoint".
         self.stopwatch3 = Stopwatch()
         if lldb.bmExecutable:
             self.exe = lldb.bmExecutable
         else:
-            self.exe = self.lldbHere
+            self.exe = lldbtest_config.lldbExec
         if lldb.bmBreakpointSpec:
             self.break_spec = lldb.bmBreakpointSpec
         else:
             self.break_spec = '-n main'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 30
def run_startup_delays_bench(self, exe, break_spec, count):
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatchs now.
         self.stopwatch.reset()
         self.stopwatch2.reset()
         for i in range(count):
             # So that the child gets torn down after the test.
-            self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
+            self.child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))
             child = self.child
 
             # Turn on logging for what the child sends back.
             if self.TraceOn():
                 child.logfile_read = sys.stdout
 
             with self.stopwatch:
                 # Create a fresh target.

test/benchmarks/stepping/TestRunHooksThenSteppings.py

def test_lldb_runhooks_then_steppings(self):
         print "lldb stepping benchmark:", self.stopwatch
 
     def run_lldb_runhooks_then_steppings(self, count):
         import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
-        self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
+        self.child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))
         self.child.expect_exact(prompt)
         # So that the child gets torn down after the test.
         child = self.child
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 

test/benchmarks/stepping/TestSteppingSpeed.py

 """Test lldb's stepping speed."""
 
 import os, sys
 import unittest2
 import lldb
 from lldbbench import *
 
 class SteppingSpeedBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         if lldb.bmExecutable:
             self.exe = lldb.bmExecutable
         else:
-            self.exe = self.lldbHere
+            self.exe = lldbtest_config.lldbExec
         if lldb.bmBreakpointSpec:
             self.break_spec = lldb.bmBreakpointSpec
         else:
             self.break_spec = '-n main'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 50
class SteppingSpeedBench(BenchBase):
 
     def run_lldb_steppings(self, exe, break_spec, count):
         import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         child.expect_exact(prompt)
         child.sendline('breakpoint set %s' % break_spec)

test/benchmarks/turnaround/TestCompileRunToBreakpointTurnaround.py

 """Benchmark the turnaround time starting a debugger and run to the breakpont with lldb vs. gdb."""
 
 import os, sys
 import unittest2
 import lldb
 from lldbbench import *
 
 class CompileRunToBreakpointBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
-        self.exe = self.lldbHere
+        self.exe = lldbtest_config.lldbExec
         self.function = 'Driver::MainLoop()'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 3
 
         self.lldb_avg = None
         self.gdb_avg = None
def test_run_lldb_then_gdb(self):
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     def run_lldb_turnaround(self, exe, function, count):
         import pexpect
         def run_one_round():
             prompt = self.child_prompt
 
             # So that the child gets torn down after the test.
-            self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
+            self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
             child = self.child
 
             # Turn on logging for what the child sends back.
             if self.TraceOn():
                 child.logfile_read = sys.stdout
 
             child.expect_exact(prompt)
             child.sendline('breakpoint set -F %s' % function)

test/dotest.py

 # Categories we want to skip
 skipCategories = []
 # use this to track per-category failures
 failuresPerCategory = {}
 
 # The path to LLDB.framework is optional.
 lldbFrameworkPath = None
 
-# The path to lldb is optional
-lldbExecutablePath = None
-
 # The config file is optional.
 configFile = None
 
 # Test suite repeat count.  Can be overwritten with '-# count'.
 count = 1
 
 # The dictionary as a result of sourcing configFile.
 config = {}
def parseOptionsAndInitTestdirs():
     global dont_do_dwarf_test
     global blacklist
     global blacklistConfig
     global categoriesList
     global validCategories
     global useCategories
     global skipCategories
     global lldbFrameworkPath
-    global lldbExecutablePath
     global configFile
     global archs
     global compilers
     global count
     global dumpSysPath
     global bmExecutable
     global bmBreakpointSpec
     global bmIterationCount
if args.plus_m:
             print "Warning: -m and +m can't both be specified! Using only -m"
         else:
             just_do_lldbmi_test = True
 
     if args.framework:
         lldbFrameworkPath = args.framework
 
     if args.executable:
-        lldbExecutablePath = args.executable
+        lldbtest_config.lldbExec = args.executable
 
     if args.libcxx:
         os.environ["LIBCXX_PATH"] = args.libcxx
 
     if args.n:
         noHeaders = True
 
     if args.p:
def setupSysPath():
 
     global rdir
     global testdirs
     global dumpSysPath
     global noHeaders
     global svn_info
     global svn_silent
     global lldbFrameworkPath
-    global lldbExecutablePath
 
     # Get the directory containing the current script.
     if "DOTEST_PROFILE" in os.environ and "DOTEST_SCRIPT_DIR" in os.environ:
         scriptPath = os.environ["DOTEST_SCRIPT_DIR"]
     else:
         scriptPath = os.path.dirname(os.path.realpath(__file__))
     if not scriptPath.endswith('test'):
         print "This script expects to reside in lldb's test directory."
def setupSysPath():
     dbc = ['DebugClang']
     rel = ['Release']
     bai = ['BuildAndIntegration']
     python_resource_dir = ['LLDB.framework', 'Resources', 'Python']
 
     # Some of the tests can invoke the 'lldb' command directly.
     # We'll try to locate the appropriate executable right here.
 
-    lldbExec = None
     lldbMiExec = None
-    lldbHere = None
-    if lldbExecutablePath:
-        if is_exe(lldbExecutablePath):
-            lldbExec = lldbExecutablePath
-            lldbHere = lldbExec
-        else:
-            print lldbExecutablePath + " is not an executable, lldb tests will fail."
-    else:
+
+    # The lldb executable can be set from the command line
+    # if it's not set, we try to find it now
+    # first, we try the environment
+    if not lldbtest_config.lldbExec:
         # First, you can define an environment variable LLDB_EXEC specifying the
         # full pathname of the lldb executable.
-        if "LLDB_EXEC" in os.environ and is_exe(os.environ["LLDB_EXEC"]):
-            lldbExec = os.environ["LLDB_EXEC"]
-        else:
-            lldbExec = None
-    
+        if "LLDB_EXEC" in os.environ:
+            lldbtest_config.lldbExec = os.environ["LLDB_EXEC"]
+    if not lldbtest_config.lldbExec:
         executable = ['lldb']
         dbgExec  = os.path.join(base, *(xcode3_build_dir + dbg + executable))
         dbgExec2 = os.path.join(base, *(xcode4_build_dir + dbg + executable))
         dbcExec  = os.path.join(base, *(xcode3_build_dir + dbc + executable))
         dbcExec2 = os.path.join(base, *(xcode4_build_dir + dbc + executable))
         relExec  = os.path.join(base, *(xcode3_build_dir + rel + executable))
         relExec2 = os.path.join(base, *(xcode4_build_dir + rel + executable))
         baiExec  = os.path.join(base, *(xcode3_build_dir + bai + executable))
         baiExec2 = os.path.join(base, *(xcode4_build_dir + bai + executable))
     
         # The 'lldb' executable built here in the source tree.
         if is_exe(dbgExec):
-            lldbHere = dbgExec
+            lldbtest_config.lldbExec = dbgExec
         elif is_exe(dbgExec2):
-            lldbHere = dbgExec2
+            lldbtest_config.lldbExec = dbgExec2
         elif is_exe(dbcExec):
-            lldbHere = dbcExec
+            lldbtest_config.lldbExec = dbcExec
         elif is_exe(dbcExec2):
-            lldbHere = dbcExec2
+            lldbtest_config.lldbExec = dbcExec2
         elif is_exe(relExec):
-            lldbHere = relExec
+            lldbtest_config.lldbExec = relExec
         elif is_exe(relExec2):
-            lldbHere = relExec2
+            lldbtest_config.lldbExec = relExec2
         elif is_exe(baiExec):
-            lldbHere = baiExec
+            lldbtest_config.lldbExec = baiExec
         elif is_exe(baiExec2):
-            lldbHere = baiExec2
-        elif lldbExec:
-            lldbHere = lldbExec
-
-        # One last chance to locate the 'lldb' executable.
-        if not lldbExec:
-            lldbExec = which('lldb')
-            if lldbHere and not lldbExec:
-                lldbExec = lldbHere
-            if lldbExec and not lldbHere:
-                lldbHere = lldbExec
-    
-    if lldbHere:
-        os.environ["LLDB_HERE"] = lldbHere
-        lldbLibDir = os.path.split(lldbHere)[0]  # confusingly, this is the "bin" directory
-        os.environ["LLDB_LIB_DIR"] = lldbLibDir
-        lldbImpLibDir = os.path.join(lldbLibDir, '..', 'lib') if sys.platform.startswith('win32') else lldbLibDir
-        os.environ["LLDB_IMPLIB_DIR"] = lldbImpLibDir
-        if not noHeaders:
-            print "LLDB library dir:", os.environ["LLDB_LIB_DIR"]
-            print "LLDB import library dir:", os.environ["LLDB_IMPLIB_DIR"]
-            os.system('%s -v' % lldbHere)
-
-    if not lldbExec:
-        print "The 'lldb' executable cannot be located.  Some of the tests may not be run as a result."
-    else:
-        os.environ["LLDB_EXEC"] = lldbExec
-        #print "The 'lldb' from PATH env variable", lldbExec
+            lldbtest_config.lldbExec = baiExec2
+        elif lldbtest_config.lldbExec:
+            lldbtest_config.lldbExec = lldbtest_config.lldbExec
+
+    if not lldbtest_config.lldbExec:
+        # Last, check the path
+        lldbtest_config.lldbExec = which('lldb')
+
+    if lldbtest_config.lldbExec and not is_exe(lldbtest_config.lldbExec):
+        print "'{}' is not a path to a valid executable"
+        del lldbtest_config.lldbExec
+    if not lldbtest_config.lldbExec:
+        print "The 'lldb' executable cannot be located.  Some of the tests may not be run as a result."
+        sys.exit(-1)
+
+    lldbLibDir = os.path.dirname(lldbtest_config.lldbExec)  # confusingly, this is the "bin" directory
+        os.system('%s -v' % lldbtest_config.lldbExec)
 
     # Assume lldb-mi is in same place as lldb
     # If not found, disable the lldb-mi tests
     global dont_do_lldbmi_test
-    if lldbExec and is_exe(lldbExec + "-mi"):
-        lldbMiExec = lldbExec + "-mi"
+    if lldbtest_config.lldbExec and is_exe(lldbtest_config.lldbExec + "-mi"):
+        lldbMiExec = lldbtest_config.lldbExec + "-mi"
     if not lldbMiExec:
         dont_do_lldbmi_test = True
         if just_do_lldbmi_test:
             print "The 'lldb-mi' executable cannot be located.  The lldb-mi tests can not be run as a result."
         else:
             print "The 'lldb-mi' executable cannot be located.  Some of the tests may not be run as a result."
     else:
         os.environ["LLDBMI_EXEC"] = lldbMiExec
if lldbFrameworkPath:
             sys.exit(-1)
     else:
         # The '-i' option is used to skip looking for lldb.py in the build tree.
         if ignore:
             return
         
         # If our lldb supports the -P option, use it to find the python path:
         init_in_python_dir = os.path.join('lldb', '__init__.py')
-        lldb_dash_p_result = None
 
-        lldbExecutable = lldbHere if lldbHere else lldbExec
-        if lldbExecutable:
-            lldb_dash_p_result = subprocess.check_output([lldbExecutable, "-P"], stderr=subprocess.STDOUT)
+        lldb_dash_p_result = subprocess.check_output([lldbtest_config.lldbExec, "-P"], stderr=subprocess.STDOUT)
 
         if lldb_dash_p_result and not lldb_dash_p_result.startswith(("<", "lldb: invalid option:")) \
                 and not lldb_dash_p_result.startswith("Traceback"):
             lines = lldb_dash_p_result.splitlines()
 
             # Workaround for readline vs libedit issue on FreeBSD.  If stdout
             # is not a terminal Python executes
             #     rl_variable_bind ("enable-meta-key", "off");

test/driver/batch_mode/TestBatchMode.py

class DriverBatchModeTest (TestBase):
 
 
     def batch_mode (self):
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
 
         # First time through, pass CRASH so the process will crash and stop in batch mode.
         run_commands = ' -b -o "break set -n main" -o "run" -o "continue" -k "frame var touch_me_not"'
-        self.child = pexpect.spawn('%s %s %s %s -- CRASH' % (self.lldbHere, self.lldbOption, run_commands, exe))
+        self.child = pexpect.spawn('%s %s %s %s -- CRASH' % (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # We should see the "run":
         self.expect_string ("run")
         # We should have hit the breakpoint & continued:
         self.expect_string ("continue")
         # The App should have crashed:
         self.expect_string("About to crash")
         # The -k option should have printed the frame variable once:
         self.expect_string ('(char *) touch_me_not')
         # Then we should have a live prompt:
         self.expect_string (prompt)
         self.child.sendline("frame variable touch_me_not")
         self.expect_string ('(char *) touch_me_not')
         
         self.deletePexpectChild()
 
         # Now do it again, and see make sure if we don't crash, we quit:
         run_commands = ' -b -o "break set -n main" -o "run" -o "continue" '
-        self.child = pexpect.spawn('%s %s %s %s -- NOCRASH' % (self.lldbHere, self.lldbOption, run_commands, exe))
+        self.child = pexpect.spawn('%s %s %s %s -- NOCRASH' % (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # We should see the "run":
         self.expect_string ("run")
         # We should have hit the breakpoint & continued:

test/functionalities/command_regex/TestCommandRegex.py

class CommandRegexTestCase(TestBase):
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_command_regex(self):
         """Test a simple scenario of 'command regex' invocation and subsequent use."""
         import pexpect
         prompt = "(lldb) "
         regex_prompt = "Enter one of more sed substitution commands in the form: 's/<regex>/<subst>/'.\r\nTerminate the substitution list with an empty line.\r\n"
         regex_prompt1 = "\r\n"
 
-        child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
+        child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
         # So that the spawned lldb session gets shutdown durng teardown.
         self.child = child
 
         # Substitute 'Help!' for 'help' using the 'commands regex' mechanism.
         child.expect_exact(prompt)

test/functionalities/completion/TestCompletion.py

def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
         # later on.
         if not isinstance(patterns, list):
             patterns = [patterns]
         
         # The default lldb prompt.
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn(self.lldbHere,
+        self.child = pexpect.spawn(lldbtest_config.lldbExec,
                                    [self.lldbOption] + ['--no-use-colors'])
         child = self.child
         # Turn on logging for input/output to/from the child.
         with open('child_send.txt', 'w') as f_send:
             with open('child_read.txt', 'w') as f_read:
                 child.logfile_send = f_send
                 child.logfile_read = f_read
 

test/functionalities/embedded_interpreter/TestConvenienceVariables.py

class ConvenienceVariablesCase(TestBase):
     def convenience_variables(self):
         """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         python_prompt = ">>> "
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # Set the breakpoint, run the inferior, when it breaks, issue print on
         # the various convenience variables.
         child.expect_exact(prompt)

test/functionalities/format/TestFormats.py

class TestFormats(TestBase):
 
     @expectedFailureFreeBSD("llvm.org/pr22784: pexpect failing on the FreeBSD buildbot")
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_formats(self):
         """Test format string functionality."""
         self.buildDwarf ()
         import pexpect
         prompt = "(lldb) "
-        child = pexpect.spawn('%s %s -x -o "b main" -o r a.out' % (self.lldbHere, self.lldbOption))
+        child = pexpect.spawn('%s %s -x -o "b main" -o r a.out' % (lldbtest_config.lldbExec, self.lldbOption))
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
         # So that the spawned lldb session gets shutdown durng teardown.
         self.child = child
 
         # Substitute 'Help!' for 'help' using the 'commands regex' mechanism.
         child.expect_exact(prompt + 'target create "a.out"') 

test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py

def test_lldb_invocation_with_single_quote_in_filename(self):
         import pexpect
         self.buildDefault()
         system([["cp", "a.out", "\"%s\"" % self.myexe]])
 
         # The default lldb prompt.
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s "%s"' % (self.lldbHere, self.lldbOption, self.myexe))
+        self.child = pexpect.spawn('%s %s "%s"' % (lldbtest_config.lldbExec, self.lldbOption, self.myexe))
         child = self.child
         child.setecho(True)
         # Turn on logging for input/output to/from the child.
         with open('child_send.txt', 'w') as f_send:
             with open('child_read.txt', 'w') as f_read:
                 child.logfile_send = f_send
                 child.logfile_read = f_read
 

test/functionalities/stop-hook/TestStopHookMechanism.py

def stop_hook_firing(self):
         """Test the stop-hook mechanism."""
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         add_prompt = "Enter your stop hook command(s).  Type 'DONE' to end."
         add_prompt1 = "> "
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # Set the breakpoint, followed by the target stop-hook commands.
         child.expect_exact(prompt)
         child.sendline('breakpoint set -f main.cpp -l %d' % self.begl)

test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

class StopHookForMultipleThreadsTestCase(TestBase):
 
     def stop_hook_multiple_threads(self):
         """Test that lldb stop-hook works for multiple threads."""
         import pexpect
         exe = os.path.join(os.getcwd(), self.exe_name)
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
-        self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
+        self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # Set the breakpoint, followed by the target stop-hook commands.
         child.expect_exact(prompt)
         child.sendline('breakpoint set -f main.cpp -l %d' % self.first_stop)

test/lldbpexpect.py

def setUp(self):
         TestBase.setUp(self)
 
     def launchArgs(self):
         pass
 
     def launch(self, timeout=None):
         if timeout is None: timeout = 30
         logfile = sys.stdout if self.TraceOn() else None
-        self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.launchArgs()), logfile=logfile)
+        self.child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.launchArgs()), logfile=logfile)
         self.child.timeout = timeout
         self.timeout = timeout
 
     def expect(self, patterns=None, timeout=None, exact=None):
         if patterns is None: return None
         if timeout is None: timeout = self.timeout
         if exact is None: exact = False
         if exact:

test/lldbtest.py

def setUp(self):
         #import traceback
         #traceback.print_stack()
 
         if "LIBCXX_PATH" in os.environ:
             self.libcxxPath = os.environ["LIBCXX_PATH"]
         else:
             self.libcxxPath = None
 
-        if "LLDB_EXEC" in os.environ:
-            self.lldbExec = os.environ["LLDB_EXEC"]
-        else:
-            self.lldbExec = None
         if "LLDBMI_EXEC" in os.environ:
             self.lldbMiExec = os.environ["LLDBMI_EXEC"]
         else:
             self.lldbMiExec = None
             self.dont_do_lldbmi_test = True
-        if "LLDB_HERE" in os.environ:
-            self.lldbHere = os.environ["LLDB_HERE"]
-        else:
-            self.lldbHere = None
+
         # If we spawn an lldb process for test (via pexpect), do not load the
         # init file unless told otherwise.
         if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
             self.lldbOption = ""
         else:
             self.lldbOption = "--no-lldbinit"
 
         # Assign the test method name to self.testMethodName.
def getArchitecture(self):
         return arch
 
     def getLldbArchitecture(self):
         """Returns the architecture of the lldb binary."""
         if not hasattr(self, 'lldbArchitecture'):
 
             # spawn local process
             command = [
-                self.lldbHere,
+                lldbtest_config.lldbExec,
                 "-o",
-                "file " + self.lldbHere,
+                "file " + lldbtest_config.lldbExec,
                 "-o",
                 "quit"
             ]
 
             output = check_output(command)
             str = output.decode("utf-8");
 
             for line in str.splitlines():
def findBuiltClang(self):
         ]
         lldb_root_path = os.path.join(os.path.dirname(__file__), "..")
         for p in paths_to_try:
             path = os.path.join(lldb_root_path, p)
             if os.path.exists(path):
                 return path
 
         # Tries to find clang at the same folder as the lldb
-        path = os.path.join(os.path.dirname(self.lldbExec), "clang")
+        path = os.path.join(os.path.dirname(lldbtest_config.lldbExec), "clang")
         if os.path.exists(path):
             return path
         
         return os.environ["CC"]
 
     def getBuildFlags(self, use_cpp11=True, use_libcxx=False, use_libstdcxx=False):
         """ Returns a dictionary (which can be provided to build* functions above) which
             contains OS-specific build flags.

test/lldbtest_config.py

 # array of strings
 # each string has the name of an lldb channel followed by
 # zero or more categories in that channel
 # ex. "gdb-remote packets"
 channels = []
 
 # leave logs/traces even for successful test runs
 log_success = False
+
+# path to the lldb command line executable tool
+lldbExec = None
+

test/terminal/TestSTTYBeforeAndAfter.py

def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
                 child.expect(expect_prompt)
 
         # Now that the stage1 logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None
         child.logfile_read = None
 
         # Invoke the lldb command.
-        child.sendline('%s %s' % (self.lldbHere, self.lldbOption))
+        child.sendline('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))
         child.expect_exact(lldb_prompt)
 
         # Immediately quit.
         child.sendline('quit')
         child.expect(expect_prompt)
 
         with open('child_send2.txt', 'w') as f_send2:
             with open('child_read2.txt', 'w') as f_read2:

test/tools/lldb-server/lldbgdbserverutils.py

Args:
         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
-    else:
-        return None
+
+    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
+
 
 
 def get_lldb_server_exe():
     """Return the lldb-server exe path.
 
     Returns:
-        A path to the lldb-gdbserver exe if it is found to exist; otherwise,
+        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"]
-    elif "LLDB_EXEC" in os.environ:
-        lldb_exe = os.environ["LLDB_EXEC"]
-        if not lldb_exe:
-            return None
-        else:
-            return _get_debug_monitor_from_lldb(lldb_exe, "lldb-server")
-    else:
-        return None
+
 
 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"]
-    elif "LLDB_EXEC" in os.environ:
-        lldb_exe = os.environ["LLDB_EXEC"]
-        if not lldb_exe:
-            return None
-        else:
-            return _get_debug_monitor_from_lldb(lldb_exe, "debugserver")
-    else:
-        return None
 
+    return _get_debug_monitor_from_lldb(lldbtest_config.lldbExec, "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.