182 lines
6.5 KiB
Python
182 lines
6.5 KiB
Python
"""
|
|
The LLVM Compiler Infrastructure
|
|
|
|
This file is distributed under the University of Illinois Open Source
|
|
License. See LICENSE.TXT for details.
|
|
|
|
Sync lldb and related source from a local machine to a remote machine.
|
|
|
|
This facilitates working on the lldb sourcecode on multiple machines
|
|
and multiple OS types, verifying changes across all.
|
|
|
|
Provides helper support for adding lldb test paths to the python path.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
from __future__ import absolute_import
|
|
|
|
# System modules
|
|
import os
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
|
|
# Third-party modules
|
|
|
|
# LLDB modules
|
|
|
|
|
|
def add_lldb_test_paths(check_dir):
|
|
# pylint: disable=line-too-long
|
|
"""Adds lldb test-related paths to the python path.
|
|
|
|
Starting with the given directory and working upward through
|
|
each parent directory up to the root, it looks for the lldb
|
|
test directory. When found, the lldb test directory and its
|
|
child test_runner/lib directory will be added to the python
|
|
system path.
|
|
|
|
Instructions for use:
|
|
|
|
This method supports a simple way of getting pylint to be able
|
|
to reliably lint lldb python test scripts (including the test
|
|
infrastructure itself). To do so, add the following to a
|
|
.pylintrc file in your home directory:
|
|
|
|
[Master]
|
|
init-hook='import os; import sys; sys.path.append(os.path.expanduser("~/path/to/lldb/packages/Python/lldbsuite/test")); import lldb_pylint_helper; lldb_pylint_helper.add_lldb_test_paths(os.getcwd()); print("sys.path={}\n".format(sys.path))'
|
|
|
|
Replace ~/path/to/lldb with a valid path to your local lldb source
|
|
tree. Note you can have multiple lldb source trees on your system, and
|
|
this will work just fine. The path in your .pylintrc is just needed to
|
|
find the paths needed for pylint in whatever lldb source tree you're in.
|
|
pylint will use the python files in whichever tree it is run from.
|
|
|
|
Note it is critical that the init-hook line be contained on a single line.
|
|
You can remove the print line at the end once you know the pythonpath is
|
|
getting set up the way you expect.
|
|
|
|
With these changes, you will be able to run the following, for example.
|
|
|
|
cd lldb/sourcetree/1-of-many/test/lang/c/anonymous
|
|
pylint TestAnonymous.py
|
|
|
|
This will work, and include all the lldb/sourcetree/1-of-many lldb-specific
|
|
python directories to your path.
|
|
|
|
You can then run it in another lldb source tree on the same machine like
|
|
so:
|
|
|
|
cd lldb/sourcetree/2-of-many/test/functionalities/inferior-assert
|
|
pyline TestInferiorAssert.py
|
|
|
|
and this will properly lint that file, using the lldb-specific python
|
|
directories from the 2-of-many source tree.
|
|
|
|
Note at the time I'm writing this, our tests are in pretty sad shape
|
|
as far as a stock pylint setup goes. But we need to start somewhere :-)
|
|
|
|
@param check_dir specifies a directory that will be used to start
|
|
looking for the lldb test infrastructure python library paths.
|
|
"""
|
|
# Add the test-related packages themselves.
|
|
add_lldb_test_package_paths(check_dir)
|
|
|
|
# Add the lldb directory itself
|
|
add_lldb_module_directory()
|
|
|
|
|
|
def add_lldb_module_directory():
|
|
"""
|
|
Desired Approach:
|
|
|
|
Part A: find an lldb
|
|
|
|
1. Walk up the parent chain from the current directory, looking for
|
|
a directory matching *build*. If we find that, use it as the
|
|
root of a directory search for an lldb[.exe] executable.
|
|
|
|
2. If 1 fails, use the path and look for an lldb[.exe] in there.
|
|
|
|
If Part A ends up with an lldb, go to part B. Otherwise, give up
|
|
on the lldb python module path.
|
|
|
|
Part B: use the output from 'lldb[.exe] -P' to find the lldb dir.
|
|
|
|
Current approach:
|
|
If Darwin, use 'xcrun lldb -P'; others: find lldb on path.
|
|
|
|
Drawback to current approach:
|
|
If the tester is changing the SB API (adding new methods), pylint
|
|
will not know about them as it is using the wrong lldb python module.
|
|
In practice, this should be minor.
|
|
"""
|
|
try:
|
|
lldb_module_path = None
|
|
|
|
if platform.system() == 'Darwin':
|
|
# Use xcrun to find the selected lldb.
|
|
lldb_module_path = subprocess.check_output(["xcrun", "lldb", "-P"])
|
|
elif platform.system() == 'Windows':
|
|
lldb_module_path = subprocess.check_output(
|
|
["lldb.exe", "-P"], shell=True)
|
|
else:
|
|
# Use the shell to run lldb from the path.
|
|
lldb_module_path = subprocess.check_output(
|
|
["lldb", "-P"], shell=True)
|
|
|
|
# Trim the result.
|
|
if lldb_module_path is not None:
|
|
lldb_module_path = lldb_module_path.strip()
|
|
|
|
# If we have a result, add it to the path
|
|
if lldb_module_path is not None and len(lldb_module_path) > 0:
|
|
sys.path.insert(0, lldb_module_path)
|
|
# pylint: disable=broad-except
|
|
except Exception as exception:
|
|
print("failed to find python path: {}".format(exception))
|
|
|
|
|
|
def add_lldb_test_package_paths(check_dir):
|
|
"""Adds the lldb test infrastructure modules to the python path.
|
|
|
|
See add_lldb_test_paths for more details.
|
|
|
|
@param check_dir the directory of the test.
|
|
"""
|
|
|
|
def child_dirs(parent_dir):
|
|
return [os.path.join(parent_dir, child)
|
|
for child in os.listdir(parent_dir)
|
|
if os.path.isdir(os.path.join(parent_dir, child))]
|
|
|
|
check_dir = os.path.realpath(check_dir)
|
|
while check_dir and len(check_dir) > 0:
|
|
# If the current directory contains a packages/Python
|
|
# directory, add that directory to the path.
|
|
packages_python_child_dir = os.path.join(
|
|
check_dir, "packages", "Python")
|
|
if os.path.exists(packages_python_child_dir):
|
|
sys.path.insert(0, packages_python_child_dir)
|
|
sys.path.insert(0, os.path.join(
|
|
packages_python_child_dir, "test_runner", "lib"))
|
|
|
|
# Handle third_party module/package directory.
|
|
third_party_module_dir = os.path.join(
|
|
check_dir, "third_party", "Python", "module")
|
|
for child_dir in child_dirs(third_party_module_dir):
|
|
# Yes, we embed the module in the module parent dir
|
|
sys.path.insert(0, child_dir)
|
|
|
|
# We're done.
|
|
break
|
|
|
|
# Continue looking up the parent chain until we have no more
|
|
# directories to check.
|
|
new_check_dir = os.path.dirname(check_dir)
|
|
# We're done when the new check dir is not different
|
|
# than the current one.
|
|
if new_check_dir == check_dir:
|
|
break
|
|
check_dir = new_check_dir
|