Make D42281 work on linux

[labath]

packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

45 ↗

(On Diff #131562)

This is needed so that the debugger resolves "/proc/self/cwd" the same way as the build system.

packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

89

these tests assume we will be able to find libloadunload_d.so before launching the process, which is often tricky, and it seems it has worked only by accident. I'll have to figure out later whether to update the test or the debugger search logic.

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/Makefile

3

I had to put this back. I am not sure why, but for me the shared libraries end up in the root directory.

[labath]

remote fixes

[labath]

Add windows fixes.

packages/Python/lldbsuite/test/functionalities/load_unload/Makefile

 
 install_name_tool:
 ifeq ($(OS),Darwin)
   install_name_tool -id @executable_path/libloadunload_d.dylib libloadunload_d.dylib
 endif
 
 
 hidden_lib_d:
-  mkdir -p hidden
   $(MAKE) VPATH=$(SRCDIR)/hidden -I $(SRCDIR)/hidden -C hidden -f $(SRCDIR)/hidden/Makefile
 
 clean::
   $(MAKE) -f $(SRCDIR)/a.mk clean
   $(MAKE) -f $(SRCDIR)/b.mk clean
   $(MAKE) -f $(SRCDIR)/c.mk clean
   $(MAKE) -f $(SRCDIR)/d.mk clean
-  mkdir -p hidden
   $(MAKE) -I $(SRCDIR)/hidden -C hidden -f $(SRCDIR)/hidden/Makefile clean

packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

 @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
 class LoadUnloadTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
+        lldbutil.mkdir_p(self.getBuildArtifact("hidden"))
         # Find the line number to break for main.cpp.
         self.line = line_number(
             'main.cpp',
             '// Set break point at this line for test_lldb_process_load_and_unload_commands().')
         self.line_d_function = line_number(
             'd.cpp', '// Find this line number within d_dunction().')
         if not self.platformIsDarwin():
             if not lldb.remote_platform and "LD_LIBRARY_PATH" in os.environ:
def copy_shlibs_to_remote(self, hidden_dir=False):
                 err = lldb.remote_platform.Put(
                     lldb.SBFileSpec(os.path.join('hidden', shlib)),
                     lldb.SBFileSpec(hidden_file))
                 if err.Fail():
                     raise RuntimeError(
                         "Unable copy 'libloadunload_d.so' to '%s'.\n>>> %s" %
                         (wd, err.GetCString()))
 
     # libloadunload_d.so does not appear in the image list because executable
     # dependencies are resolved relative to the debuggers PWD. Bug?
     @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @not_remote_testsuite_ready
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_modules_search_paths(self):
         """Test target modules list after loading a different copy of the library libd.dylib, and verifies that it works with 'target modules search-paths add'."""
 
def test_lldb_process_load_and_unload_commands(self):
         # Break at main.cpp before the call to dlopen().
         # Use lldb's process load command to load the dylib, instead.
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        ctx = self.platformContext
+        dylibName = ctx.shlib_prefix + 'loadunload_a.' + ctx.shlib_extension
+        localDylibPath = self.getBuildArtifact(dylibName)
         if lldb.remote_platform:
-            shlib_dir = lldb.remote_platform.GetWorkingDirectory()
-        else:
-            shlib_dir = self.mydir
-
-        if self.platformIsDarwin():
-            dylibName = self.getBuildArtifact('libloadunload_a.dylib')
+            wd = lldb.remote_platform.GetWorkingDirectory()
+            remoteDylibPath = lldbutil.join_remote_paths(wd, dylibName)
         else:
-            dylibName = self.getBuildArtifact('libloadunload_a.so')
+            remoteDylibPath = localDylibPath
 
         # Make sure that a_function does not exist at this point.
         self.expect(
             "image lookup -n a_function",
             "a_function should not exist yet",
             error=True,
             matching=False,
             patterns=["1 match found"])
 
         # Use lldb 'process load' to load the dylib.
         self.expect(
-            "process load %s --install=%s" %
-            (dylibName, dylibName),
-            "%s loaded correctly" %
-            dylibName,
+            "process load %s --install=%s" % (localDylibPath, remoteDylibPath),
+            "%s loaded correctly" % dylibName,
             patterns=[
-                'Loading "%s".*ok' %
-                dylibName,
+                'Loading "%s".*ok' % localDylibPath,
                 'Image [0-9]+ loaded'])
 
         # Search for and match the "Image ([0-9]+) loaded" pattern.
         output = self.res.GetOutput()
         pattern = re.compile("Image ([0-9]+) loaded")
         for l in output.split(os.linesep):
             #print("l:", l)
             match = pattern.search(l)

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/Makefile

 LEVEL := ../../../make
 
 LD_EXTRAS := -L. -LOne -l$(LIB_PREFIX)One -LTwo -l$(LIB_PREFIX)Two
 C_SOURCES := main.c
 
 include $(LEVEL)/Makefile.rules
 
 .PHONY:
 a.out: lib_One lib_Two
 
 lib_%:
-  mkdir -p $*
   $(MAKE) VPATH=$(SRCDIR)/$* -I $(SRCDIR) -f $(SRCDIR)/$*.mk
 
 clean::
   $(MAKE) -f $(SRCDIR)/One.mk clean
   $(MAKE) -f $(SRCDIR)/Two.mk clean

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/TestConflictingSymbol.py

 from lldbsuite.test import lldbutil
 
 
 class TestConflictingSymbols(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
+    def setUp(self):
+        TestBase.setUp(self)
+        lldbutil.mkdir_p(self.getBuildArtifact("One"))
+        lldbutil.mkdir_p(self.getBuildArtifact("Two"))
+
     def test_conflicting_symbols(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Register our shared libraries for remote targets so they get
         # automatically uploaded

packages/Python/lldbsuite/test/lldbutil.py

 """
 This LLDB module contains miscellaneous utilities.
 Some of the test suite takes advantage of the utility functions defined here.
 They can also be useful for general purpose lldb scripting.
 """
 
 from __future__ import print_function
 from __future__ import absolute_import
 
 # System modules
 import collections
+import errno
 import os
 import re
 import sys
 import time
 
 # Third-party modules
 from six import StringIO as SixStringIO
 import six
if fpath:
             return program
     else:
         for path in os.environ["PATH"].split(os.pathsep):
             exe_file = os.path.join(path, program)
             if is_exe(exe_file):
                 return exe_file
     return None
 
+def mkdir_p(path):
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+    if not os.path.isdir(path):
+        raise OSError(errno.ENOTDIR, "%s is not a directory"%path)
 # ===================================================
 # Disassembly for an SBFunction or an SBSymbol object
 # ===================================================
 
 
 def disassemble(target, function_or_symbol):
     """Disassemble the function or symbol given a target.
 

packages/Python/lldbsuite/test/make/Makefile.rules

 # And test/functionalities/archives/Makefile:
 # MAKE_DSYM := NO
 # ARCHIVE_NAME := libfoo.a
 # ARCHIVE_C_SOURCES := a.c b.c
 
 # Uncomment line below for debugging shell commands
 # SHELL = /bin/sh -x
 
-SRCDIR := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))/
-THIS_FILE_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+SRCDIR := $(shell dirname $(firstword $(MAKEFILE_LIST)))/
+THIS_FILE_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/
 LLDB_BASE_DIR := $(THIS_FILE_DIR)../../../../../
 
 
 #----------------------------------------------------------------------
 # If OS is not defined, use 'uname -s' to determine the OS name.
 #
 # uname on Windows gives "windows32", but most environments standardize
 # on "Windows_NT", so we'll make it consistent here.  When running

packages/Python/lldbsuite/test/settings/quoting/TestQuoting.py

class SettingsCommandTestCase(TestBase):
     def do_test_args(self, args_in, args_out):
         """Test argument parsing. Run the program with args_in. The program dumps its arguments
         to stdout. Compare the stdout with args_out."""
         self.buildDefault(testdir=self.mydir)
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        outfile = self.getBuildArtifact("output.txt")
-        self.runCmd("process launch -- %s %s" %(outfile, args_in))
+        local_outfile = self.getBuildArtifact("output.txt")
+        if lldb.remote_platform:
+            remote_outfile = "output.txt" # Relative to platform's PWD
+        else:
+            remote_outfile = local_outfile
+
+        self.runCmd("process launch -- %s %s" %(remote_outfile, args_in))
 
         if lldb.remote_platform:
-            src_file_spec = lldb.SBFileSpec(outfile, False)
-            dst_file_spec = lldb.SBFileSpec(outfile, True)
+            src_file_spec = lldb.SBFileSpec(remote_outfile, False)
+            dst_file_spec = lldb.SBFileSpec(local_outfile, True)
             lldb.remote_platform.Get(src_file_spec, dst_file_spec)
 
-        with open(outfile, 'r') as f:
+        with open(local_outfile, 'r') as f:
             output = f.read()
 
-        self.RemoveTempFile(outfile)
+        self.RemoveTempFile(local_outfile)
 
         self.assertEqual(output, args_out)