[TestLoadUnload] Enable for Android while skipping it for other remotes.

[sivachandra]

Summary

This change adds all the necessary infrastructure required to
selectively enable and make TestLoadUnload work for Android. One test,
which tests the module search paths, is still kept disabled for remote
as search paths (because of module caching) are local anyway.

[sivachandra]

This is WiP, please ignore until I add reviewers.

[sivachandra]

Ready for review.

[sivachandra]

Address an offline comment and make a slight improvement.

[tberghammer]

Why do you enable these tests only on remote Android? I think they should work on any remote target with your fix (where the test makes sense)

test/functionalities/load_unload/TestLoadUnload.py

59

I think this will fail in case of Windows -> Android (wrong path separator). You can use SBPlatform::MakeDirectory what should work in all cases

176

Same here

[sivachandra]

Address comments.

[sivachandra]

I have enabled this test for only Android as I have verified it only for Android.

[tberghammer]

Looks good

[emaste]

test/lldbtest.py

738

Please call this skipUnless... for consistency with other skip decorators.

[sivachandra]

Rename skipIfUnlistedRemote to skipUnlessListedRemote.

test/functionalities/load_unload/Makefile

 all: a.out $(LIB_A) $(LIB_B) $(LIB_C) $(LIB_D) hidden/$(LIB_D)
 
 a.out: main.o $(LIB_D)
   $(CC) $(CFLAGS) -o a.out main.o -L. -lloadunload_d $(LIB_DL)
 
 main.o: main.c
   $(CC) $(CFLAGS) -c main.c
 
-hidden/$(LIB_D): b.o
-  $(CC) $(CFLAGS) $(LD_FLAGS) -o hidden/$(LIB_D) d.o
+hidden/$(LIB_D): dh.o
+  $(CC) $(CFLAGS) $(LD_FLAGS) -o hidden/$(LIB_D) dh.o
   if [ "$(OS)" = "Darwin" ]; then dsymutil -o hidden/$(LIB_D).dSYM hidden/$(LIB_D); fi
 
 $(LIB_A): a.o $(LIB_B)
   $(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_A) -o $(LIB_A) a.o -L. -lloadunload_b
   if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_A); fi
 
 a.o: a.c
   $(CC) $(CFLAGS) -c a.c

 
 $(LIB_D): d.o
   $(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_D) -o $(LIB_D) d.o
   if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_D); fi
 
 d.o: d.c
   $(CC) $(CFLAGS) -c d.c
 
+dh.o: d.c
+  $(CC) $(CFLAGS) -DHIDDEN -c d.c -o dh.o
+
 clean:
   rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM hidden/*)

test/functionalities/load_unload/TestLoadUnload.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.c',
                                 '// Set break point at this line for test_lldb_process_load_and_unload_commands().')
         self.line_d_function = line_number('d.c',
                                            '// Find this line number within d_dunction().')
         if not self.platformIsDarwin():
-            if "LD_LIBRARY_PATH" in os.environ:
+            if not lldb.remote_platform and "LD_LIBRARY_PATH" in os.environ:
                 self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.environ["LD_LIBRARY_PATH"] + ":" + os.getcwd())
             else:
-                self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + os.getcwd())
+                if lldb.remote_platform:
+                    wd = lldb.remote_platform.GetWorkingDirectory()
+                else:
+                    wd = os.getcwd()
+                self.runCmd("settings set target.env-vars " + self.dylibPath + "=" + wd)
+
+    def copy_shlibs_to_remote(self, hidden_dir=False):
+        """ Copies the shared libs required by this test suite to remote.
+        Does nothing in case of non-remote platforms.
+        """
+        if lldb.remote_platform:
+            cwd = os.getcwd()
+            shlibs = ['libloadunload_a.so', 'libloadunload_b.so',
+                      'libloadunload_c.so', 'libloadunload_d.so']
+            wd = lldb.remote_platform.GetWorkingDirectory()
+            for f in shlibs:
+                err = lldb.remote_platform.Put(
+                    lldb.SBFileSpec(os.path.join(cwd, f)),
+                    lldb.SBFileSpec(os.path.join(wd, f)))
+                if err.Fail():
+                    raise RuntimeError(
+                        "Unable copy '%s' to '%s'.\n>>> %s" %
+                        (f, wd, err.GetCString()))
+            if hidden_dir:
+                shlib = 'libloadunload_d.so'
+                hidden_dir = os.path.join(wd, 'hidden')
+                hidden_file = os.path.join(hidden_dir, shlib)
+                err = lldb.remote_platform.MakeDirectory(hidden_dir)
+                if err.Fail():
+                    raise RuntimeError(
+                        "Unable to create a directory '%s'." % hidden_dir)
+                err = lldb.remote_platform.Put(
+                    lldb.SBFileSpec(os.path.join(cwd, 'hidden', shlib)),
+                    lldb.SBFileSpec(hidden_file))
+                if err.Fail():
+                    raise RuntimeError(
+                        "Unable copy 'libloadunload_d.so' to '%s'.\n>>> %s" %
+                        (wd, err.GetCString()))
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @not_remote_testsuite_ready
     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'."""
 
         # Invoke the default build rule.
         self.buildDefault()
def test_modules_search_paths(self):
         self.addTearDownHook(lambda: self.dbg.HandleCommand(remove_dyld_path_cmd))
 
         self.runCmd("run")
 
         self.expect("target modules list", "LLDB successfully locates the relocated dynamic library",
             substrs = [new_dylib])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @not_remote_testsuite_ready
+    @skipUnlessListedRemote(['android'])
     def test_dyld_library_path(self):
         """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
 
         # Invoke the default build rule.
         self.buildDefault()
+        self.copy_shlibs_to_remote(hidden_dir=True)
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'
             dsymName = 'libloadunload_d.dylib.dSYM'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory to relocate the dynamic library and its debugging info.
         special_dir = "hidden"
-        new_dir = os.path.join(os.getcwd(), special_dir)
-
-        old_dylib = os.path.join(os.getcwd(), dylibName)
-        new_dylib = os.path.join(new_dir, dylibName)
-
-        #system(["ls", "-lR", "."])
-
-        # Try running with the (DY)LD_LIBRARY_PATH environment variable set, make sure
-        # we pick up the hidden dylib.
-
-        env_cmd_string = "settings set target.env-vars " + self.dylibPath + "=" + new_dir
-        if not self.platformIsDarwin():
-            env_cmd_string += ":" + os.getcwd()
+        if lldb.remote_platform:
+            wd = lldb.remote_platform.GetWorkingDirectory()
+        else:
+            wd = os.getcwd()
 
-        if self.TraceOn():
-            print "Set environment to: ", env_cmd_string
-        self.runCmd(env_cmd_string)
-        self.runCmd("settings show target.env-vars")
+        old_dir = wd
+        new_dir = os.path.join(wd, special_dir)
+        old_dylib = os.path.join(old_dir, dylibName)
 
         remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath
         self.addTearDownHook(lambda: self.dbg.HandleCommand(remove_dyld_path_cmd))
 
-        lldbutil.run_break_set_by_file_and_line (self, "d.c", self.line_d_function, num_expected_locations=1, loc_exact=True)
-
         # For now we don't track (DY)LD_LIBRARY_PATH, so the old library will be in
         # the modules list.
         self.expect("target modules list",
                     substrs = [os.path.basename(old_dylib)],
                     matching=True)
 
-        self.runCmd("run")
-        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
-            patterns = ["frame #0.*d_function.*at d.c:%d" % self.line_d_function])
+        lldbutil.run_break_set_by_file_and_line (self, "d.c", self.line_d_function, num_expected_locations=1)
+        # After run, make sure the non-hidden library is picked up.
+        self.expect("run", substrs=["return", "700"])
 
-        # After run, make sure the hidden library is present, and the one we didn't 
-        # load is not.
-        self.expect("target modules list",
-            substrs = [special_dir, os.path.basename(new_dylib)])
+        self.runCmd("continue")
+
+        # Add the hidden directory first in the search path.
+        env_cmd_string = ("settings set target.env-vars %s=%s" %
+                          (self.dylibPath, new_dir))
+        if not self.platformIsDarwin():
+            env_cmd_string += ":" + wd
+        self.runCmd(env_cmd_string)
+
+        # This time, the hidden library should be picked up.
+        self.expect("run", substrs=["return", "12345"])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @not_remote_testsuite_ready
+    @skipUnlessListedRemote(['android'])
     @unittest2.expectedFailure("rdar://15367406")
     def test_lldb_process_load_and_unload_commands(self):
         """Test that lldb process load/unload command work correctly."""
 
         # Invoke the default build rule.
         self.buildDefault()
+        self.copy_shlibs_to_remote()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break at main.c 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.c", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_FAILED)
 
+        if lldb.remote_platform:
+            shlib_dir = lldb.remote_platform.GetWorkingDirectory()
+        else:
+            shlib_dir = self.mydir
         # 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 .* %s" % self.mydir])
+            patterns = ["1 match found .* %s" % shlib_dir])
 
-        if self.platformIsDarwin():
+        if lldb.remote_platform:
+            dylibName = os.path.join(shlib_dir, 'libloadunload_a.so')
+        elif self.platformIsDarwin():
             dylibName = 'libloadunload_a.dylib'
         else:
             dylibName = 'libloadunload_a.so'
 
         # Use lldb 'process load' to load the dylib.
         self.expect("process load %s" % dylibName, "%s loaded correctly" % dylibName,
             patterns = ['Loading "%s".*ok' % dylibName,
                         '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)
             if match:
                 break
         index = match.group(1)
 
         # Now we should have an entry for a_function.
         self.expect("image lookup -n a_function", "a_function should now exist",
-            patterns = ["1 match found .*%s" % self.mydir])
+            patterns = ["1 match found .*%s" % shlib_dir])
 
         # Use lldb 'process unload' to unload the dylib.
         self.expect("process unload %s" % index, "%s unloaded correctly" % dylibName,
             patterns = ["Unloading .* with index %s.*ok" % index])
 
         self.runCmd("process continue")
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @not_remote_testsuite_ready
+    @skipUnlessListedRemote(['android'])
     def test_load_unload(self):
         """Test breakpoint by name works correctly with dlopen'ing."""
 
         # Invoke the default build rule.
         self.buildDefault()
+        self.copy_shlibs_to_remote()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break by function name a_function (not yet loaded).
         lldbutil.run_break_set_by_symbol (self, "a_function", num_expected_locations=0)
 
         self.runCmd("run", RUN_FAILED)
def test_load_unload(self):
                        'a_function',
                        'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 2.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
             substrs = [' resolved, hit count = 2'])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @not_remote_testsuite_ready
+    @skipUnlessListedRemote(['android'])
     def test_step_over_load (self):
         """Test stepping over code that loads a shared library works correctly."""
 
         # Invoke the default build rule.
         self.buildDefault()
+        self.copy_shlibs_to_remote()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break by function name a_function (not yet loaded).
         lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_FAILED)

test/functionalities/load_unload/d.c

 //===-- c.c -----------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 int
 d_function ()
-{
-    return 700; // Find this line number within d_dunction().
+{ // Find this line number within d_dunction().
+#ifdef HIDDEN
+    return 12345;
+#else
+    return 700;
+#endif
 }

test/lldbtest.py

def wrapper(*args, **kwargs):
         from unittest2 import case
         if lldb.remote_platform:
             self = args[0]
             self.skipTest("skip on remote platform")
         else:
             func(*args, **kwargs)
     return wrapper
 
+def skipUnlessListedRemote(remote_list=None):
+    def myImpl(func):
+        if isinstance(func, type) and issubclass(func, unittest2.TestCase):
+            raise Exception("@skipIfRemote can only be used to decorate a "
+                            "test method")
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if remote_list and lldb.remote_platform:
+                self = args[0]
+                triple = self.dbg.GetSelectedPlatform().GetTriple()
+                for r in remote_list:
+                    if r in triple:
+                        func(*args, **kwargs)
+                        return
+                self.skipTest("skip on remote platform %s" % str(triple))
+            else:
+                func(*args, **kwargs)
+        return wrapper
+
+    return myImpl
+
 def skipIfRemoteDueToDeadlock(func):
     """Decorate the item to skip tests if testing remotely due to the test deadlocking."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfRemote can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):
         from unittest2 import case
         if lldb.remote_platform: