def get_ethtool_macro(): # see: https://github.com/giampaolo/psutil/issues/659 from distutils.unixccompiler import UnixCCompiler from distutils.errors import CompileError with tempfile.NamedTemporaryFile(suffix='.c', delete=False, mode="wt") as f: f.write("#include <linux/ethtool.h>") @atexit.register def on_exit(): try: os.remove(f.name) except OSError: pass compiler = UnixCCompiler() try: with silenced_output('stderr'): with silenced_output('stdout'): compiler.compile([f.name]) except CompileError: return ("PSUTIL_ETHTOOL_MISSING_TYPES", 1) else: return None
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. Reason: %s. Compiling may fail because of undefined preprocessor macros." % details ) self.gcc_version, self.ld_version, self.dllwrap_version = get_versions() self.debug_print( self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" % (self.gcc_version, self.ld_version, self.dllwrap_version) ) if self.ld_version >= "2.10.90": self.linker_dll = "gcc" else: self.linker_dll = "dllwrap" if self.ld_version >= "2.13": shared_option = "-shared" else: shared_option = "-mdll -static" self.set_executables( compiler="gcc -mcygwin -O -Wall", compiler_so="gcc -mcygwin -mdll -O -Wall", compiler_cxx="g++ -mcygwin -O -Wall", linker_exe="gcc -mcygwin", linker_so="%s -mcygwin %s" % (self.linker_dll, shared_option), ) if self.gcc_version == "2.91.57": self.dll_libraries = ["msvcrt"] self.warn("Consider upgrading to a newer version of gcc") else: self.dll_libraries = get_msvcr()
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) (status, details) = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " + ("Reason: %s." % details) + "Compiling may fail because of undefined preprocessor macros.") (self.gcc_version, self.ld_version) = \ get_versions() self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" % (self.gcc_version, self.ld_version)) # Hard-code GCC because that's what this is all about. # XXX optimization, warnings etc. should be customizable. self.set_executables( compiler='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', linker_exe='gcc -Zomf -Zmt -Zcrtdll', linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll') # want the gcc library statically linked (so that we don't have # to distribute a version dependent on the compiler we have) self.dll_libraries = ["gcc"]
def get_ethtool_macro(): # see: https://github.com/giampaolo/psutil/issues/659 from distutils.unixccompiler import UnixCCompiler from distutils.errors import CompileError with tempfile.NamedTemporaryFile( suffix='.c', delete=False, mode="wt") as f: f.write("#include <linux/ethtool.h>") @atexit.register def on_exit(): try: os.remove(f.name) except OSError: pass compiler = UnixCCompiler() try: with silenced_output('stderr'): with silenced_output('stdout'): compiler.compile([f.name]) except CompileError: return ("PSUTIL_ETHTOOL_MISSING_TYPES", 1) else: return None
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. Reason: %s. Compiling may fail because of undefined preprocessor macros." % details) self.gcc_version, self.ld_version, self.dllwrap_version = get_versions( ) self.debug_print( self.compiler_type + ': gcc %s, ld %s, dllwrap %s\n' % (self.gcc_version, self.ld_version, self.dllwrap_version)) if self.ld_version >= '2.10.90': self.linker_dll = 'gcc' else: self.linker_dll = 'dllwrap' if self.ld_version >= '2.13': shared_option = '-shared' else: shared_option = '-mdll -static' self.set_executables(compiler='gcc -mcygwin -O -Wall', compiler_so='gcc -mcygwin -mdll -O -Wall', compiler_cxx='g++ -mcygwin -O -Wall', linker_exe='gcc -mcygwin', linker_so='%s -mcygwin %s' % (self.linker_dll, shared_option)) if self.gcc_version == '2.91.57': self.dll_libraries = ['msvcrt'] self.warn('Consider upgrading to a newer version of gcc') else: self.dll_libraries = get_msvcr()
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose, dry_run, force) (status, details) = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " + ("Reason: %s." % details) + "Compiling may fail because of undefined preprocessor macros.") (self.gcc_version, self.ld_version) = \ get_versions() self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" % (self.gcc_version, self.ld_version) ) # Hard-code GCC because that's what this is all about. # XXX optimization, warnings etc. should be customizable. self.set_executables(compiler='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', linker_exe='gcc -Zomf -Zmt -Zcrtdll', linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll') # want the gcc library statically linked (so that we don't have # to distribute a version dependent on the compiler we have) self.dll_libraries=["gcc"]
def __init__(self): # Check to ensure that nvcc can be located try: subprocess.check_output('nvcc --help', shell=True) except CalledProcessError: print >> sys.stderr, 'Could not find nvcc, the nvidia cuda compiler' sys.exit(1) UnixCCompiler.__init__(self)
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose, dry_run, force) cc = 'icc' self.set_executables(compiler=cc, compiler_so=cc, compiler_cxx=cc, linker_exe=cc, linker_so=cc + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, linker_exe=compiler, linker_so=compiler + ' -shared')
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose,dry_run, force) compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, linker_exe=compiler, linker_so=compiler + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " "Reason: %s. " "Compiling may fail because of undefined preprocessor macros." % details) self.gcc_version, self.ld_version, self.dllwrap_version = \ get_versions() self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" % (self.gcc_version, self.ld_version, self.dllwrap_version) ) # ld_version >= "2.10.90" and < "2.13" should also be able to use # gcc -mdll instead of dllwrap # Older dllwraps had own version numbers, newer ones use the # same as the rest of binutils ( also ld ) # dllwrap 2.10.90 is buggy if self.ld_version >= "2.10.90": self.linker_dll = "gcc" else: self.linker_dll = "dllwrap" # ld_version >= "2.13" support -shared so use it instead of # -mdll -static if self.ld_version >= "2.13": shared_option = "-shared" else: shared_option = "-mdll -static" # Hard-code GCC because that's what this is all about. # XXX optimization, warnings etc. should be customizable. self.set_executables(compiler='gcc -mcygwin -O -Wall', compiler_so='gcc -mcygwin -mdll -O -Wall', compiler_cxx='g++ -mcygwin -O -Wall', linker_exe='gcc -mcygwin', linker_so=('%s -mcygwin %s' % (self.linker_dll, shared_option))) # cygwin and mingw32 need different sets of libraries if self.gcc_version == "2.91.57": # cygwin shouldn't need msvcrt, but without the dlls will crash # (gcc version 2.91.57) -- perhaps something about initialization self.dll_libraries=["msvcrt"] self.warn( "Consider upgrading to a newer version of gcc") else: # Include the appropriate MSVC runtime library if Python was built # with MSVC 7.0 or later. self.dll_libraries = get_msvcr()
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose, dry_run, force) (status, details) = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " "Reason: %s. " "Compiling may fail because of undefined preprocessor macros." % details) self.gcc_version, self.ld_version, self.dllwrap_version = \ get_versions() self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" % (self.gcc_version, self.ld_version, self.dllwrap_version) ) # ld_version >= "2.10.90" and < "2.13" should also be able to use # gcc -mdll instead of dllwrap # Older dllwraps had own version numbers, newer ones use the # same as the rest of binutils ( also ld ) # dllwrap 2.10.90 is buggy if self.ld_version >= "2.10.90": self.linker_dll = "gcc" else: self.linker_dll = "dllwrap" # ld_version >= "2.13" support -shared so use it instead of # -mdll -static if self.ld_version >= "2.13": shared_option = "-shared" else: shared_option = "-mdll -static" # Hard-code GCC because that's what this is all about. # XXX optimization, warnings etc. should be customizable. self.set_executables(compiler='gcc -mcygwin -O -Wall', compiler_so='gcc -mcygwin -mdll -O -Wall', compiler_cxx='g++ -mcygwin -O -Wall', linker_exe='gcc -mcygwin', linker_so=('%s -mcygwin %s' % (self.linker_dll, shared_option))) # cygwin and mingw32 need different sets of libraries if self.gcc_version == "2.91.57": # cygwin shouldn't need msvcrt, but without the dlls will crash # (gcc version 2.91.57) -- perhaps something about initialization self.dll_libraries=["msvcrt"] self.warn( "Consider upgrading to a newer version of gcc") else: # Include the appropriate MSVC runtime library if Python was built # with MSVC 7.0 or later. self.dll_libraries = get_msvcr()
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose,dry_run, force) self.cc_exe = 'icc -O3 -fPIC -fp-model strict -fomit-frame-pointer -openmp -xHost -w ' compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, linker_exe=compiler, linker_so=compiler + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = 'icc -O3 -g -fPIC -fp-model strict -fomit-frame-pointer -openmp -axCORE-AVX2 -xSSE4.2 ' compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, linker_exe=compiler, linker_so=compiler + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) cc_compiler = self.cc_exe cxx_compiler = self.cxx_exe self.set_executables(compiler=cc_compiler + ' -O3 -fPIC', compiler_so=cc_compiler + ' -O3 -fPIC', compiler_cxx=cxx_compiler + ' -O3 -fPIC', linker_exe=cc_compiler + ' -lamath', linker_so=cc_compiler + ' -lamath -shared')
def __init__(self, verbose = 0, dry_run = 0, force = 0): UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn("Python's pyconfig.h doesn't seem to support your compiler. " + 'Reason: %s.' % details + 'Compiling may fail because of undefined preprocessor macros.') self.gcc_version, self.ld_version = get_versions() self.debug_print(self.compiler_type + ': gcc %s, ld %s\n' % (self.gcc_version, self.ld_version)) self.set_executables(compiler='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall', linker_exe='gcc -Zomf -Zmt -Zcrtdll', linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll') self.dll_libraries = ['gcc']
def preprocess(self, source, output_file=None, macros=None, include_dirs=None, extra_preargs=None, extra_postargs=None): print("PREPROCESS") UnixCCompiler.preprocess(self, source, output_file, macros, include_dirs, extra_preargs, exta_postargs)
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = 'icc -m64 -fPIC' compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler, linker_so=compiler + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = ('icc -m64 -fPIC -fp-model strict -O3 ' '-fomit-frame-pointer -openmp -xSSE4.2') compiler = self.cc_exe self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' -shared -shared-intel')
def link( self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None, ): extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) libraries.extend(self.dll_libraries) if export_symbols is not None and (target_desc != self.EXECUTABLE or self.linker_dll == "gcc"): temp_dir = os.path.dirname(objects[0]) dll_name, dll_extension = os.path.splitext(os.path.basename(output_filename)) def_file = os.path.join(temp_dir, dll_name + ".def") lib_file = os.path.join(temp_dir, "lib" + dll_name + ".a") contents = ["LIBRARY %s" % os.path.basename(output_filename), "EXPORTS"] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) if self.linker_dll == "dllwrap": extra_preargs.extend(["--output-lib", lib_file]) extra_preargs.extend(["--def", def_file]) else: objects.append(def_file) if not debug: extra_preargs.append("-s") UnixCCompiler.link( self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang, ) return
def link(self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): print "LINK" UnixCCompiler.link(self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, export_symbols, debug, extra_preargs, extra_postargs, build_temp, target_lang)
def link( self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None, ): extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) libraries.extend(self.dll_libraries) if export_symbols is not None and target_desc != self.EXECUTABLE: temp_dir = os.path.dirname(objects[0]) dll_name, dll_extension = os.path.splitext(os.path.basename(output_filename)) def_file = os.path.join(temp_dir, dll_name + ".def") contents = [ "LIBRARY %s INITINSTANCE TERMINSTANCE" % os.path.splitext(os.path.basename(output_filename))[0], "DATA MULTIPLE NONSHARED", "EXPORTS", ] for sym in export_symbols: contents.append(' "%s"' % sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) objects.append(def_file) if not debug: extra_preargs.append("-s") UnixCCompiler.link( self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang, ) return
def link( self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, export_symbols=None, # export_symbols, we do this in our def-file debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None, ): if self.gcc_version < "3.0.0": distutils.cygwinccompiler.CygwinCCompiler.link( 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, ) else: UnixCCompiler.link( 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, )
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = ('icc -m64 -fPIC -fp-model strict -O3 ' '-fomit-frame-pointer -openmp -xSSE4.2') compiler = self.cc_exe if platform.system() == 'Darwin': shared_flag = '-Wl,-undefined,dynamic_lookup' else: shared_flag = '-shared' self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' ' + shared_flag + ' -shared-intel')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = ('icc -m64 -fPIC -fp-model strict -O3 ' '-fomit-frame-pointer -openmp') compiler = self.cc_exe if platform.system() == 'Darwin': shared_flag = '-Wl,-undefined,dynamic_lookup' else: shared_flag = '-shared' self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' ' + shared_flag + ' -shared-intel')
def link( self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, export_symbols=None, # export_symbols, we do this in our def-file debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): if self.gcc_version < "3.0.0": distutils.cygwinccompiler.CygwinCCompiler.link( 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) else: UnixCCompiler.link( 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)
def link(self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): """Link the objects.""" # use separate copies, so we can modify the lists libraries = copy.copy(libraries or []) libraries.extend(self.dll_libraries) if os.name == 'nt': sysroot = os.path.dirname(os.path.realpath(sys.executable)) library_dirs = copy.copy(library_dirs or []) library_dirs.append(sysroot) UnixCCompiler.link(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)
def link(self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) libraries.extend(self.dll_libraries) if export_symbols is not None and (target_desc != self.EXECUTABLE or self.linker_dll == 'gcc'): temp_dir = os.path.dirname(objects[0]) dll_name, dll_extension = os.path.splitext( os.path.basename(output_filename)) def_file = os.path.join(temp_dir, dll_name + '.def') lib_file = os.path.join(temp_dir, 'lib' + dll_name + '.a') contents = [ 'LIBRARY %s' % os.path.basename(output_filename), 'EXPORTS' ] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), 'writing %s' % def_file) if self.linker_dll == 'dllwrap': extra_preargs.extend(['--output-lib', lib_file]) extra_preargs.extend(['--def', def_file]) else: objects.append(def_file) if not debug: extra_preargs.append('-s') UnixCCompiler.link(self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang) return
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.cc_exe = ('icc -fPIC -fp-model precise -O3 ' '-fomit-frame-pointer -qopenmp ' '-Wall -Wimplicit ' '-qoffload-option,mic,compiler,' '\'"-fp-model fast=2 -Wl,-zdefs"\'') compiler = self.cc_exe if platform.system() == 'Darwin': shared_flag = '-Wl,-undefined,dynamic_lookup' else: shared_flag = '-shared' self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' ' + shared_flag + ' -shared-intel')
def link(self, target_desc, objects, output_filename, output_dir = None, libraries = None, library_dirs = None, runtime_library_dirs = None, export_symbols = None, debug = 0, extra_preargs = None, extra_postargs = None, build_temp = None, target_lang = None): extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) libraries.extend(self.dll_libraries) if export_symbols is not None and target_desc != self.EXECUTABLE: temp_dir = os.path.dirname(objects[0]) dll_name, dll_extension = os.path.splitext(os.path.basename(output_filename)) def_file = os.path.join(temp_dir, dll_name + '.def') contents = ['LIBRARY %s INITINSTANCE TERMINSTANCE' % os.path.splitext(os.path.basename(output_filename))[0], 'DATA MULTIPLE NONSHARED', 'EXPORTS'] for sym in export_symbols: contents.append(' "%s"' % sym) self.execute(write_file, (def_file, contents), 'writing %s' % def_file) objects.append(def_file) if not debug: extra_preargs.append('-s') UnixCCompiler.link(self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang) return
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) (status, details) = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " "Reason: %s. " "Compiling may fail because of undefined preprocessor macros." % details) # want the gcc library statically linked (so that we don't have # to distribute a version dependent on the compiler we have) # self.dll_libraries=["gcc"] # was removed by the python 3.9 update, as I doubt it makes sense self.dll_libraries = []
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) v = self.get_version() self.cc_exe = ('icc -fPIC -fp-model strict -O3 -fomit-frame-pointer ' + environ.get('CFLAGS', '').strip()) compiler = self.cc_exe if platform.system() == 'Darwin': shared_flag = '-Wl,-undefined,dynamic_lookup' else: shared_flag = '-shared' self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' ' + shared_flag + ' -shared-intel ' + environ.get('LDFLAGS', '').strip())
def __init__ (self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__ (self, verbose, dry_run, force) cc = 'clang' cflags = sysconfig.get_config_var ('CFLAGS') or "" cflags += os.getenv('CFLAGS', '') cshared = sysconfig.get_config_var ('CCSHARED') or "" ldflags = sysconfig.get_config_var ('LDFLAGS') or "" ldflags += os.getenv('LDFLAGS', '') cppflags = os.getenv ('CPPFLAGS', '') cargs = ' ' + cflags + ' ' + cppflags soargs = ' ' + cflags + ' ' + cshared ldargs = ' ' + ldflags self.set_executables(compiler=cc + cargs, compiler_so=cc + soargs, compiler_cxx=cc, linker_exe=cc + ldflags, linker_so=cc + ' -shared')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) v = self.get_version() mpopt = 'openmp' if v and v < '15' else 'qopenmp' self.cc_exe = ('icc -fPIC -fp-model strict -O3 ' '-fomit-frame-pointer -{}').format(mpopt) compiler = self.cc_exe if platform.system() == 'Darwin': shared_flag = '-Wl,-undefined,dynamic_lookup' else: shared_flag = '-shared' self.set_executables(compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver='xiar' + ' cru', linker_exe=compiler + ' -shared-intel', linker_so=compiler + ' ' + shared_flag + ' -shared-intel')
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) v = self.get_version() mpopt = "openmp" if v and v < "15" else "qopenmp" self.cc_exe = ("icc -m64 -fPIC -fp-model strict -O3 " "-fomit-frame-pointer -{}").format(mpopt) compiler = self.cc_exe if platform.system() == "Darwin": shared_flag = "-Wl,-undefined,dynamic_lookup" else: shared_flag = "-shared" self.set_executables( compiler=compiler, compiler_so=compiler, compiler_cxx=compiler, archiver="xiar" + " cru", linker_exe=compiler + " -shared-intel", linker_so=compiler + " " + shared_flag + " -shared-intel", )
def get_ethtool_macro(): # see: https://github.com/giampaolo/psutil/issues/659 from distutils.unixccompiler import UnixCCompiler from distutils.errors import CompileError with tempfile.NamedTemporaryFile(suffix='.c', delete=False, mode="wt") as f: f.write("#include <linux/ethtool.h>") output_dir = tempfile.mkdtemp() try: compiler = UnixCCompiler() # https://github.com/giampaolo/psutil/pull/1568 if os.getenv('CC'): compiler.set_executable('compiler_so', os.getenv('CC')) with silenced_output('stderr'): with silenced_output('stdout'): compiler.compile([f.name], output_dir=output_dir) except CompileError: return ("PSUTIL_ETHTOOL_MISSING_TYPES", 1) else: return None finally: os.remove(f.name) shutil.rmtree(output_dir)
def __init__(self, verbose = 0, dry_run = 0, force = 0): UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn("Python's pyconfig.h doesn't seem to support your compiler. Reason: %s. Compiling may fail because of undefined preprocessor macros." % details) self.gcc_version, self.ld_version, self.dllwrap_version = get_versions() self.debug_print(self.compiler_type + ': gcc %s, ld %s, dllwrap %s\n' % (self.gcc_version, self.ld_version, self.dllwrap_version)) if self.ld_version >= '2.10.90': self.linker_dll = 'gcc' else: self.linker_dll = 'dllwrap' if self.ld_version >= '2.13': shared_option = '-shared' else: shared_option = '-mdll -static' self.set_executables(compiler='gcc -mcygwin -O -Wall', compiler_so='gcc -mcygwin -mdll -O -Wall', compiler_cxx='g++ -mcygwin -O -Wall', linker_exe='gcc -mcygwin', linker_so='%s -mcygwin %s' % (self.linker_dll, shared_option)) if self.gcc_version == '2.91.57': self.dll_libraries = ['msvcrt'] self.warn('Consider upgrading to a newer version of gcc') else: self.dll_libraries = get_msvcr()
def __init__(self, verbose=0, dry_run=0, force=0): try: import tinycc except ImportError: DistutilsPlatformError( "tinycc not installed or not supported for this platform") UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " "Reason: %s. " "Compiling may fail because of undefined preprocessor macros." % details) self.tcc_version = _find_exe_version([tinycc.TCC, '-v']) self.debug_print(self.compiler_type + ": tcc %s\n" % self.tcc_version) self.set_executables( compiler=[tinycc.TCC, '-DMS_WIN64', '-D__TINYCC__', '-Wall'], compiler_so=[tinycc.TCC, '-DMS_WIN64', '-D__TINYCC__', '-Wall'], compiler_cxx=[], linker_exe=[tinycc.TCC], linker_so=[tinycc.TCC, '-shared'], ) # Include the appropriate MSVC runtime library if Python was built # with MSVC 7.0 or later. if os.name == 'nt': self.dll_libraries = get_msvcr() else: self.dll_libraries = []
def link(self, target_desc, objects, output_filename, output_dir = None, libraries = None, library_dirs = None, runtime_library_dirs = None, export_symbols = None, debug = 0, extra_preargs = None, extra_postargs = None, build_temp = None, target_lang = None): extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) libraries.extend(self.dll_libraries) if export_symbols is not None and (target_desc != self.EXECUTABLE or self.linker_dll == 'gcc'): temp_dir = os.path.dirname(objects[0]) dll_name, dll_extension = os.path.splitext(os.path.basename(output_filename)) def_file = os.path.join(temp_dir, dll_name + '.def') lib_file = os.path.join(temp_dir, 'lib' + dll_name + '.a') contents = ['LIBRARY %s' % os.path.basename(output_filename), 'EXPORTS'] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), 'writing %s' % def_file) if self.linker_dll == 'dllwrap': extra_preargs.extend(['--output-lib', lib_file]) extra_preargs.extend(['--def', def_file]) else: objects.append(def_file) if not debug: extra_preargs.append('-s') UnixCCompiler.link(self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang) return
def __init__(self, verbose=0, dry_run=0, force=0): try: import tinycc except ImportError: DistutilsPlatformError("tinycc not installed or not supported for this platform") UnixCCompiler.__init__(self, verbose, dry_run, force) status, details = check_config_h() self.debug_print("Python's GCC status: %s (details: %s)" % (status, details)) if status is not CONFIG_H_OK: self.warn( "Python's pyconfig.h doesn't seem to support your compiler. " "Reason: %s. " "Compiling may fail because of undefined preprocessor macros." % details) self.tcc_version = _find_exe_version([tinycc.TCC, '-v']) self.debug_print(self.compiler_type + ": tcc %s\n" % self.tcc_version) self.set_executables( compiler=[tinycc.TCC, '-DMS_WIN64', '-D__TINYCC__', '-Wall'], compiler_so=[tinycc.TCC, '-DMS_WIN64', '-D__TINYCC__', '-Wall'], compiler_cxx=[], linker_exe=[tinycc.TCC], linker_so=[tinycc.TCC, '-shared'], ) # Include the appropriate MSVC runtime library if Python was built # with MSVC 7.0 or later. if os.name == 'nt': self.dll_libraries = get_msvcr() else: self.dll_libraries = []
def compile_exe(): user = os.path.expanduser("~/.pyinitrd") if not os.path.exists(user): os.mkdir(user) src = os.path.join(user, "gen_init_cpio.c") if not os.path.exists(src): orig = "/usr/src/linux/usr/gen_init_cpio.c" if not os.path.exists(orig): Exception("Requires Linux kernel sources in %r" % orig) shutil.copyfile(orig, src) compiler = UnixCCompiler() obj = os.path.join(user, "gen_init_cpio.o") if not os.path.exists(obj): compiler.compile(["gen_init_cpio.c"], user) exe = os.path.join(user, "gen_init_cpio") if not os.path.exists(exe): print("compiling") compiler.link_executable([obj], exe, user) return exe
def run(self): if not self.extensions: return if self.distribution.has_c_libraries(): build_clib = self.get_finalized_command('build_clib') self.libraries.extend(build_clib.get_library_names() or []) self.library_dirs.append(build_clib.build_clib) from distutils.unixccompiler import UnixCCompiler self.compiler = UnixCCompiler(verbose=self.verbose, dry_run=self.dry_run, force=self.force) self.compiler.shared_lib_extension = ".pyd" # not used :( if self.libraries is not None: self.compiler.set_libraries(self.libraries) if self.library_dirs is not None: self.compiler.set_library_dirs(self.library_dirs) python_lib = "python" + self.cross_ver.replace(".", "") import os.path, subprocess if not os.path.exists(os.path.join(self.cross_dir, python_lib + ".def")): log.info("making def for %s in %s", python_lib, self.cross_dir) subprocess.check_call(["gendef", python_lib + ".dll"], cwd=self.cross_dir) python_lib_fname = self.compiler.static_lib_format % ( python_lib, self.compiler.static_lib_extension) if not os.path.exists(os.path.join(self.cross_dir, python_lib_fname)): log.info("making link library %s for %s in %s", python_lib_fname, python_lib, self.cross_dir) print self.cross_compiler.replace("gcc", "dlltool") subprocess.check_call([ self.cross_compiler.replace( "gcc", "dlltool"), "--dllname", python_lib + ".dll", "--def", python_lib + ".def", "--output-lib", python_lib_fname ], cwd=self.cross_dir) specs_fname = os.path.join(self.cross_dir, "compiler.specs") if not os.path.exists(specs_fname): log.info("making compiler specs %s", specs_fname) msvcr = msvct_table.get(self.cross_ver) newspecs = make_specs(self.cross_compiler, msvcr, int(msvcr[-2:])) fh = open(specs_fname, "w") fh.write(newspecs) fh.close() self.compiler.set_executables( compiler_so="{} -specs={}".format(self.cross_compiler, specs_fname), linker_so="{} -specs={} -static-libgcc -shared".format( self.cross_compiler, specs_fname), ) if "win-amd64" == self.plat_name: self.compiler.define_macro("MS_WIN64") self.compiler.add_library(python_lib) self.compiler.add_library_dir(self.cross_dir) self.compiler.add_include_dir(os.path.join(self.cross_dir, 'include')) # Now actually compile and link everything. self.build_extensions()
def link_shared_object (self, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None): # use separate copies, so we can modify the lists extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) # Additional libraries libraries.extend(self.dll_libraries) # we want to put some files in the same directory as the # object files are, build_temp doesn't help much # where are the object files temp_dir = os.path.dirname(objects[0]) # name of dll to give the helper files (def, lib, exp) the same name (dll_name, dll_extension) = os.path.splitext( os.path.basename(output_filename)) # generate the filenames for these files def_file = None # this will be done later, if necessary exp_file = os.path.join(temp_dir, dll_name + ".exp") lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a") #extra_preargs.append("--verbose") if self.linker == "dllwrap": extra_preargs.extend([#"--output-exp",exp_file, "--output-lib",lib_file, ]) else: # doesn't work: bfd_close build\...\libfoo.a: Invalid operation extra_preargs.extend([#"-Wl,--out-implib,%s" % lib_file, ]) # check what we got in export_symbols if export_symbols is not None: # Make .def file # (It would probably better to check if we really need this, # but for this we had to insert some unchanged parts of # UnixCCompiler, and this is not what we want.) def_file = os.path.join(temp_dir, dll_name + ".def") contents = [ "LIBRARY %s" % os.path.basename(output_filename), "EXPORTS"] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) if def_file: if self.linker == "dllwrap": # for dllwrap we have to use a special option extra_preargs.append("--def") # for gcc/ld it is specified as any other object file extra_preargs.append(def_file) # who wants symbols and a many times larger output file # should explicitly switch the debug mode on # otherwise we let dllwrap/ld strip the output file # (On my machine unstripped_file = stripped_file + 254KB # 10KB < stripped_file < ??100KB ) if not debug: extra_preargs.append("-s") UnixCCompiler.link_shared_object(self, 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)
def __init__(self, verbose=0, dry_run=0, force=0): UnixCCompiler.__init__(self, verbose, dry_run, force) self.set_executable("compiler", "nasm")
def link (self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None): # use separate copies, so we can modify the lists extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) # Additional libraries libraries.extend(self.dll_libraries) # handle export symbols by creating a def-file # with executables this only works with gcc/ld as linker if ((export_symbols is not None) and (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")): # (The linker doesn't do anything if output is up-to-date. # So it would probably better to check if we really need this, # but for this we had to insert some unchanged parts of # UnixCCompiler, and this is not what we want.) # we want to put some files in the same directory as the # object files are, build_temp doesn't help much # where are the object files temp_dir = os.path.dirname(objects[0]) # name of dll to give the helper files the same base name (dll_name, dll_extension) = os.path.splitext( os.path.basename(output_filename)) # generate the filenames for these files def_file = os.path.join(temp_dir, dll_name + ".def") exp_file = os.path.join(temp_dir, dll_name + ".exp") lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a") # Generate .def file contents = [ "LIBRARY %s" % os.path.basename(output_filename), "EXPORTS"] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) # next add options for def-file and to creating import libraries # dllwrap uses different options than gcc/ld if self.linker_dll == "dllwrap": extra_preargs.extend([#"--output-exp",exp_file, "--output-lib",lib_file, ]) # for dllwrap we have to use a special option extra_preargs.extend(["--def", def_file]) # we use gcc/ld here and can be sure ld is >= 2.9.10 else: # doesn't work: bfd_close build\...\libfoo.a: Invalid operation #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file]) # for gcc/ld the def-file is specified as any other object files objects.append(def_file) #end: if ((export_symbols is not None) and # (target_desc <> self.EXECUTABLE or self.linker_dll == "gcc")): # who wants symbols and a many times larger output file # should explicitly switch the debug mode on # otherwise we let dllwrap/ld strip the output file # (On my machine: 10KB < stripped_file < ??100KB # unstripped_file = stripped_file + XXX KB # ( XXX=254 for a typical python extension)) if not debug: extra_preargs.append("-s") UnixCCompiler.link(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)
"""distutils.cygwinccompiler
class BuildExtCommand(build_ext): def run(self): self.run_command('build_yacc') self.run_command('build_lex') build_ext.run(self) try: static_sepol = os.environ['SEPOL'] except KeyError: # try to find libsepol.a. The find_library_file function # chooses dynamic libraries over static ones, so # this assumes that the static lib is in the same directory # as the dynamic lib. dynamic_sepol = UnixCCompiler().find_library_file(['/usr/lib64', '/usr/lib'], 'sepol') static_sepol = dynamic_sepol.replace(".so", ".a") ext_py_mods = [Extension('setools.policyrep._qpol', ['setools/policyrep/qpol.i', 'libqpol/avrule_query.c', 'libqpol/bool_query.c', 'libqpol/bounds_query.c', 'libqpol/class_perm_query.c', 'libqpol/cond_query.c', 'libqpol/constraint_query.c', 'libqpol/context_query.c', 'libqpol/default_object_query.c', 'libqpol/expand.c', 'libqpol/fs_use_query.c', 'libqpol/ftrule_query.c',
def link_shared_object(self, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None): # use separate copies, so we can modify the lists extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) # Additional libraries libraries.extend(self.dll_libraries) # we want to put some files in the same directory as the # object files are, build_temp doesn't help much # where are the object files temp_dir = os.path.dirname(objects[0]) # name of dll to give the helper files (def, lib, exp) the same name (dll_name, dll_extension) = os.path.splitext(os.path.basename(output_filename)) # generate the filenames for these files def_file = None # this will be done later, if necessary exp_file = os.path.join(temp_dir, dll_name + ".exp") lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a") #extra_preargs.append("--verbose") if self.linker == "dllwrap": extra_preargs.extend([ #"--output-exp",exp_file, "--output-lib", lib_file, ]) else: # doesn't work: bfd_close build\...\libfoo.a: Invalid operation extra_preargs.extend([ #"-Wl,--out-implib,%s" % lib_file, ]) # check what we got in export_symbols if export_symbols is not None: # Make .def file # (It would probably better to check if we really need this, # but for this we had to insert some unchanged parts of # UnixCCompiler, and this is not what we want.) def_file = os.path.join(temp_dir, dll_name + ".def") contents = [ "LIBRARY %s" % os.path.basename(output_filename), "EXPORTS" ] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) if def_file: if self.linker == "dllwrap": # for dllwrap we have to use a special option extra_preargs.append("--def") # for gcc/ld it is specified as any other object file extra_preargs.append(def_file) # who wants symbols and a many times larger output file # should explicitly switch the debug mode on # otherwise we let dllwrap/ld strip the output file # (On my machine unstripped_file = stripped_file + 254KB # 10KB < stripped_file < ??100KB ) if not debug: extra_preargs.append("-s") UnixCCompiler.link_shared_object( self, 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)
def link(self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): # use separate copies, so we can modify the lists extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) # Additional libraries libraries.extend(self.dll_libraries) # handle export symbols by creating a def-file # with executables this only works with gcc/ld as linker if ((export_symbols is not None) and (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")): # (The linker doesn't do anything if output is up-to-date. # So it would probably better to check if we really need this, # but for this we had to insert some unchanged parts of # UnixCCompiler, and this is not what we want.) # we want to put some files in the same directory as the # object files are, build_temp doesn't help much # where are the object files temp_dir = os.path.dirname(objects[0]) # name of dll to give the helper files the same base name (dll_name, dll_extension) = os.path.splitext( os.path.basename(output_filename)) # generate the filenames for these files def_file = os.path.join(temp_dir, dll_name + ".def") lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a") # Generate .def file contents = [ "LIBRARY %s" % os.path.basename(output_filename), "EXPORTS" ] for sym in export_symbols: contents.append(sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) # next add options for def-file and to creating import libraries # dllwrap uses different options than gcc/ld if self.linker_dll == "dllwrap": extra_preargs.extend(["--output-lib", lib_file]) # for dllwrap we have to use a special option extra_preargs.extend(["--def", def_file]) # we use gcc/ld here and can be sure ld is >= 2.9.10 else: # doesn't work: bfd_close build\...\libfoo.a: Invalid operation #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file]) # for gcc/ld the def-file is specified as any object files objects.append(def_file) #end: if ((export_symbols is not None) and # (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")): # who wants symbols and a many times larger output file # should explicitly switch the debug mode on # otherwise we let dllwrap/ld strip the output file # (On my machine: 10KB < stripped_file < ??100KB # unstripped_file = stripped_file + XXX KB # ( XXX=254 for a typical python extension)) if not debug: extra_preargs.append("-s") UnixCCompiler.link( 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)
class cross_build_ext(build_ext): user_options = build_ext.user_options + [ ('cross-dir=', None, "Python headers and libraries for cross compilation"), ('cross-ver=', None, "version for cross compilation"), ('cross-compiler=', None, "compiler for cross compilation"), ] def initialize_options(self): build_ext.initialize_options(self) self.cross_dir = None self.cross_ver = None self.cross_compiler = None def finalize_options(self): build_ext.finalize_options(self) self.set_undefined_options('build', ('cross_dir', 'cross_dir'), ('cross_ver', 'cross_ver'), ('cross_compiler', 'cross_compiler'), ) if self.cross_compiler is None: self.cross_compiler = { "win32": "i686-w64-mingw32-gcc", "win-amd64": "x86_64-w64-mingw32-gcc" }.get(self.plat_name) def run(self): if not self.extensions: return if self.distribution.has_c_libraries(): build_clib = self.get_finalized_command('build_clib') self.libraries.extend(build_clib.get_library_names() or []) self.library_dirs.append(build_clib.build_clib) from distutils.unixccompiler import UnixCCompiler self.compiler = UnixCCompiler(verbose=self.verbose, dry_run=self.dry_run, force=self.force) self.compiler.shared_lib_extension = ".pyd" # not used :( if self.libraries is not None: self.compiler.set_libraries(self.libraries) if self.library_dirs is not None: self.compiler.set_library_dirs(self.library_dirs) python_lib = "python"+self.cross_ver.replace(".","") import os.path, subprocess if not os.path.exists( os.path.join(self.cross_dir, python_lib+".def") ): log.info("making def for %s in %s", python_lib, self.cross_dir) subprocess.check_call(["gendef", python_lib+".dll"], cwd=self.cross_dir) python_lib_fname = self.compiler.static_lib_format % (python_lib, self.compiler.static_lib_extension ) if not os.path.exists( os.path.join(self.cross_dir, python_lib_fname) ): log.info("making link library %s for %s in %s", python_lib_fname, python_lib, self.cross_dir) print self.cross_compiler.replace("gcc","dlltool") subprocess.check_call([self.cross_compiler.replace("gcc","dlltool"), "--dllname", python_lib+".dll", "--def", python_lib+".def", "--output-lib", python_lib_fname], cwd=self.cross_dir) specs_fname = os.path.join(self.cross_dir, "compiler.specs") if not os.path.exists(specs_fname): log.info("making compiler specs %s", specs_fname) msvcr = msvct_table.get(self.cross_ver) newspecs = make_specs(self.cross_compiler, msvcr, int(msvcr[-2:])) fh = open(specs_fname, "w") fh.write(newspecs) fh.close() self.compiler.set_executables( compiler_so="{} -specs={}".format(self.cross_compiler, specs_fname), linker_so="{} -specs={} -static-libgcc -shared".format(self.cross_compiler, specs_fname), ) if "win-amd64" == self.plat_name: self.compiler.define_macro("MS_WIN64") self.compiler.add_library(python_lib) self.compiler.add_library_dir(self.cross_dir) self.compiler.add_include_dir(os.path.join(self.cross_dir, 'include')) # Now actually compile and link everything. self.build_extensions() def get_ext_filename(self, ext_name): return build_ext.get_ext_filename(self, ext_name).replace(".so",".pyd")
def link (self, target_desc, objects, output_filename, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None): # use separate copies, so we can modify the lists extra_preargs = copy.copy(extra_preargs or []) libraries = copy.copy(libraries or []) objects = copy.copy(objects or []) # Additional libraries libraries.extend(self.dll_libraries) # handle export symbols by creating a def-file # with executables this only works with gcc/ld as linker if ((export_symbols is not None) and (target_desc != self.EXECUTABLE)): # (The linker doesn't do anything if output is up-to-date. # So it would probably better to check if we really need this, # but for this we had to insert some unchanged parts of # UnixCCompiler, and this is not what we want.) # we want to put some files in the same directory as the # object files are, build_temp doesn't help much # where are the object files temp_dir = os.path.dirname(objects[0]) # name of dll to give the helper files the same base name (dll_name, dll_extension) = os.path.splitext( os.path.basename(output_filename)) # generate the filenames for these files def_file = os.path.join(temp_dir, dll_name + ".def") # Generate .def file contents = [ "LIBRARY %s INITINSTANCE TERMINSTANCE" % \ os.path.splitext(os.path.basename(output_filename))[0], "DATA MULTIPLE NONSHARED", "EXPORTS"] for sym in export_symbols: contents.append(' "%s"' % sym) self.execute(write_file, (def_file, contents), "writing %s" % def_file) # next add options for def-file and to creating import libraries # for gcc/ld the def-file is specified as any other object files objects.append(def_file) #end: if ((export_symbols is not None) and # (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")): # who wants symbols and a many times larger output file # should explicitly switch the debug mode on # otherwise we let dllwrap/ld strip the output file # (On my machine: 10KB < stripped_file < ??100KB # unstripped_file = stripped_file + XXX KB # ( XXX=254 for a typical python extension)) if not debug: extra_preargs.append("-s") UnixCCompiler.link(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)
def get_flann_lib(): ''' Gets the location of the flann library that users should link against. ''' # Would make sense to have setup.py write out a file containing the location # it found (like what CMake does), but that doesn't work with Anaconda envs. global _flann_lib if _flann_lib is not None: return _flann_lib import os import re from subprocess import check_output import sys so_name = index.__file__ if sys.platform == 'darwin': # this is gross. it'd be better to not have to do all this. out = check_output(['otool', '-L', so_name]).decode().splitlines() assert out.pop(0) == so_name + ':' for line in out: assert line[0] == '\t' fname = line.split(None, 1)[0] if 'libflann' in fname and 'libflann_cpp' not in fname: if fname.startswith('@rpath'): o = check_output(['otool', '-l', so_name]).decode() i = o.index('cmd LC_RPATH') lines = o[i:].splitlines() assert lines[0].strip() == 'cmd LC_RPATH' assert re.match(r'cmdsize \d+$', lines[1].strip()) m = re.match(r'path (.*) \(offset \d+\)$', lines[2].strip()) assert m fname = fname.replace('@rpath', m.group(1)) fname = fname.replace('@loader_path', os.path.dirname(so_name)) if '/' not in fname: # relative install_names, dammit # look for it in the standard places... dirs = ['/usr/local/lib', '/usr/lib', '/lib'] if 'LIBRARY_PATH' in os.environ: dirs = os.environ['LIBRARY_PATH'].split(':') + dirs from distutils.unixccompiler import UnixCCompiler assert fname.startswith('lib') assert fname.endswith('.dylib') basename = fname[len('lib'):-len('.dylib')] fname = UnixCCompiler().find_library_file(dirs, basename) if fname is None: msg = "Can't find library file lib{}.dylib" raise ValueError(msg.format(basename)) assert fname.startswith('/') _flann_lib = os.path.abspath(fname) return _flann_lib elif sys.platform.startswith('linux'): out = check_output(['ldd', so_name]).decode().splitlines() for line in out: match = _ldd_re.match(line) if not match: import warnings warnings.warn("Confused by ldd output line: {}".format(line)) continue shortname, path = match.groups() if 'libflann' in shortname and 'libflann_cpp' not in shortname: if path: _flann_lib = os.path.abspath(path) return _flann_lib else: raise OSError("get_flann_lib doesn't know how to handle this OS")