mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-01-10 18:11:19 +00:00
c3d0165c49
A combination of broken escaping in CMake and in the python swig generation scripts meant that the swig generation step would fail whenever there were spaces or special characters in parameters passed to swig. The fix for this in CMakeLists is to use the VERBATIM option on all COMMAND-based custom builders relying on CMake to properly escape each argument in the generated file. Within the python swig scripts, the fix is to call subprocess.Popen with a list of raw argument strings rather than ones that are incorrectly manually escaped, then passed to a shell subprocess via subprocess.Popen(' '.join(params)). This also prevents nasty things happening such as accidental command-injection. This allows us to have the swig / python executables in paths containing special chars and spaces, (or on shared storage on Win32, e.g \\some\path or C:\Program Files\swig\swig.exe). Subscribers: lldb-commits Differential Revision: https://reviews.llvm.org/D26757 llvm-svn: 289956
442 lines
15 KiB
Python
442 lines
15 KiB
Python
"""
|
|
The LLVM Compiler Infrastructure
|
|
|
|
This file is distributed under the University of Illinois Open Source
|
|
License. See LICENSE.TXT for details.
|
|
|
|
Python binding preparation script.
|
|
"""
|
|
|
|
# Python modules:
|
|
from __future__ import print_function
|
|
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import platform
|
|
|
|
|
|
class SwigSettings(object):
|
|
"""Provides a single object to represent swig files and settings."""
|
|
|
|
def __init__(self):
|
|
self.extensions_file = None
|
|
self.header_files = None
|
|
self.input_file = None
|
|
self.interface_files = None
|
|
self.output_file = None
|
|
self.safecast_file = None
|
|
self.typemaps_file = None
|
|
self.wrapper_file = None
|
|
|
|
@classmethod
|
|
def _any_files_newer(cls, files, check_mtime):
|
|
"""Returns if any of the given files has a newer modified time.
|
|
|
|
@param cls the class
|
|
@param files a list of zero or more file paths to check
|
|
@param check_mtime the modification time to use as a reference.
|
|
|
|
@return True if any file's modified time is newer than check_mtime.
|
|
"""
|
|
for path in files:
|
|
path_mtime = os.path.getmtime(path)
|
|
if path_mtime > check_mtime:
|
|
# This path was modified more recently than the
|
|
# check_mtime.
|
|
return True
|
|
# If we made it here, nothing was newer than the check_mtime
|
|
return False
|
|
|
|
@classmethod
|
|
def _file_newer(cls, path, check_mtime):
|
|
"""Tests how recently a file has been modified.
|
|
|
|
@param cls the class
|
|
@param path a file path to check
|
|
@param check_mtime the modification time to use as a reference.
|
|
|
|
@return True if the file's modified time is newer than check_mtime.
|
|
"""
|
|
path_mtime = os.path.getmtime(path)
|
|
return path_mtime > check_mtime
|
|
|
|
def output_out_of_date(self):
|
|
"""Returns whether the output file is out of date.
|
|
|
|
Compares output file time to all the input files.
|
|
|
|
@return True if any of the input files are newer than
|
|
the output file, or if the output file doesn't exist;
|
|
False otherwise.
|
|
"""
|
|
if not os.path.exists(self.output_file):
|
|
logging.info("will generate, missing binding output file")
|
|
return True
|
|
output_mtime = os.path.getmtime(self.output_file)
|
|
if self._any_files_newer(self.header_files, output_mtime):
|
|
logging.info("will generate, header files newer")
|
|
return True
|
|
if self._any_files_newer(self.interface_files, output_mtime):
|
|
logging.info("will generate, interface files newer")
|
|
return True
|
|
if self._file_newer(self.input_file, output_mtime):
|
|
logging.info("will generate, swig input file newer")
|
|
return True
|
|
if self._file_newer(self.extensions_file, output_mtime):
|
|
logging.info("will generate, swig extensions file newer")
|
|
return True
|
|
if self._file_newer(self.wrapper_file, output_mtime):
|
|
logging.info("will generate, swig wrapper file newer")
|
|
return True
|
|
if self._file_newer(self.typemaps_file, output_mtime):
|
|
logging.info("will generate, swig typemaps file newer")
|
|
return True
|
|
if self._file_newer(self.safecast_file, output_mtime):
|
|
logging.info("will generate, swig safecast file newer")
|
|
return True
|
|
|
|
# If we made it here, nothing is newer than the output file.
|
|
# Thus, the output file is not out of date.
|
|
return False
|
|
|
|
|
|
def get_header_files(options):
|
|
"""Returns a list of paths to C++ header files for the LLDB API.
|
|
|
|
These are the files that define the C++ API that will be wrapped by Python.
|
|
|
|
@param options the dictionary of options parsed from the command line.
|
|
|
|
@return a list of full paths to the include files used to define the public
|
|
LLDB C++ API.
|
|
"""
|
|
|
|
header_file_paths = []
|
|
header_base_dir = os.path.join(options.src_root, "include", "lldb")
|
|
|
|
# Specify the include files in include/lldb that are not easy to
|
|
# grab programatically.
|
|
for header in [
|
|
"lldb-defines.h",
|
|
"lldb-enumerations.h",
|
|
"lldb-forward.h",
|
|
"lldb-types.h"]:
|
|
header_file_paths.append(os.path.normcase(
|
|
os.path.join(header_base_dir, header)))
|
|
|
|
# Include the main LLDB.h file.
|
|
api_dir = os.path.join(header_base_dir, "API")
|
|
header_file_paths.append(os.path.normcase(
|
|
os.path.join(api_dir, "LLDB.h")))
|
|
|
|
filename_regex = re.compile(r"^SB.+\.h$")
|
|
|
|
# Include all the SB*.h files in the API dir.
|
|
for filename in os.listdir(api_dir):
|
|
if filename_regex.match(filename):
|
|
header_file_paths.append(
|
|
os.path.normcase(os.path.join(api_dir, filename)))
|
|
|
|
logging.debug("found public API header file paths: %s", header_file_paths)
|
|
return header_file_paths
|
|
|
|
|
|
def get_interface_files(options):
|
|
"""Returns a list of interface files used as input to swig.
|
|
|
|
@param options the options dictionary parsed from the command line args.
|
|
|
|
@return a list of full paths to the interface (.i) files used to describe
|
|
the public API language binding.
|
|
"""
|
|
interface_file_paths = []
|
|
interface_dir = os.path.join(options.src_root, "scripts", "interface")
|
|
|
|
for filepath in [f for f in os.listdir(interface_dir)
|
|
if os.path.splitext(f)[1] == ".i"]:
|
|
interface_file_paths.append(
|
|
os.path.normcase(os.path.join(interface_dir, filepath)))
|
|
|
|
logging.debug("found swig interface files: %s", interface_file_paths)
|
|
return interface_file_paths
|
|
|
|
|
|
def remove_ignore_enoent(filename):
|
|
"""Removes given file, ignoring error if it doesn't exist.
|
|
|
|
@param filename the path of the file to remove.
|
|
"""
|
|
try:
|
|
os.remove(filename)
|
|
except OSError as error:
|
|
import errno
|
|
if error.errno != errno.ENOENT:
|
|
raise
|
|
|
|
|
|
def do_swig_rebuild(options, dependency_file, config_build_dir, settings):
|
|
"""Generates Python bindings file from swig.
|
|
|
|
This method will do a sys.exit() if something fails. If it returns to
|
|
the caller, it succeeded.
|
|
|
|
@param options the parsed command line options structure.
|
|
@param dependency_file path to the bindings dependency file
|
|
to be generated; otherwise, None if a dependency file is not
|
|
to be generated.
|
|
@param config_build_dir used as the output directory used by swig
|
|
@param settings the SwigSettings that specify a number of aspects used
|
|
to configure building the Python binding with swig (mostly paths)
|
|
"""
|
|
if options.generate_dependency_file:
|
|
temp_dep_file_path = dependency_file + ".tmp"
|
|
|
|
# Build the SWIG args list
|
|
is_darwin = options.target_platform == "Darwin"
|
|
gen_deps = options.generate_dependency_file
|
|
darwin_extras = ["-D__APPLE__"] if is_darwin else []
|
|
deps_args = ["-MMD", "-MF", temp_dep_file_path] if gen_deps else []
|
|
command = ([
|
|
options.swig_executable,
|
|
"-c++",
|
|
"-shadow",
|
|
"-python",
|
|
"-threads",
|
|
"-I" + os.path.normpath(os.path.join(options.src_root, "include")),
|
|
"-I" + os.path.curdir,
|
|
"-D__STDC_LIMIT_MACROS",
|
|
"-D__STDC_CONSTANT_MACROS"
|
|
]
|
|
+ darwin_extras
|
|
+ deps_args
|
|
+ [
|
|
"-outdir", config_build_dir,
|
|
"-o", settings.output_file,
|
|
settings.input_file
|
|
]
|
|
)
|
|
logging.info("running swig with: %r", command)
|
|
|
|
# Execute swig
|
|
process = subprocess.Popen(
|
|
command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
)
|
|
# Wait for SWIG process to terminate
|
|
swig_stdout, swig_stderr = process.communicate()
|
|
return_code = process.returncode
|
|
if return_code != 0:
|
|
logging.error(
|
|
"swig failed with error code %d: stdout=%s, stderr=%s",
|
|
return_code,
|
|
swig_stdout,
|
|
swig_stderr)
|
|
logging.error(
|
|
"command line:\n%s", ' '.join(command))
|
|
sys.exit(return_code)
|
|
|
|
logging.info("swig generation succeeded")
|
|
if swig_stdout is not None and len(swig_stdout) > 0:
|
|
logging.info("swig output: %s", swig_stdout)
|
|
|
|
# Move the depedency file we just generated to the proper location.
|
|
if options.generate_dependency_file:
|
|
if os.path.exists(temp_dep_file_path):
|
|
shutil.move(temp_dep_file_path, dependency_file)
|
|
else:
|
|
logging.error(
|
|
"failed to generate Python binding depedency file '%s'",
|
|
temp_dep_file_path)
|
|
if os.path.exists(dependency_file):
|
|
# Delete the old one.
|
|
os.remove(dependency_file)
|
|
sys.exit(-10)
|
|
|
|
|
|
def run_python_script(script_and_args):
|
|
"""Runs a python script, logging appropriately.
|
|
|
|
If the command returns anything non-zero, it is registered as
|
|
an error and exits the program.
|
|
|
|
@param script_and_args the python script to execute, along with
|
|
the command line arguments to pass to it.
|
|
"""
|
|
command = [sys.executable] + script_and_args
|
|
process = subprocess.Popen(command)
|
|
script_stdout, script_stderr = process.communicate()
|
|
return_code = process.returncode
|
|
if return_code != 0:
|
|
logging.error("failed to run %r: %r", command, script_stderr)
|
|
sys.exit(return_code)
|
|
else:
|
|
logging.info("ran script %r'", command)
|
|
if script_stdout is not None:
|
|
logging.info("output: %s", script_stdout)
|
|
|
|
|
|
def do_modify_python_lldb(options, config_build_dir):
|
|
"""Executes the modify-python-lldb.py script.
|
|
|
|
@param options the parsed command line arguments
|
|
@param config_build_dir the directory where the Python output was created.
|
|
"""
|
|
script_path = os.path.normcase(
|
|
os.path.join(
|
|
options.src_root,
|
|
"scripts",
|
|
"Python",
|
|
"modify-python-lldb.py"))
|
|
|
|
if not os.path.exists(script_path):
|
|
logging.error("failed to find python script: '%s'", script_path)
|
|
sys.exit(-11)
|
|
|
|
run_python_script([script_path, config_build_dir])
|
|
|
|
|
|
def get_python_module_path(options):
|
|
"""Returns the location where the lldb Python module should be placed.
|
|
|
|
@param options dictionary of options parsed from the command line.
|
|
|
|
@return the directory where the lldb module should be placed.
|
|
"""
|
|
if options.framework:
|
|
# Caller wants to use the OS X framework packaging.
|
|
|
|
# We are packaging in an OS X-style framework bundle. The
|
|
# module dir will be within the
|
|
# LLDB.framework/Resources/Python subdirectory.
|
|
return os.path.join(
|
|
options.target_dir,
|
|
"LLDB.framework",
|
|
"Resources",
|
|
"Python",
|
|
"lldb")
|
|
else:
|
|
from distutils.sysconfig import get_python_lib
|
|
|
|
if options.prefix is not None:
|
|
module_path = get_python_lib(True, False, options.prefix)
|
|
else:
|
|
module_path = get_python_lib(True, False)
|
|
return os.path.normcase(
|
|
os.path.join(module_path, "lldb"))
|
|
|
|
|
|
def main(options):
|
|
"""Pepares the Python language binding to LLDB.
|
|
|
|
@param options the parsed command line argument dictionary
|
|
"""
|
|
# Setup generated dependency file options.
|
|
if options.generate_dependency_file:
|
|
dependency_file = os.path.normcase(os.path.join(
|
|
options.target_dir, "LLDBWrapPython.cpp.d"))
|
|
else:
|
|
dependency_file = None
|
|
|
|
# Keep track of all the swig-related settings.
|
|
settings = SwigSettings()
|
|
|
|
# Determine the final binding file path.
|
|
settings.output_file = os.path.normcase(
|
|
os.path.join(options.target_dir, "LLDBWrapPython.cpp"))
|
|
|
|
# Touch the output file (but don't really generate it) if python
|
|
# is disabled.
|
|
disable_python = os.getenv("LLDB_DISABLE_PYTHON", None)
|
|
if disable_python is not None and disable_python == "1":
|
|
remove_ignore_enoent(settings.output_file)
|
|
# Touch the file.
|
|
open(settings.output_file, 'w').close()
|
|
logging.info(
|
|
"Created empty python binding file due to LLDB_DISABLE_PYTHON "
|
|
"being set")
|
|
return
|
|
|
|
# We also check the GCC_PREPROCESSOR_DEFINITIONS to see if it
|
|
# contains LLDB_DISABLE_PYTHON. If so, we skip generating
|
|
# the binding.
|
|
gcc_preprocessor_defs = os.getenv("GCC_PREPROCESSOR_DEFINITIONS", None)
|
|
if gcc_preprocessor_defs is not None:
|
|
if re.search(r"LLDB_DISABLE_PYTHON", gcc_preprocessor_defs):
|
|
remove_ignore_enoent(settings.output_file)
|
|
# Touch the file
|
|
open(settings.output_file, 'w').close()
|
|
logging.info(
|
|
"Created empty python binding file due to "
|
|
"finding LLDB_DISABLE_PYTHON in GCC_PREPROCESSOR_DEFINITIONS")
|
|
return
|
|
|
|
# Setup paths used during swig invocation.
|
|
settings.input_file = os.path.normcase(
|
|
os.path.join(options.src_root, "scripts", "lldb.swig"))
|
|
scripts_python_dir = os.path.dirname(os.path.realpath(__file__))
|
|
settings.extensions_file = os.path.normcase(
|
|
os.path.join(scripts_python_dir, "python-extensions.swig"))
|
|
settings.wrapper_file = os.path.normcase(
|
|
os.path.join(scripts_python_dir, "python-wrapper.swig"))
|
|
settings.typemaps_file = os.path.normcase(
|
|
os.path.join(scripts_python_dir, "python-typemaps.swig"))
|
|
settings.safecast_file = os.path.normcase(
|
|
os.path.join(scripts_python_dir, "python-swigsafecast.swig"))
|
|
|
|
settings.header_files = get_header_files(options)
|
|
settings.interface_files = get_interface_files(options)
|
|
|
|
generate_output = settings.output_out_of_date()
|
|
|
|
# Determine where to put the module.
|
|
python_module_path = get_python_module_path(options)
|
|
logging.info("python module path: %s", python_module_path)
|
|
|
|
# Handle the configuration build dir.
|
|
if options.config_build_dir is not None:
|
|
config_build_dir = options.config_build_dir
|
|
else:
|
|
config_build_dir = python_module_path
|
|
|
|
# Allow missing/non-link _lldb.so to force regeneration.
|
|
if not generate_output:
|
|
# Ensure the _lldb.so file exists.
|
|
so_path = os.path.join(python_module_path, "_lldb.so")
|
|
if not os.path.exists(so_path) or not os.path.islink(so_path):
|
|
logging.info("_lldb.so doesn't exist or isn't a symlink")
|
|
generate_output = True
|
|
|
|
# Allow missing __init__.py to force regeneration.
|
|
if not generate_output:
|
|
# Ensure the __init__.py for the lldb module can be found.
|
|
init_path = os.path.join(python_module_path, "__init__.py")
|
|
if not os.path.exists(init_path):
|
|
logging.info("__init__.py doesn't exist")
|
|
generate_output = True
|
|
|
|
if not generate_output:
|
|
logging.info(
|
|
"Skipping Python binding generation: everything is up to date")
|
|
return
|
|
|
|
# Generate the Python binding with swig.
|
|
logging.info("Python binding is out of date, regenerating")
|
|
do_swig_rebuild(options, dependency_file, config_build_dir, settings)
|
|
if options.generate_dependency_file:
|
|
return
|
|
|
|
# Post process the swig-generated file.
|
|
do_modify_python_lldb(options, config_build_dir)
|
|
|
|
|
|
# This script can be called by another Python script by calling the main()
|
|
# function directly
|
|
if __name__ == "__main__":
|
|
print("Script cannot be called directly.")
|
|
sys.exit(-1)
|