Python code coverage for Lib/packaging/compiler/cygwinccompiler.py

#	count	content
1	n/a	"""CCompiler implementations for Cygwin and mingw32 versions of GCC.
2	n/a
3	n/a	This module contains the CygwinCCompiler class, a subclass of
4	n/a	UnixCCompiler that handles the Cygwin port of the GNU C compiler to
5	n/a	Windows, and the Mingw32CCompiler class which handles the mingw32 port
6	n/a	of GCC (same as cygwin in no-cygwin mode).
7	n/a	"""
8	n/a
9	n/a	# problems:
10	n/a	#
11	n/a	# * if you use a msvc compiled python version (1.5.2)
12	n/a	# 1. you have to insert a __GNUC__ section in its config.h
13	n/a	# 2. you have to generate a import library for its dll
14	n/a	# - create a def-file for python??.dll
15	n/a	# - create a import library using
16	n/a	# dlltool --dllname python15.dll --def python15.def \
17	n/a	# --output-lib libpython15.a
18	n/a	#
19	n/a	# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
20	n/a	#
21	n/a	# * We put export_symbols in a def-file, and don't use
22	n/a	# --export-all-symbols because it doesn't worked reliable in some
23	n/a	# tested configurations. And because other windows compilers also
24	n/a	# need their symbols specified this no serious problem.
25	n/a	#
26	n/a	# tested configurations:
27	n/a	#
28	n/a	# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
29	n/a	# (after patching python's config.h and for C++ some other include files)
30	n/a	# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
31	n/a	# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
32	n/a	# (ld doesn't support -shared, so we use dllwrap)
33	n/a	# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
34	n/a	# - its dllwrap doesn't work, there is a bug in binutils 2.10.90
35	n/a	# see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
36	n/a	# - using gcc -mdll instead dllwrap doesn't work without -static because
37	n/a	# it tries to link against dlls instead their import libraries. (If
38	n/a	# it finds the dll first.)
39	n/a	# By specifying -static we force ld to link against the import libraries,
40	n/a	# this is windows standard and there are normally not the necessary symbols
41	n/a	# in the dlls.
42	n/a	# *** only the version of June 2000 shows these problems
43	n/a	# * cygwin gcc 3.2/ld 2.13.90 works
44	n/a	# (ld supports -shared)
45	n/a	# * mingw gcc 3.2/ld 2.13 works
46	n/a	# (ld supports -shared)
47	n/a
48	n/a
49	n/a	import os
50	n/a	import sys
51	n/a
52	n/a	from packaging import logger
53	n/a	from packaging.compiler.unixccompiler import UnixCCompiler
54	n/a	from packaging.util import write_file
55	n/a	from packaging.errors import PackagingExecError, CompileError, UnknownFileError
56	n/a	from packaging.util import get_compiler_versions
57	n/a	import sysconfig
58	n/a
59	n/a	# TODO use platform instead of sys.version
60	n/a	# (platform does unholy sys.version parsing too, but at least it gives other
61	n/a	# VMs a chance to override the returned values)
62	n/a
63	n/a
64	n/a	def get_msvcr():
65	n/a	"""Include the appropriate MSVC runtime library if Python was built
66	n/a	with MSVC 7.0 or later.
67	n/a	"""
68	n/a	msc_pos = sys.version.find('MSC v.')
69	n/a	if msc_pos != -1:
70	n/a	msc_ver = sys.version[msc_pos+6:msc_pos+10]
71	n/a	if msc_ver == '1300':
72	n/a	# MSVC 7.0
73	n/a	return ['msvcr70']
74	n/a	elif msc_ver == '1310':
75	n/a	# MSVC 7.1
76	n/a	return ['msvcr71']
77	n/a	elif msc_ver == '1400':
78	n/a	# VS2005 / MSVC 8.0
79	n/a	return ['msvcr80']
80	n/a	elif msc_ver == '1500':
81	n/a	# VS2008 / MSVC 9.0
82	n/a	return ['msvcr90']
83	n/a	else:
84	n/a	raise ValueError("Unknown MS Compiler version %s " % msc_ver)
85	n/a
86	n/a
87	n/a	class CygwinCCompiler(UnixCCompiler):
88	n/a	""" Handles the Cygwin port of the GNU C compiler to Windows.
89	n/a	"""
90	n/a	name = 'cygwin'
91	n/a	description = 'Cygwin port of GNU C Compiler for Win32'
92	n/a	obj_extension = ".o"
93	n/a	static_lib_extension = ".a"
94	n/a	shared_lib_extension = ".dll"
95	n/a	static_lib_format = "lib%s%s"
96	n/a	shared_lib_format = "%s%s"
97	n/a	exe_extension = ".exe"
98	n/a
99	n/a	def __init__(self, dry_run=False, force=False):
100	n/a	super(CygwinCCompiler, self).__init__(dry_run, force)
101	n/a
102	n/a	status, details = check_config_h()
103	n/a	logger.debug("Python's GCC status: %s (details: %s)", status, details)
104	n/a	if status is not CONFIG_H_OK:
105	n/a	self.warn(
106	n/a	"Python's pyconfig.h doesn't seem to support your compiler. "
107	n/a	"Reason: %s. "
108	n/a	"Compiling may fail because of undefined preprocessor macros."
109	n/a	% details)
110	n/a
111	n/a	self.gcc_version, self.ld_version, self.dllwrap_version = \
112	n/a	get_compiler_versions()
113	n/a	logger.debug(self.name + ": gcc %s, ld %s, dllwrap %s\n",
114	n/a	self.gcc_version,
115	n/a	self.ld_version,
116	n/a	self.dllwrap_version)
117	n/a
118	n/a	# ld_version >= "2.10.90" and < "2.13" should also be able to use
119	n/a	# gcc -mdll instead of dllwrap
120	n/a	# Older dllwraps had own version numbers, newer ones use the
121	n/a	# same as the rest of binutils ( also ld )
122	n/a	# dllwrap 2.10.90 is buggy
123	n/a	if self.ld_version >= "2.10.90":
124	n/a	self.linker_dll = "gcc"
125	n/a	else:
126	n/a	self.linker_dll = "dllwrap"
127	n/a
128	n/a	# ld_version >= "2.13" support -shared so use it instead of
129	n/a	# -mdll -static
130	n/a	if self.ld_version >= "2.13":
131	n/a	shared_option = "-shared"
132	n/a	else:
133	n/a	shared_option = "-mdll -static"
134	n/a
135	n/a	# Hard-code GCC because that's what this is all about.
136	n/a	# XXX optimization, warnings etc. should be customizable.
137	n/a	self.set_executables(compiler='gcc -mcygwin -O -Wall',
138	n/a	compiler_so='gcc -mcygwin -mdll -O -Wall',
139	n/a	compiler_cxx='g++ -mcygwin -O -Wall',
140	n/a	linker_exe='gcc -mcygwin',
141	n/a	linker_so=('%s -mcygwin %s' %
142	n/a	(self.linker_dll, shared_option)))
143	n/a
144	n/a	# cygwin and mingw32 need different sets of libraries
145	n/a	if self.gcc_version == "2.91.57":
146	n/a	# cygwin shouldn't need msvcrt, but without the dlls will crash
147	n/a	# (gcc version 2.91.57) -- perhaps something about initialization
148	n/a	self.dll_libraries=["msvcrt"]
149	n/a	self.warn(
150	n/a	"Consider upgrading to a newer version of gcc")
151	n/a	else:
152	n/a	# Include the appropriate MSVC runtime library if Python was built
153	n/a	# with MSVC 7.0 or later.
154	n/a	self.dll_libraries = get_msvcr()
155	n/a
156	n/a	def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
157	n/a	"""Compile the source by spawning GCC and windres if needed."""
158	n/a	if ext == '.rc' or ext == '.res':
159	n/a	# gcc needs '.res' and '.rc' compiled to object files !!!
160	n/a	try:
161	n/a	self.spawn(["windres", "-i", src, "-o", obj])
162	n/a	except PackagingExecError as msg:
163	n/a	raise CompileError(msg)
164	n/a	else: # for other files use the C-compiler
165	n/a	try:
166	n/a	self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
167	n/a	extra_postargs)
168	n/a	except PackagingExecError as msg:
169	n/a	raise CompileError(msg)
170	n/a
171	n/a	def link(self, target_desc, objects, output_filename, output_dir=None,
172	n/a	libraries=None, library_dirs=None, runtime_library_dirs=None,
173	n/a	export_symbols=None, debug=False, extra_preargs=None,
174	n/a	extra_postargs=None, build_temp=None, target_lang=None):
175	n/a	"""Link the objects."""
176	n/a	# use separate copies, so we can modify the lists
177	n/a	extra_preargs = list(extra_preargs or [])
178	n/a	libraries = list(libraries or [])
179	n/a	objects = list(objects or [])
180	n/a
181	n/a	# Additional libraries
182	n/a	libraries.extend(self.dll_libraries)
183	n/a
184	n/a	# handle export symbols by creating a def-file
185	n/a	# with executables this only works with gcc/ld as linker
186	n/a	if ((export_symbols is not None) and
187	n/a	(target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
188	n/a	# (The linker doesn't do anything if output is up-to-date.
189	n/a	# So it would probably better to check if we really need this,
190	n/a	# but for this we had to insert some unchanged parts of
191	n/a	# UnixCCompiler, and this is not what we want.)
192	n/a
193	n/a	# we want to put some files in the same directory as the
194	n/a	# object files are, build_temp doesn't help much
195	n/a	# where are the object files
196	n/a	temp_dir = os.path.dirname(objects[0])
197	n/a	# name of dll to give the helper files the same base name
198	n/a	dll_name, dll_extension = os.path.splitext(
199	n/a	os.path.basename(output_filename))
200	n/a
201	n/a	# generate the filenames for these files
202	n/a	def_file = os.path.join(temp_dir, dll_name + ".def")
203	n/a	lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
204	n/a
205	n/a	# Generate .def file
206	n/a	contents = [
207	n/a	"LIBRARY %s" % os.path.basename(output_filename),
208	n/a	"EXPORTS"]
209	n/a	for sym in export_symbols:
210	n/a	contents.append(sym)
211	n/a	self.execute(write_file, (def_file, contents),
212	n/a	"writing %s" % def_file)
213	n/a
214	n/a	# next add options for def-file and to creating import libraries
215	n/a
216	n/a	# dllwrap uses different options than gcc/ld
217	n/a	if self.linker_dll == "dllwrap":
218	n/a	extra_preargs.extend(("--output-lib", lib_file))
219	n/a	# for dllwrap we have to use a special option
220	n/a	extra_preargs.extend(("--def", def_file))
221	n/a	# we use gcc/ld here and can be sure ld is >= 2.9.10
222	n/a	else:
223	n/a	# doesn't work: bfd_close build\...\libfoo.a: Invalid operation
224	n/a	#extra_preargs.extend(("-Wl,--out-implib,%s" % lib_file))
225	n/a	# for gcc/ld the def-file is specified as any object files
226	n/a	objects.append(def_file)
227	n/a
228	n/a	#end: if ((export_symbols is not None) and
229	n/a	# (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
230	n/a
231	n/a	# who wants symbols and a many times larger output file
232	n/a	# should explicitly switch the debug mode on
233	n/a	# otherwise we let dllwrap/ld strip the output file
234	n/a	# (On my machine: 10KB < stripped_file < ??100KB
235	n/a	# unstripped_file = stripped_file + XXX KB
236	n/a	# ( XXX=254 for a typical python extension))
237	n/a	if not debug:
238	n/a	extra_preargs.append("-s")
239	n/a
240	n/a	super(CygwinCCompiler, self).link(
241	n/a	target_desc, objects, output_filename, output_dir, libraries,
242	n/a	library_dirs, runtime_library_dirs,
243	n/a	None, # export_symbols, we do this in our def-file
244	n/a	debug, extra_preargs, extra_postargs, build_temp, target_lang)
245	n/a
246	n/a	# -- Miscellaneous methods -----------------------------------------
247	n/a
248	n/a	def object_filenames(self, source_filenames, strip_dir=False,
249	n/a	output_dir=''):
250	n/a	"""Adds supports for rc and res files."""
251	n/a	if output_dir is None:
252	n/a	output_dir = ''
253	n/a	obj_names = []
254	n/a	for src_name in source_filenames:
255	n/a	# use normcase to make sure '.rc' is really '.rc' and not '.RC'
256	n/a	base, ext = os.path.splitext(os.path.normcase(src_name))
257	n/a	if ext not in (self.src_extensions + ['.rc','.res']):
258	n/a	raise UnknownFileError("unknown file type '%s' (from '%s')" % (ext, src_name))
259	n/a	if strip_dir:
260	n/a	base = os.path.basename(base)
261	n/a	if ext in ('.res', '.rc'):
262	n/a	# these need to be compiled to object files
263	n/a	obj_names.append(os.path.join(output_dir,
264	n/a	base + ext + self.obj_extension))
265	n/a	else:
266	n/a	obj_names.append(os.path.join(output_dir,
267	n/a	base + self.obj_extension))
268	n/a	return obj_names
269	n/a
270	n/a	# the same as cygwin plus some additional parameters
271	n/a	class Mingw32CCompiler(CygwinCCompiler):
272	n/a	""" Handles the Mingw32 port of the GNU C compiler to Windows.
273	n/a	"""
274	n/a	name = 'mingw32'
275	n/a	description = 'MinGW32 compiler'
276	n/a
277	n/a	def __init__(self, dry_run=False, force=False):
278	n/a	super(Mingw32CCompiler, self).__init__(dry_run, force)
279	n/a
280	n/a	# ld_version >= "2.13" support -shared so use it instead of
281	n/a	# -mdll -static
282	n/a	if self.ld_version >= "2.13":
283	n/a	shared_option = "-shared"
284	n/a	else:
285	n/a	shared_option = "-mdll -static"
286	n/a
287	n/a	# A real mingw32 doesn't need to specify a different entry point,
288	n/a	# but cygwin 2.91.57 in no-cygwin-mode needs it.
289	n/a	if self.gcc_version <= "2.91.57":
290	n/a	entry_point = '--entry _DllMain@12'
291	n/a	else:
292	n/a	entry_point = ''
293	n/a
294	n/a	self.set_executables(compiler='gcc -mno-cygwin -O -Wall',
295	n/a	compiler_so='gcc -mno-cygwin -mdll -O -Wall',
296	n/a	compiler_cxx='g++ -mno-cygwin -O -Wall',
297	n/a	linker_exe='gcc -mno-cygwin',
298	n/a	linker_so='%s -mno-cygwin %s %s'
299	n/a	% (self.linker_dll, shared_option,
300	n/a	entry_point))
301	n/a	# Maybe we should also append -mthreads, but then the finished
302	n/a	# dlls need another dll (mingwm10.dll see Mingw32 docs)
303	n/a	# (-mthreads: Support thread-safe exception handling on `Mingw32')
304	n/a
305	n/a	# no additional libraries needed
306	n/a	self.dll_libraries=[]
307	n/a
308	n/a	# Include the appropriate MSVC runtime library if Python was built
309	n/a	# with MSVC 7.0 or later.
310	n/a	self.dll_libraries = get_msvcr()
311	n/a
312	n/a	# Because these compilers aren't configured in Python's pyconfig.h file by
313	n/a	# default, we should at least warn the user if he is using a unmodified
314	n/a	# version.
315	n/a
316	n/a	CONFIG_H_OK = "ok"
317	n/a	CONFIG_H_NOTOK = "not ok"
318	n/a	CONFIG_H_UNCERTAIN = "uncertain"
319	n/a
320	n/a	def check_config_h():
321	n/a	"""Check if the current Python installation appears amenable to building
322	n/a	extensions with GCC.
323	n/a
324	n/a	Returns a tuple (status, details), where 'status' is one of the following
325	n/a	constants:
326	n/a
327	n/a	- CONFIG_H_OK: all is well, go ahead and compile
328	n/a	- CONFIG_H_NOTOK: doesn't look good
329	n/a	- CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
330	n/a
331	n/a	'details' is a human-readable string explaining the situation.
332	n/a
333	n/a	Note there are two ways to conclude "OK": either 'sys.version' contains
334	n/a	the string "GCC" (implying that this Python was built with GCC), or the
335	n/a	installed "pyconfig.h" contains the string "__GNUC__".
336	n/a	"""
337	n/a
338	n/a	# XXX since this function also checks sys.version, it's not strictly a
339	n/a	# "pyconfig.h" check -- should probably be renamed...
340	n/a	# if sys.version contains GCC then python was compiled with GCC, and the
341	n/a	# pyconfig.h file should be OK
342	n/a	if "GCC" in sys.version:
343	n/a	return CONFIG_H_OK, "sys.version mentions 'GCC'"
344	n/a
345	n/a	# let's see if __GNUC__ is mentioned in python.h
346	n/a	fn = sysconfig.get_config_h_filename()
347	n/a	try:
348	n/a	with open(fn) as config_h:
349	n/a	if "__GNUC__" in config_h.read():
350	n/a	return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
351	n/a	else:
352	n/a	return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
353	n/a	except IOError as exc:
354	n/a	return (CONFIG_H_UNCERTAIN,
355	n/a	"couldn't read '%s': %s" % (fn, exc.strerror))