| """ |
| Support code for building Python extensions on Windows. |
| |
| # NT stuff |
| # 1. Make sure libpython<version>.a exists for gcc. If not, build it. |
| # 2. Force windows to use gcc (we're struggling with MSVC and g77 support) |
| # 3. Force windows to use g77 |
| |
| """ |
| import os |
| import sys |
| import subprocess |
| import re |
| import textwrap |
| |
| # Overwrite certain distutils.ccompiler functions: |
| import numpy.distutils.ccompiler # noqa: F401 |
| from numpy.distutils import log |
| # NT stuff |
| # 1. Make sure libpython<version>.a exists for gcc. If not, build it. |
| # 2. Force windows to use gcc (we're struggling with MSVC and g77 support) |
| # --> this is done in numpy/distutils/ccompiler.py |
| # 3. Force windows to use g77 |
| |
| import distutils.cygwinccompiler |
| from distutils.unixccompiler import UnixCCompiler |
| from distutils.msvccompiler import get_build_version as get_build_msvc_version |
| from distutils.errors import UnknownFileError |
| from numpy.distutils.misc_util import (msvc_runtime_library, |
| msvc_runtime_version, |
| msvc_runtime_major, |
| get_build_architecture) |
| |
| def get_msvcr_replacement(): |
| """Replacement for outdated version of get_msvcr from cygwinccompiler""" |
| msvcr = msvc_runtime_library() |
| return [] if msvcr is None else [msvcr] |
| |
| |
| # Useful to generate table of symbols from a dll |
| _START = re.compile(r'\[Ordinal/Name Pointer\] Table') |
| _TABLE = re.compile(r'^\s+\[([\s*[0-9]*)\] ([a-zA-Z0-9_]*)') |
| |
| # the same as cygwin plus some additional parameters |
| class Mingw32CCompiler(distutils.cygwinccompiler.CygwinCCompiler): |
| """ A modified MingW32 compiler compatible with an MSVC built Python. |
| |
| """ |
| |
| compiler_type = 'mingw32' |
| |
| def __init__ (self, |
| verbose=0, |
| dry_run=0, |
| force=0): |
| |
| distutils.cygwinccompiler.CygwinCCompiler.__init__ (self, verbose, |
| dry_run, force) |
| |
| # **changes: eric jones 4/11/01 |
| # 1. Check for import library on Windows. Build if it doesn't exist. |
| |
| build_import_library() |
| |
| # Check for custom msvc runtime library on Windows. Build if it doesn't exist. |
| msvcr_success = build_msvcr_library() |
| msvcr_dbg_success = build_msvcr_library(debug=True) |
| if msvcr_success or msvcr_dbg_success: |
| # add preprocessor statement for using customized msvcr lib |
| self.define_macro('NPY_MINGW_USE_CUSTOM_MSVCR') |
| |
| # Define the MSVC version as hint for MinGW |
| msvcr_version = msvc_runtime_version() |
| if msvcr_version: |
| self.define_macro('__MSVCRT_VERSION__', '0x%04i' % msvcr_version) |
| |
| # MS_WIN64 should be defined when building for amd64 on windows, |
| # but python headers define it only for MS compilers, which has all |
| # kind of bad consequences, like using Py_ModuleInit4 instead of |
| # Py_ModuleInit4_64, etc... So we add it here |
| if get_build_architecture() == 'AMD64': |
| self.set_executables( |
| compiler='gcc -g -DDEBUG -DMS_WIN64 -O0 -Wall', |
| compiler_so='gcc -g -DDEBUG -DMS_WIN64 -O0 -Wall ' |
| '-Wstrict-prototypes', |
| linker_exe='gcc -g', |
| linker_so='gcc -g -shared') |
| else: |
| self.set_executables( |
| compiler='gcc -O2 -Wall', |
| compiler_so='gcc -O2 -Wall -Wstrict-prototypes', |
| linker_exe='g++ ', |
| linker_so='g++ -shared') |
| # added for python2.3 support |
| # we can't pass it through set_executables because pre 2.2 would fail |
| self.compiler_cxx = ['g++'] |
| |
| # Maybe we should also append -mthreads, but then the finished dlls |
| # need another dll (mingwm10.dll see Mingw32 docs) (-mthreads: Support |
| # thread-safe exception handling on `Mingw32') |
| |
| # no additional libraries needed |
| #self.dll_libraries=[] |
| return |
| |
| # __init__ () |
| |
| def link(self, |
| target_desc, |
| objects, |
| output_filename, |
| output_dir, |
| libraries, |
| library_dirs, |
| runtime_library_dirs, |
| export_symbols = None, |
| debug=0, |
| extra_preargs=None, |
| extra_postargs=None, |
| build_temp=None, |
| target_lang=None): |
| # Include the appropriate MSVC runtime library if Python was built |
| # with MSVC >= 7.0 (MinGW standard is msvcrt) |
| runtime_library = msvc_runtime_library() |
| if runtime_library: |
| if not libraries: |
| libraries = [] |
| libraries.append(runtime_library) |
| args = (self, |
| target_desc, |
| objects, |
| output_filename, |
| output_dir, |
| libraries, |
| library_dirs, |
| runtime_library_dirs, |
| None, #export_symbols, we do this in our def-file |
| debug, |
| extra_preargs, |
| extra_postargs, |
| build_temp, |
| target_lang) |
| func = UnixCCompiler.link |
| func(*args[:func.__code__.co_argcount]) |
| return |
| |
| def object_filenames (self, |
| source_filenames, |
| strip_dir=0, |
| output_dir=''): |
| if output_dir is None: output_dir = '' |
| obj_names = [] |
| for src_name in source_filenames: |
| # use normcase to make sure '.rc' is really '.rc' and not '.RC' |
| (base, ext) = os.path.splitext (os.path.normcase(src_name)) |
| |
| # added these lines to strip off windows drive letters |
| # without it, .o files are placed next to .c files |
| # instead of the build directory |
| drv, base = os.path.splitdrive(base) |
| if drv: |
| base = base[1:] |
| |
| if ext not in (self.src_extensions + ['.rc', '.res']): |
| raise UnknownFileError( |
| "unknown file type '%s' (from '%s')" % \ |
| (ext, src_name)) |
| if strip_dir: |
| base = os.path.basename (base) |
| if ext == '.res' or ext == '.rc': |
| # these need to be compiled to object files |
| obj_names.append (os.path.join (output_dir, |
| base + ext + self.obj_extension)) |
| else: |
| obj_names.append (os.path.join (output_dir, |
| base + self.obj_extension)) |
| return obj_names |
| |
| # object_filenames () |
| |
| |
| def find_python_dll(): |
| # We can't do much here: |
| # - find it in the virtualenv (sys.prefix) |
| # - find it in python main dir (sys.base_prefix, if in a virtualenv) |
| # - in system32, |
| # - ortherwise (Sxs), I don't know how to get it. |
| stems = [sys.prefix] |
| if sys.base_prefix != sys.prefix: |
| stems.append(sys.base_prefix) |
| |
| sub_dirs = ['', 'lib', 'bin'] |
| # generate possible combinations of directory trees and sub-directories |
| lib_dirs = [] |
| for stem in stems: |
| for folder in sub_dirs: |
| lib_dirs.append(os.path.join(stem, folder)) |
| |
| # add system directory as well |
| if 'SYSTEMROOT' in os.environ: |
| lib_dirs.append(os.path.join(os.environ['SYSTEMROOT'], 'System32')) |
| |
| # search in the file system for possible candidates |
| major_version, minor_version = tuple(sys.version_info[:2]) |
| implementation = sys.implementation.name |
| if implementation == 'cpython': |
| dllname = f'python{major_version}{minor_version}.dll' |
| elif implementation == 'pypy': |
| dllname = f'libpypy{major_version}.{minor_version}-c.dll' |
| else: |
| dllname = f'Unknown platform {implementation}' |
| print("Looking for %s" % dllname) |
| for folder in lib_dirs: |
| dll = os.path.join(folder, dllname) |
| if os.path.exists(dll): |
| return dll |
| |
| raise ValueError("%s not found in %s" % (dllname, lib_dirs)) |
| |
| def dump_table(dll): |
| st = subprocess.check_output(["objdump.exe", "-p", dll]) |
| return st.split(b'\n') |
| |
| def generate_def(dll, dfile): |
| """Given a dll file location, get all its exported symbols and dump them |
| into the given def file. |
| |
| The .def file will be overwritten""" |
| dump = dump_table(dll) |
| for i in range(len(dump)): |
| if _START.match(dump[i].decode()): |
| break |
| else: |
| raise ValueError("Symbol table not found") |
| |
| syms = [] |
| for j in range(i+1, len(dump)): |
| m = _TABLE.match(dump[j].decode()) |
| if m: |
| syms.append((int(m.group(1).strip()), m.group(2))) |
| else: |
| break |
| |
| if len(syms) == 0: |
| log.warn('No symbols found in %s' % dll) |
| |
| with open(dfile, 'w') as d: |
| d.write('LIBRARY %s\n' % os.path.basename(dll)) |
| d.write(';CODE PRELOAD MOVEABLE DISCARDABLE\n') |
| d.write(';DATA PRELOAD SINGLE\n') |
| d.write('\nEXPORTS\n') |
| for s in syms: |
| #d.write('@%d %s\n' % (s[0], s[1])) |
| d.write('%s\n' % s[1]) |
| |
| def find_dll(dll_name): |
| |
| arch = {'AMD64' : 'amd64', |
| 'Intel' : 'x86'}[get_build_architecture()] |
| |
| def _find_dll_in_winsxs(dll_name): |
| # Walk through the WinSxS directory to find the dll. |
| winsxs_path = os.path.join(os.environ.get('WINDIR', r'C:\WINDOWS'), |
| 'winsxs') |
| if not os.path.exists(winsxs_path): |
| return None |
| for root, dirs, files in os.walk(winsxs_path): |
| if dll_name in files and arch in root: |
| return os.path.join(root, dll_name) |
| return None |
| |
| def _find_dll_in_path(dll_name): |
| # First, look in the Python directory, then scan PATH for |
| # the given dll name. |
| for path in [sys.prefix] + os.environ['PATH'].split(';'): |
| filepath = os.path.join(path, dll_name) |
| if os.path.exists(filepath): |
| return os.path.abspath(filepath) |
| |
| return _find_dll_in_winsxs(dll_name) or _find_dll_in_path(dll_name) |
| |
| def build_msvcr_library(debug=False): |
| if os.name != 'nt': |
| return False |
| |
| # If the version number is None, then we couldn't find the MSVC runtime at |
| # all, because we are running on a Python distribution which is customed |
| # compiled; trust that the compiler is the same as the one available to us |
| # now, and that it is capable of linking with the correct runtime without |
| # any extra options. |
| msvcr_ver = msvc_runtime_major() |
| if msvcr_ver is None: |
| log.debug('Skip building import library: ' |
| 'Runtime is not compiled with MSVC') |
| return False |
| |
| # Skip using a custom library for versions < MSVC 8.0 |
| if msvcr_ver < 80: |
| log.debug('Skip building msvcr library:' |
| ' custom functionality not present') |
| return False |
| |
| msvcr_name = msvc_runtime_library() |
| if debug: |
| msvcr_name += 'd' |
| |
| # Skip if custom library already exists |
| out_name = "lib%s.a" % msvcr_name |
| out_file = os.path.join(sys.prefix, 'libs', out_name) |
| if os.path.isfile(out_file): |
| log.debug('Skip building msvcr library: "%s" exists' % |
| (out_file,)) |
| return True |
| |
| # Find the msvcr dll |
| msvcr_dll_name = msvcr_name + '.dll' |
| dll_file = find_dll(msvcr_dll_name) |
| if not dll_file: |
| log.warn('Cannot build msvcr library: "%s" not found' % |
| msvcr_dll_name) |
| return False |
| |
| def_name = "lib%s.def" % msvcr_name |
| def_file = os.path.join(sys.prefix, 'libs', def_name) |
| |
| log.info('Building msvcr library: "%s" (from %s)' \ |
| % (out_file, dll_file)) |
| |
| # Generate a symbol definition file from the msvcr dll |
| generate_def(dll_file, def_file) |
| |
| # Create a custom mingw library for the given symbol definitions |
| cmd = ['dlltool', '-d', def_file, '-l', out_file] |
| retcode = subprocess.call(cmd) |
| |
| # Clean up symbol definitions |
| os.remove(def_file) |
| |
| return (not retcode) |
| |
| def build_import_library(): |
| if os.name != 'nt': |
| return |
| |
| arch = get_build_architecture() |
| if arch == 'AMD64': |
| return _build_import_library_amd64() |
| elif arch == 'Intel': |
| return _build_import_library_x86() |
| else: |
| raise ValueError("Unhandled arch %s" % arch) |
| |
| def _check_for_import_lib(): |
| """Check if an import library for the Python runtime already exists.""" |
| major_version, minor_version = tuple(sys.version_info[:2]) |
| |
| # patterns for the file name of the library itself |
| patterns = ['libpython%d%d.a', |
| 'libpython%d%d.dll.a', |
| 'libpython%d.%d.dll.a'] |
| |
| # directory trees that may contain the library |
| stems = [sys.prefix] |
| if hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix: |
| stems.append(sys.base_prefix) |
| elif hasattr(sys, 'real_prefix') and sys.real_prefix != sys.prefix: |
| stems.append(sys.real_prefix) |
| |
| # possible subdirectories within those trees where it is placed |
| sub_dirs = ['libs', 'lib'] |
| |
| # generate a list of candidate locations |
| candidates = [] |
| for pat in patterns: |
| filename = pat % (major_version, minor_version) |
| for stem_dir in stems: |
| for folder in sub_dirs: |
| candidates.append(os.path.join(stem_dir, folder, filename)) |
| |
| # test the filesystem to see if we can find any of these |
| for fullname in candidates: |
| if os.path.isfile(fullname): |
| # already exists, in location given |
| return (True, fullname) |
| |
| # needs to be built, preferred location given first |
| return (False, candidates[0]) |
| |
| def _build_import_library_amd64(): |
| out_exists, out_file = _check_for_import_lib() |
| if out_exists: |
| log.debug('Skip building import library: "%s" exists', out_file) |
| return |
| |
| # get the runtime dll for which we are building import library |
| dll_file = find_python_dll() |
| log.info('Building import library (arch=AMD64): "%s" (from %s)' % |
| (out_file, dll_file)) |
| |
| # generate symbol list from this library |
| def_name = "python%d%d.def" % tuple(sys.version_info[:2]) |
| def_file = os.path.join(sys.prefix, 'libs', def_name) |
| generate_def(dll_file, def_file) |
| |
| # generate import library from this symbol list |
| cmd = ['dlltool', '-d', def_file, '-l', out_file] |
| subprocess.check_call(cmd) |
| |
| def _build_import_library_x86(): |
| """ Build the import libraries for Mingw32-gcc on Windows |
| """ |
| out_exists, out_file = _check_for_import_lib() |
| if out_exists: |
| log.debug('Skip building import library: "%s" exists', out_file) |
| return |
| |
| lib_name = "python%d%d.lib" % tuple(sys.version_info[:2]) |
| lib_file = os.path.join(sys.prefix, 'libs', lib_name) |
| if not os.path.isfile(lib_file): |
| # didn't find library file in virtualenv, try base distribution, too, |
| # and use that instead if found there. for Python 2.7 venvs, the base |
| # directory is in attribute real_prefix instead of base_prefix. |
| if hasattr(sys, 'base_prefix'): |
| base_lib = os.path.join(sys.base_prefix, 'libs', lib_name) |
| elif hasattr(sys, 'real_prefix'): |
| base_lib = os.path.join(sys.real_prefix, 'libs', lib_name) |
| else: |
| base_lib = '' # os.path.isfile('') == False |
| |
| if os.path.isfile(base_lib): |
| lib_file = base_lib |
| else: |
| log.warn('Cannot build import library: "%s" not found', lib_file) |
| return |
| log.info('Building import library (ARCH=x86): "%s"', out_file) |
| |
| from numpy.distutils import lib2def |
| |
| def_name = "python%d%d.def" % tuple(sys.version_info[:2]) |
| def_file = os.path.join(sys.prefix, 'libs', def_name) |
| nm_output = lib2def.getnm( |
| lib2def.DEFAULT_NM + [lib_file], shell=False) |
| dlist, flist = lib2def.parse_nm(nm_output) |
| with open(def_file, 'w') as fid: |
| lib2def.output_def(dlist, flist, lib2def.DEF_HEADER, fid) |
| |
| dll_name = find_python_dll () |
| |
| cmd = ["dlltool", |
| "--dllname", dll_name, |
| "--def", def_file, |
| "--output-lib", out_file] |
| status = subprocess.check_output(cmd) |
| if status: |
| log.warn('Failed to build import library for gcc. Linking will fail.') |
| return |
| |
| #===================================== |
| # Dealing with Visual Studio MANIFESTS |
| #===================================== |
| |
| # Functions to deal with visual studio manifests. Manifest are a mechanism to |
| # enforce strong DLL versioning on windows, and has nothing to do with |
| # distutils MANIFEST. manifests are XML files with version info, and used by |
| # the OS loader; they are necessary when linking against a DLL not in the |
| # system path; in particular, official python 2.6 binary is built against the |
| # MS runtime 9 (the one from VS 2008), which is not available on most windows |
| # systems; python 2.6 installer does install it in the Win SxS (Side by side) |
| # directory, but this requires the manifest for this to work. This is a big |
| # mess, thanks MS for a wonderful system. |
| |
| # XXX: ideally, we should use exactly the same version as used by python. I |
| # submitted a patch to get this version, but it was only included for python |
| # 2.6.1 and above. So for versions below, we use a "best guess". |
| _MSVCRVER_TO_FULLVER = {} |
| if sys.platform == 'win32': |
| try: |
| import msvcrt |
| # I took one version in my SxS directory: no idea if it is the good |
| # one, and we can't retrieve it from python |
| _MSVCRVER_TO_FULLVER['80'] = "8.0.50727.42" |
| _MSVCRVER_TO_FULLVER['90'] = "9.0.21022.8" |
| # Value from msvcrt.CRT_ASSEMBLY_VERSION under Python 3.3.0 |
| # on Windows XP: |
| _MSVCRVER_TO_FULLVER['100'] = "10.0.30319.460" |
| crt_ver = getattr(msvcrt, 'CRT_ASSEMBLY_VERSION', None) |
| if crt_ver is not None: # Available at least back to Python 3.3 |
| maj, min = re.match(r'(\d+)\.(\d)', crt_ver).groups() |
| _MSVCRVER_TO_FULLVER[maj + min] = crt_ver |
| del maj, min |
| del crt_ver |
| except ImportError: |
| # If we are here, means python was not built with MSVC. Not sure what |
| # to do in that case: manifest building will fail, but it should not be |
| # used in that case anyway |
| log.warn('Cannot import msvcrt: using manifest will not be possible') |
| |
| def msvc_manifest_xml(maj, min): |
| """Given a major and minor version of the MSVCR, returns the |
| corresponding XML file.""" |
| try: |
| fullver = _MSVCRVER_TO_FULLVER[str(maj * 10 + min)] |
| except KeyError: |
| raise ValueError("Version %d,%d of MSVCRT not supported yet" % |
| (maj, min)) from None |
| # Don't be fooled, it looks like an XML, but it is not. In particular, it |
| # should not have any space before starting, and its size should be |
| # divisible by 4, most likely for alignment constraints when the xml is |
| # embedded in the binary... |
| # This template was copied directly from the python 2.6 binary (using |
| # strings.exe from mingw on python.exe). |
| template = textwrap.dedent("""\ |
| <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> |
| <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> |
| <security> |
| <requestedPrivileges> |
| <requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel> |
| </requestedPrivileges> |
| </security> |
| </trustInfo> |
| <dependency> |
| <dependentAssembly> |
| <assemblyIdentity type="win32" name="Microsoft.VC%(maj)d%(min)d.CRT" version="%(fullver)s" processorArchitecture="*" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity> |
| </dependentAssembly> |
| </dependency> |
| </assembly>""") |
| |
| return template % {'fullver': fullver, 'maj': maj, 'min': min} |
| |
| def manifest_rc(name, type='dll'): |
| """Return the rc file used to generate the res file which will be embedded |
| as manifest for given manifest file name, of given type ('dll' or |
| 'exe'). |
| |
| Parameters |
| ---------- |
| name : str |
| name of the manifest file to embed |
| type : str {'dll', 'exe'} |
| type of the binary which will embed the manifest |
| |
| """ |
| if type == 'dll': |
| rctype = 2 |
| elif type == 'exe': |
| rctype = 1 |
| else: |
| raise ValueError("Type %s not supported" % type) |
| |
| return """\ |
| #include "winuser.h" |
| %d RT_MANIFEST %s""" % (rctype, name) |
| |
| def check_embedded_msvcr_match_linked(msver): |
| """msver is the ms runtime version used for the MANIFEST.""" |
| # check msvcr major version are the same for linking and |
| # embedding |
| maj = msvc_runtime_major() |
| if maj: |
| if not maj == int(msver): |
| raise ValueError( |
| "Discrepancy between linked msvcr " \ |
| "(%d) and the one about to be embedded " \ |
| "(%d)" % (int(msver), maj)) |
| |
| def configtest_name(config): |
| base = os.path.basename(config._gen_temp_sourcefile("yo", [], "c")) |
| return os.path.splitext(base)[0] |
| |
| def manifest_name(config): |
| # Get configest name (including suffix) |
| root = configtest_name(config) |
| exext = config.compiler.exe_extension |
| return root + exext + ".manifest" |
| |
| def rc_name(config): |
| # Get configtest name (including suffix) |
| root = configtest_name(config) |
| return root + ".rc" |
| |
| def generate_manifest(config): |
| msver = get_build_msvc_version() |
| if msver is not None: |
| if msver >= 8: |
| check_embedded_msvcr_match_linked(msver) |
| ma_str, mi_str = str(msver).split('.') |
| # Write the manifest file |
| manxml = msvc_manifest_xml(int(ma_str), int(mi_str)) |
| with open(manifest_name(config), "w") as man: |
| config.temp_files.append(manifest_name(config)) |
| man.write(manxml) |
