[Test Suite] Properly respect --framework option

[beanz]

Summary

dotest.py has a framework option that is not respected. This patch makes the framework path properly configurable via the --framework option.

This patch also adds a function to the lldbtest.Base class named "hasDarwinFramework" which allows us to not rely on the host platform to determine if a framework is present. If running on Darwin, and not building a framework, this will follow the *nix code paths which are appropriate for Darwin.

[zturner]

Maybe put that function lldbplatformutil?

[tfiala]

Looks good.

I do wonder if we should have a general helper for lines like this:

sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin')

but that doesn't have to be looked at here.

[fjricci]

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

1418 ↗

(On Diff #76351)

Why do we need to make this -L$(lib_dir)/../lib instead of the original -L$(lib_dir)? This breaks cases where lib_dir is lib64 and not lib

[beanz]

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

1418 ↗

(On Diff #76351)

Basically because this is hack on top of hack on top of hack...

Confusingly lib_dir is actually set to the bin dir not the correct setting for lib/lib64. Except if lldb supports the -P flag, and your host is FreeBSD or Linux, in which case we construct the lib path from the python path...

So this change was needed to make Darwin or NetBSD work, but broke FreeBSD and Linux in lib64 configurations... great...

We *really* need to clean up all of this because the garbled mess of platform-specific hacks is a really big problem.

packages/Python/lldbsuite/test/dotest.py

if is_exe(lldbMiExec):
         os.environ["LLDBMI_EXEC"] = lldbMiExec
     else:
         if not configuration.shouldSkipBecauseOfCategories(["lldb-mi"]):
             print(
                 "The 'lldb-mi' executable cannot be located.  The lldb-mi tests can not be run as a result.")
             configuration.skipCategories.append("lldb-mi")
 
     lldbPythonDir = None  # The directory that contains 'lldb/__init__.py'
+    if os.path.exists(os.path.join(lldbLibDir, "LLDB.framework")):
+        configuration.lldbFrameworkPath = lldbLibDir
     if configuration.lldbFrameworkPath:
+        lldbtest_config.lldbFrameworkPath = configuration.lldbFrameworkPath
         candidatePath = os.path.join(
             configuration.lldbFrameworkPath, 'Resources', 'Python')
         if os.path.isfile(os.path.join(candidatePath, 'lldb/__init__.py')):
             lldbPythonDir = candidatePath
         if not lldbPythonDir:
             print(
                 'Resources/Python/lldb/__init__.py was not found in ' +
                 configuration.lldbFrameworkPath)

packages/Python/lldbsuite/test/lldbtest.py

def setUp(self):
         self.res = lldb.SBCommandReturnObject()
 
         self.setPlatformWorkingDir()
         self.enableLogChannelsForCurrentTest()
 
         # Initialize debug_info
         self.debug_info = None
 
+        lib_dir = os.environ["LLDB_LIB_DIR"]
+        self.dsym = None
+        self.framework_dir = None
+        self.darwinWithFramework = self.platformIsDarwin()
+        if sys.platform.startswith("darwin"):
+            # Handle the framework environment variable if it is set
+            if hasattr(lldbtest_config, 'lldbFrameworkPath'):
+                framework_path = lldbtest_config.lldbFrameworkPath
+                # Framework dir should be the directory containing the framework
+                self.framework_dir = framework_path[:framework_path.rfind('LLDB.framework')]
+            # If a framework dir was not specified assume the Xcode build
+            # directory layout where the framework is in LLDB_LIB_DIR.
+            else:
+                self.framework_dir = lib_dir
+            self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB')
+            # If the framework binary doesn't exist, assume we didn't actually
+            # build a framework, and fallback to standard *nix behavior by
+            # setting framework_dir and dsym to None.
+            if not os.path.exists(self.dsym):
+                self.framework_dir = None
+                self.dsym = None
+                self.darwinWithFramework = False
+
     def setAsync(self, value):
         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
         old_async = self.dbg.GetAsync()
         self.dbg.SetAsync(value)
         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
 
     def cleanupSubprocesses(self):
         # Ensure any subprocesses are cleaned up
def getGoCompilerVersion(self):
                 if m:
                     return m.group(1)
         return None
 
     def platformIsDarwin(self):
         """Returns true if the OS triple for the selected platform is any valid apple OS"""
         return lldbplatformutil.platformIsDarwin()
 
+    def hasDarwinFramework(self):
+        return self.darwinWithFramework
+
     def getPlatform(self):
         """Returns the target platform the test suite is running on."""
         return lldbplatformutil.getPlatform()
 
     def isIntelCompiler(self):
         """ Returns true if using an Intel (ICC) compiler, false otherwise. """
         return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
 
def buildDriver(self, sources, exe_name):
         """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
             or LLDB.framework).
         """
 
         stdflag = self.getstdFlag()
         stdlibflag = self.getstdlibFlag()
 
         lib_dir = os.environ["LLDB_LIB_DIR"]
-        if sys.platform.startswith("darwin"):
-            dsym = os.path.join(lib_dir, 'LLDB.framework', 'LLDB')
+        if self.hasDarwinFramework():
             d = {'CXX_SOURCES': sources,
                  'EXE': exe_name,
                  'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
-                 'FRAMEWORK_INCLUDES': "-F%s" % lib_dir,
-                 'LD_EXTRAS': "%s -Wl,-rpath,%s" % (dsym, lib_dir),
+                 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
+                 'LD_EXTRAS': "%s -Wl,-rpath,%s" % (self.dsym, self.framework_dir),
                  }
-        elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
+        elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
             d = {
                 'CXX_SOURCES': sources,
                 'EXE': exe_name,
                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
                                                  stdlibflag,
                                                  os.path.join(
                                                      os.environ["LLDB_SRC"],
                                                      "include")),
-                'LD_EXTRAS': "-L%s -llldb" % lib_dir}
+                'LD_EXTRAS': "-L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
         elif sys.platform.startswith('win'):
             d = {
                 'CXX_SOURCES': sources,
                 'EXE': exe_name,
                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
                                                  stdlibflag,
                                                  os.path.join(
                                                      os.environ["LLDB_SRC"],
                                                      "include")),
                 'LD_EXTRAS': "-L%s -lliblldb" % os.environ["LLDB_IMPLIB_DIR"]}
         if self.TraceOn():
             print(
                 "Building LLDB Driver (%s) from sources %s" %
                 (exe_name, sources))
 
         self.buildDefault(dictionary=d)
 
     def buildLibrary(self, sources, lib_name):
         """Platform specific way to build a default library. """
 
         stdflag = self.getstdFlag()
 
         lib_dir = os.environ["LLDB_LIB_DIR"]
-        if self.platformIsDarwin():
-            dsym = os.path.join(lib_dir, 'LLDB.framework', 'LLDB')
+        if self.hasDarwinFramework():
             d = {'DYLIB_CXX_SOURCES': sources,
                  'DYLIB_NAME': lib_name,
                  'CFLAGS_EXTRAS': "%s -stdlib=libc++" % stdflag,
-                 'FRAMEWORK_INCLUDES': "-F%s" % lib_dir,
-                 'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (dsym, lib_dir),
+                 'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
+                 'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (self.dsym, self.framework_dir),
                  }
-        elif self.getPlatform() in ('freebsd', 'linux', 'netbsd') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
+        elif sys.platform.rstrip('0123456789') in ('freebsd', 'linux', 'netbsd', 'darwin') or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
             d = {
                 'DYLIB_CXX_SOURCES': sources,
                 'DYLIB_NAME': lib_name,
                 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
                                                     os.path.join(
                                                         os.environ["LLDB_SRC"],
                                                         "include")),
-                'LD_EXTRAS': "-shared -L%s -llldb" % lib_dir}
+                'LD_EXTRAS': "-shared -L%s/../lib -llldb -Wl,-rpath,%s/../lib" % (lib_dir, lib_dir)}
         elif self.getPlatform() == 'windows':
             d = {
                 'DYLIB_CXX_SOURCES': sources,
                 'DYLIB_NAME': lib_name,
                 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
                                                     os.path.join(
                                                         os.environ["LLDB_SRC"],
                                                         "include")),

test/CMakeLists.txt

if (NOT LLDB_TEST_HIDE_CONSOLE_WINDOWS)
     set(LLDB_TEST_COMMON_ARGS ${LLDB_TEST_COMMON_ARGS} --show-inferior-console)
   endif()
 endif()
 
 if(LLDB_CODESIGN_IDENTITY)
   list(APPEND LLDB_TEST_COMMON_ARGS --codesign-identity "${LLDB_CODESIGN_IDENTITY}")
 endif()
 
+if(LLDB_BUILD_FRAMEWORK)
+  list(APPEND LLDB_TEST_COMMON_ARGS --framework $<TARGET_FILE_DIR:liblldb>)
+endif()
+
 add_python_test_target(check-lldb-single
   ${LLDB_SOURCE_DIR}/test/dotest.py
   "--no-multiprocess;${LLDB_TEST_COMMON_ARGS};${LLDB_TEST_USER_ARGS}"
   "Testing LLDB with args: ${LLDB_TEST_COMMON_ARGS};${LLDB_TEST_USER_ARGS}"
   )
 
 set(LLDB_DOTEST_ARGS -q;${LLDB_TEST_COMMON_ARGS};${LLDB_TEST_USER_ARGS})
 
 # If tests crash cause LLDB to crash, or things are otherwise unstable, or if machine-parsable
 # output is desired (i.e. in continuous integration contexts) check-lldb-single is a better target.
 add_python_test_target(check-lldb
   ${LLDB_SOURCE_DIR}/test/dotest.py
   "${LLDB_DOTEST_ARGS}"
   "Testing LLDB (parallel execution, with a separate subprocess per test)"
   )