Context Navigation

source: mainline/tools/autotool.py@ a420203

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since a420203 was a420203, checked in by Martin Decky <martin@…>, 10 years ago
use distinct file names for int128 probe (for easier debugging)
Property mode set to `100755`
File size: 32.1 KB

Line
1	#!/usr/bin/env python
2	#
3	# Copyright (c) 2010 Martin Decky
4	# All rights reserved.
5	#
6	# Redistribution and use in source and binary forms, with or without
7	# modification, are permitted provided that the following conditions
8	# are met:
9	#
10	# - Redistributions of source code must retain the above copyright
11	# notice, this list of conditions and the following disclaimer.
12	# - Redistributions in binary form must reproduce the above copyright
13	# notice, this list of conditions and the following disclaimer in the
14	# documentation and/or other materials provided with the distribution.
15	# - The name of the author may not be used to endorse or promote products
16	# derived from this software without specific prior written permission.
17	#
18	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	#
29
30	"""
31	Detect important prerequisites and parameters for building HelenOS
32	"""
33
34	import sys
35	import os
36	import shutil
37	import re
38	import time
39	import subprocess
40
41	SANDBOX = 'autotool'
42	CONFIG = 'Makefile.config'
43	MAKEFILE = 'Makefile.common'
44	HEADER = 'common.h'
45	GUARD = 'AUTOTOOL_COMMON_H_'
46
47	PROBE_SOURCE = 'probe.c'
48	PROBE_OUTPUT = 'probe.s'
49
50	PROBE_INT128_SOURCE = 'probe_int128.c'
51	PROBE_INT128_OUTPUT = 'probe_int128.s'
52
53	PACKAGE_BINUTILS = "usually part of binutils"
54	PACKAGE_GCC = "preferably version 4.7.0 or newer"
55	PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
56
57	COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
58	COMPILER_WARNING = "The compilation of HelenOS might fail."
59
60	PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, strc, conc, value) \\
61	asm volatile ( \\
62	"AUTOTOOL_DECLARE\\t" category "\\t" subcategory "\\t" tag "\\t" name "\\t" strc "\\t" conc "\\t%[val]\\n" \\
63	: \\
64	: [val] "n" (value) \\
65	)
66
67	#define STRING(arg) STRING_ARG(arg)
68	#define STRING_ARG(arg) #arg
69
70	#define DECLARE_BUILTIN_TYPE(tag, type) \\
71	AUTOTOOL_DECLARE("builtin_size", "", tag, STRING(type), "", "", sizeof(type)); \\
72	AUTOTOOL_DECLARE("builtin_sign", "unsigned long long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long long int)); \\
73	AUTOTOOL_DECLARE("builtin_sign", "unsigned long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long int)); \\
74	AUTOTOOL_DECLARE("builtin_sign", "unsigned int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned int)); \\
75	AUTOTOOL_DECLARE("builtin_sign", "unsigned short int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned short int)); \\
76	AUTOTOOL_DECLARE("builtin_sign", "unsigned char", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned char)); \\
77	AUTOTOOL_DECLARE("builtin_sign", "signed long long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long long int)); \\
78	AUTOTOOL_DECLARE("builtin_sign", "signed long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long int)); \\
79	AUTOTOOL_DECLARE("builtin_sign", "signed int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed int)); \\
80	AUTOTOOL_DECLARE("builtin_sign", "signed short int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed short int)); \\
81	AUTOTOOL_DECLARE("builtin_sign", "signed char", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed char));
82
83	#define DECLARE_INTSIZE(tag, type, strc, conc) \\
84	AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
85	AUTOTOOL_DECLARE("intsize", "signed", tag, #type, strc, conc, sizeof(signed type));
86
87	#define DECLARE_FLOATSIZE(tag, type) \\
88	AUTOTOOL_DECLARE("floatsize", "", tag, #type, "", "", sizeof(type));
89
90	int main(int argc, char *argv[])
91	{
92	#ifdef __SIZE_TYPE__
93	DECLARE_BUILTIN_TYPE("size", __SIZE_TYPE__);
94	#endif
95	#ifdef __WCHAR_TYPE__
96	DECLARE_BUILTIN_TYPE("wchar", __WCHAR_TYPE__);
97	#endif
98	#ifdef __WINT_TYPE__
99	DECLARE_BUILTIN_TYPE("wint", __WINT_TYPE__);
100	#endif
101	"""
102
103	PROBE_TAIL = """}
104	"""
105
106	PROBE_INT128_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, strc, conc, value) \\
107	asm volatile ( \\
108	"AUTOTOOL_DECLARE\\t" category "\\t" subcategory "\\t" tag "\\t" name "\\t" strc "\\t" conc "\\t%[val]\\n" \\
109	: \\
110	: [val] "n" (value) \\
111	)
112
113	#define DECLARE_INTSIZE(tag, type) \\
114	AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, "", "", sizeof(unsigned type)); \\
115	AUTOTOOL_DECLARE("intsize", "signed", tag, #type, "", "", sizeof(signed type));
116
117	int main(int argc, char *argv[])
118	{
119	"""
120
121	PROBE_INT128_TAIL = """}
122	"""
123
124	def read_config(fname, config):
125	"Read HelenOS build configuration"
126
127	inf = open(fname, 'r')
128
129	for line in inf:
130	res = re.match(r'^(?:#!# )?([^#]\w)\s=\s(.?)\s*$', line)
131	if (res):
132	config[res.group(1)] = res.group(2)
133
134	inf.close()
135
136	def print_error(msg):
137	"Print a bold error message"
138
139	sys.stderr.write("\n")
140	sys.stderr.write("######################################################################\n")
141	sys.stderr.write("HelenOS build sanity check error:\n")
142	sys.stderr.write("\n")
143	sys.stderr.write("%s\n" % "\n".join(msg))
144	sys.stderr.write("######################################################################\n")
145	sys.stderr.write("\n")
146
147	sys.exit(1)
148
149	def print_warning(msg):
150	"Print a bold error message"
151
152	sys.stderr.write("\n")
153	sys.stderr.write("######################################################################\n")
154	sys.stderr.write("HelenOS build sanity check warning:\n")
155	sys.stderr.write("\n")
156	sys.stderr.write("%s\n" % "\n".join(msg))
157	sys.stderr.write("######################################################################\n")
158	sys.stderr.write("\n")
159
160	time.sleep(5)
161
162	def sandbox_enter():
163	"Create a temporal sandbox directory for running tests"
164
165	if (os.path.exists(SANDBOX)):
166	if (os.path.isdir(SANDBOX)):
167	try:
168	shutil.rmtree(SANDBOX)
169	except:
170	print_error(["Unable to cleanup the directory \"%s\"." % SANDBOX])
171	else:
172	print_error(["Please inspect and remove unexpected directory,",
173	"entry \"%s\"." % SANDBOX])
174
175	try:
176	os.mkdir(SANDBOX)
177	except:
178	print_error(["Unable to create sandbox directory \"%s\"." % SANDBOX])
179
180	owd = os.getcwd()
181	os.chdir(SANDBOX)
182
183	return owd
184
185	def sandbox_leave(owd):
186	"Leave the temporal sandbox directory"
187
188	os.chdir(owd)
189
190	def check_config(config, key):
191	"Check whether the configuration key exists"
192
193	if (not key in config):
194	print_error(["Build configuration of HelenOS does not contain %s." % key,
195	"Try running \"make config\" again.",
196	"If the problem persists, please contact the developers of HelenOS."])
197
198	def check_common(common, key):
199	"Check whether the common key exists"
200
201	if (not key in common):
202	print_error(["Failed to determine the value %s." % key,
203	"Please contact the developers of HelenOS."])
204
205	def get_target(config):
206	target = None
207	gnu_target = None
208	clang_target = None
209	helenos_target = None
210	cc_args = []
211
212	if (config['PLATFORM'] == "abs32le"):
213	check_config(config, "CROSS_TARGET")
214	target = config['CROSS_TARGET']
215
216	if (config['CROSS_TARGET'] == "arm32"):
217	gnu_target = "arm-linux-gnueabi"
218	clang_target = "arm-unknown-linux"
219	helenos_target = "arm-helenos-gnueabi"
220
221	if (config['CROSS_TARGET'] == "ia32"):
222	gnu_target = "i686-pc-linux-gnu"
223	clang_target = "i386-unknown-linux"
224	helenos_target = "i686-pc-helenos"
225
226	if (config['CROSS_TARGET'] == "mips32"):
227	gnu_target = "mipsel-linux-gnu"
228	clang_target = "mipsel-unknown-linux"
229	helenos_target = "mipsel-helenos"
230	common['CC_ARGS'].append("-mabi=32")
231
232	if (config['PLATFORM'] == "amd64"):
233	target = config['PLATFORM']
234	gnu_target = "amd64-linux-gnu"
235	clang_target = "x86_64-unknown-linux"
236	helenos_target = "amd64-helenos"
237
238	if (config['PLATFORM'] == "arm32"):
239	target = config['PLATFORM']
240	gnu_target = "arm-linux-gnueabi"
241	clang_target = "arm-unknown-linux"
242	helenos_target = "arm-helenos-gnueabi"
243
244	if (config['PLATFORM'] == "ia32"):
245	target = config['PLATFORM']
246	gnu_target = "i686-pc-linux-gnu"
247	clang_target = "i386-unknown-linux"
248	helenos_target = "i686-pc-helenos"
249
250	if (config['PLATFORM'] == "ia64"):
251	target = config['PLATFORM']
252	gnu_target = "ia64-pc-linux-gnu"
253	helenos_target = "ia64-pc-helenos"
254
255	if (config['PLATFORM'] == "mips32"):
256	check_config(config, "MACHINE")
257	cc_args.append("-mabi=32")
258
259	if ((config['MACHINE'] == "msim") or (config['MACHINE'] == "lmalta")):
260	target = config['PLATFORM']
261	gnu_target = "mipsel-linux-gnu"
262	clang_target = "mipsel-unknown-linux"
263	helenos_target = "mipsel-helenos"
264
265	if ((config['MACHINE'] == "bmalta")):
266	target = "mips32eb"
267	gnu_target = "mips-linux-gnu"
268	clang_target = "mips-unknown-linux"
269	helenos_target = "mips-helenos"
270
271	if (config['PLATFORM'] == "mips64"):
272	check_config(config, "MACHINE")
273	cc_args.append("-mabi=64")
274
275	if (config['MACHINE'] == "msim"):
276	target = config['PLATFORM']
277	gnu_target = "mips64el-linux-gnu"
278	clang_target = "mips64el-unknown-linux"
279	helenos_target = "mips64el-helenos"
280
281	if (config['PLATFORM'] == "ppc32"):
282	target = config['PLATFORM']
283	gnu_target = "ppc-linux-gnu"
284	clang_target = "powerpc-unknown-linux"
285	helenos_target = "ppc-helenos"
286
287	if (config['PLATFORM'] == "sparc32"):
288	target = config['PLATFORM'];
289	gnu_target = "sparc-leon3-linux-gnu"
290	helenos_target = "sparc-leon3-helenos"
291
292	if (config['PLATFORM'] == "sparc64"):
293	target = config['PLATFORM']
294	gnu_target = "sparc64-linux-gnu"
295	clang_target = "sparc-unknown-linux"
296	helenos_target = "sparc64-helenos"
297
298	return (target, cc_args, gnu_target, clang_target, helenos_target)
299
300	def check_app(args, name, details):
301	"Check whether an application can be executed"
302
303	try:
304	sys.stderr.write("Checking for %s ... " % args[0])
305	subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE).wait()
306	except:
307	sys.stderr.write("failed\n")
308	print_error(["%s is missing." % name,
309	"",
310	"Execution of \"%s\" has failed. Please make sure that it" % " ".join(args),
311	"is installed in your system (%s)." % details])
312
313	sys.stderr.write("ok\n")
314
315	def check_app_alternatives(alts, args, name, details):
316	"Check whether an application can be executed (use several alternatives)"
317
318	tried = []
319	found = None
320
321	for alt in alts:
322	working = True
323	cmdline = [alt] + args
324	tried.append(" ".join(cmdline))
325
326	try:
327	sys.stderr.write("Checking for %s ... " % alt)
328	subprocess.Popen(cmdline, stdout = subprocess.PIPE, stderr = subprocess.PIPE).wait()
329	except:
330	sys.stderr.write("failed\n")
331	working = False
332
333	if (working):
334	sys.stderr.write("ok\n")
335	found = alt
336	break
337
338	if (found is None):
339	print_error(["%s is missing." % name,
340	"",
341	"Please make sure that it is installed in your",
342	"system (%s)." % details,
343	"",
344	"The following alternatives were tried:"] + tried)
345
346	return found
347
348	def check_gcc(path, prefix, common, details):
349	"Check for GCC"
350
351	common['GCC'] = "%sgcc" % prefix
352
353	if (not path is None):
354	common['GCC'] = "%s/%s" % (path, common['GCC'])
355
356	check_app([common['GCC'], "--version"], "GNU GCC", details)
357
358	def check_binutils(path, prefix, common, details):
359	"Check for binutils toolchain"
360
361	common['AS'] = "%sas" % prefix
362	common['LD'] = "%sld" % prefix
363	common['AR'] = "%sar" % prefix
364	common['OBJCOPY'] = "%sobjcopy" % prefix
365	common['OBJDUMP'] = "%sobjdump" % prefix
366	common['STRIP'] = "%sstrip" % prefix
367
368	if (not path is None):
369	for key in ["AS", "LD", "AR", "OBJCOPY", "OBJDUMP", "STRIP"]:
370	common[key] = "%s/%s" % (path, common[key])
371
372	check_app([common['AS'], "--version"], "GNU Assembler", details)
373	check_app([common['LD'], "--version"], "GNU Linker", details)
374	check_app([common['AR'], "--version"], "GNU Archiver", details)
375	check_app([common['OBJCOPY'], "--version"], "GNU Objcopy utility", details)
376	check_app([common['OBJDUMP'], "--version"], "GNU Objdump utility", details)
377	check_app([common['STRIP'], "--version"], "GNU strip", details)
378
379	def check_python():
380	"Check for Python dependencies"
381
382	try:
383	sys.stderr.write("Checking for PyYAML ... ")
384	import yaml
385	except ImportError:
386	print_error(["PyYAML is missing.",
387	"",
388	"Please make sure that it is installed in your",
389	"system (usually part of PyYAML package)."])
390
391	sys.stderr.write("ok\n")
392
393	def decode_value(value):
394	"Decode integer value"
395
396	base = 10
397
398	if ((value.startswith('$')) or (value.startswith('#'))):
399	value = value[1:]
400
401	if (value.startswith('0x')):
402	value = value[2:]
403	base = 16
404
405	return int(value, base)
406
407	def probe_compiler(common, intsizes, floatsizes):
408	"Generate, compile and parse probing source"
409
410	check_common(common, "CC")
411
412	outf = open(PROBE_SOURCE, 'w')
413	outf.write(PROBE_HEAD)
414
415	for typedef in intsizes:
416	outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
417
418	for typedef in floatsizes:
419	outf.write("\nDECLARE_FLOATSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
420
421	outf.write(PROBE_TAIL)
422	outf.close()
423
424	args = [common['CC']]
425	args.extend(common['CC_ARGS'])
426	args.extend(["-S", "-o", PROBE_OUTPUT, PROBE_SOURCE])
427
428	try:
429	sys.stderr.write("Checking compiler properties ... ")
430	output = subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE).communicate()
431	except:
432	sys.stderr.write("failed\n")
433	print_error(["Error executing \"%s\"." % " ".join(args),
434	"Make sure that the compiler works properly."])
435
436	if (not os.path.isfile(PROBE_OUTPUT)):
437	sys.stderr.write("failed\n")
438	print(output[1])
439	print_error(["Error executing \"%s\"." % " ".join(args),
440	"The compiler did not produce the output file \"%s\"." % PROBE_OUTPUT,
441	"",
442	output[0],
443	output[1]])
444
445	sys.stderr.write("ok\n")
446
447	inf = open(PROBE_OUTPUT, 'r')
448	lines = inf.readlines()
449	inf.close()
450
451	unsigned_sizes = {}
452	signed_sizes = {}
453
454	unsigned_tags = {}
455	signed_tags = {}
456
457	unsigned_strcs = {}
458	signed_strcs = {}
459
460	unsigned_concs = {}
461	signed_concs = {}
462
463	float_tags = {}
464
465	builtin_sizes = {}
466	builtin_signs = {}
467
468	for j in range(len(lines)):
469	tokens = lines[j].strip().split("\t")
470
471	if (len(tokens) > 0):
472	if (tokens[0] == "AUTOTOOL_DECLARE"):
473	if (len(tokens) < 7):
474	print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
475
476	category = tokens[1]
477	subcategory = tokens[2]
478	tag = tokens[3]
479	name = tokens[4]
480	strc = tokens[5]
481	conc = tokens[6]
482	value = tokens[7]
483
484	if (category == "intsize"):
485	try:
486	value_int = decode_value(value)
487	except:
488	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
489
490	if (subcategory == "unsigned"):
491	unsigned_sizes[value_int] = name
492	unsigned_tags[tag] = value_int
493	unsigned_strcs[value_int] = strc
494	unsigned_concs[value_int] = conc
495	elif (subcategory == "signed"):
496	signed_sizes[value_int] = name
497	signed_tags[tag] = value_int
498	signed_strcs[value_int] = strc
499	signed_concs[value_int] = conc
500	else:
501	print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
502
503	if (category == "floatsize"):
504	try:
505	value_int = decode_value(value)
506	except:
507	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
508
509	float_tags[tag] = value_int
510
511	if (category == "builtin_size"):
512	try:
513	value_int = decode_value(value)
514	except:
515	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
516
517	builtin_sizes[tag] = {'name': name, 'value': value_int}
518
519	if (category == "builtin_sign"):
520	try:
521	value_int = decode_value(value)
522	except:
523	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
524
525	if (value_int == 1):
526	if (not tag in builtin_signs):
527	builtin_signs[tag] = strc;
528	elif (builtin_signs[tag] != strc):
529	print_error(["Inconsistent builtin type detection in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
530
531	return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'float_tags': float_tags, 'builtin_sizes': builtin_sizes, 'builtin_signs': builtin_signs}
532
533	def probe_int128(common):
534	"Generate, compile and parse probing source for 128-bit integers"
535
536	check_common(common, "CC")
537
538	outf = open(PROBE_INT128_SOURCE, 'w')
539	outf.write(PROBE_INT128_HEAD)
540	outf.write("\tDECLARE_INTSIZE(\"INT128\", int __attribute((mode(TI))));\n")
541	outf.write(PROBE_INT128_TAIL)
542	outf.close()
543
544	args = [common['CC']]
545	args.extend(common['CC_ARGS'])
546	args.extend(["-S", "-o", PROBE_INT128_OUTPUT, PROBE_INT128_SOURCE])
547
548	try:
549	sys.stderr.write("Checking whether the compiler has intrinsic support for 128-bit integers ... ")
550	output = subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE).communicate()
551	except:
552	sys.stderr.write("no\n")
553	return False
554
555	if (not os.path.isfile(PROBE_INT128_OUTPUT)):
556	sys.stderr.write("no\n")
557	return False
558
559	inf = open(PROBE_INT128_OUTPUT, 'r')
560	lines = inf.readlines()
561	inf.close()
562
563	for j in range(len(lines)):
564	tokens = lines[j].strip().split("\t")
565
566	if (len(tokens) > 0):
567	if (tokens[0] == "AUTOTOOL_DECLARE"):
568	if (len(tokens) < 7):
569	print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
570
571	category = tokens[1]
572	subcategory = tokens[2]
573	tag = tokens[3]
574	name = tokens[4]
575	strc = tokens[5]
576	conc = tokens[6]
577	value = tokens[7]
578
579	if (category == "intsize"):
580	try:
581	value_int = decode_value(value)
582	except:
583	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
584
585	if (subcategory == "unsigned"):
586	if (value_int != 16):
587	sys.stderr.write("no\n")
588	return False
589	elif (subcategory == "signed"):
590	if (value_int != 16):
591	sys.stderr.write("no\n")
592	return False
593	else:
594	print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
595
596	sys.stderr.write("yes\n")
597	return True
598
599	def detect_sizes(probe, bytes, inttags, floattags):
600	"Detect correct types for fixed-size types"
601
602	macros = []
603	typedefs = []
604
605	for b in bytes:
606	if (not b in probe['unsigned_sizes']):
607	print_error(['Unable to find appropriate unsigned integer type for %u bytes.' % b,
608	COMPILER_FAIL])
609
610	if (not b in probe['signed_sizes']):
611	print_error(['Unable to find appropriate signed integer type for %u bytes.' % b,
612	COMPILER_FAIL])
613
614	if (not b in probe['unsigned_strcs']):
615	print_error(['Unable to find appropriate unsigned printf formatter for %u bytes.' % b,
616	COMPILER_FAIL])
617
618	if (not b in probe['signed_strcs']):
619	print_error(['Unable to find appropriate signed printf formatter for %u bytes.' % b,
620	COMPILER_FAIL])
621
622	if (not b in probe['unsigned_concs']):
623	print_error(['Unable to find appropriate unsigned literal macro for %u bytes.' % b,
624	COMPILER_FAIL])
625
626	if (not b in probe['signed_concs']):
627	print_error(['Unable to find appropriate signed literal macro for %u bytes.' % b,
628	COMPILER_FAIL])
629
630	typedefs.append({'oldtype': "unsigned %s" % probe['unsigned_sizes'][b], 'newtype': "uint%u_t" % (b * 8)})
631	typedefs.append({'oldtype': "signed %s" % probe['signed_sizes'][b], 'newtype': "int%u_t" % (b * 8)})
632
633	macros.append({'oldmacro': "unsigned %s" % probe['unsigned_sizes'][b], 'newmacro': "UINT%u_T" % (b * 8)})
634	macros.append({'oldmacro': "signed %s" % probe['signed_sizes'][b], 'newmacro': "INT%u_T" % (b * 8)})
635
636	macros.append({'oldmacro': "\"%so\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIo%u" % (b * 8)})
637	macros.append({'oldmacro': "\"%su\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIu%u" % (b * 8)})
638	macros.append({'oldmacro': "\"%sx\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIx%u" % (b * 8)})
639	macros.append({'oldmacro': "\"%sX\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIX%u" % (b * 8)})
640	macros.append({'oldmacro': "\"%sd\"" % probe['signed_strcs'][b], 'newmacro': "PRId%u" % (b * 8)})
641
642	name = probe['unsigned_concs'][b]
643	if ((name.startswith('@')) or (name == "")):
644	macros.append({'oldmacro': "c ## U", 'newmacro': "UINT%u_C(c)" % (b * 8)})
645	else:
646	macros.append({'oldmacro': "c ## U%s" % name, 'newmacro': "UINT%u_C(c)" % (b * 8)})
647
648	name = probe['unsigned_concs'][b]
649	if ((name.startswith('@')) or (name == "")):
650	macros.append({'oldmacro': "c", 'newmacro': "INT%u_C(c)" % (b * 8)})
651	else:
652	macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
653
654	for tag in inttags:
655	newmacro = "U%s" % tag
656	if (not tag in probe['unsigned_tags']):
657	print_error(['Unable to find appropriate size macro for %s.' % newmacro,
658	COMPILER_FAIL])
659
660	oldmacro = "UINT%s" % (probe['unsigned_tags'][tag] * 8)
661	macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
662	macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
663	macros.append({'oldmacro': "1", 'newmacro': 'U%s_SIZE_%s' % (tag, probe['unsigned_tags'][tag] * 8)})
664
665	newmacro = tag
666	if (not tag in probe['signed_tags']):
667	print_error(['Unable to find appropriate size macro for %s' % newmacro,
668	COMPILER_FAIL])
669
670	oldmacro = "INT%s" % (probe['signed_tags'][tag] * 8)
671	macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
672	macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
673	macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['signed_tags'][tag] * 8)})
674
675	for tag in floattags:
676	if (not tag in probe['float_tags']):
677	print_error(['Unable to find appropriate size macro for %s' % tag,
678	COMPILER_FAIL])
679
680	macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['float_tags'][tag] * 8)})
681
682	if (not 'size' in probe['builtin_signs']):
683	print_error(['Unable to determine whether size_t is signed or unsigned.',
684	COMPILER_FAIL])
685
686	if (probe['builtin_signs']['size'] != 'unsigned'):
687	print_error(['The type size_t is not unsigned.',
688	COMPILER_FAIL])
689
690	fnd = True
691
692	if (not 'wchar' in probe['builtin_sizes']):
693	print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
694	'for defining the compiler-native type wchar_t. We are',
695	'forced to define wchar_t as a hardwired type int32_t.',
696	COMPILER_WARNING])
697	fnd = False
698
699	if (probe['builtin_sizes']['wchar']['value'] != 4):
700	print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
701	'the compiler-native type wchar_t is not compliant with',
702	'HelenOS. We are forced to define wchar_t as a hardwired',
703	'type int32_t.',
704	COMPILER_WARNING])
705	fnd = False
706
707	if (not fnd):
708	macros.append({'oldmacro': "int32_t", 'newmacro': "wchar_t"})
709	else:
710	macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
711
712	if (not 'wchar' in probe['builtin_signs']):
713	print_error(['Unable to determine whether wchar_t is signed or unsigned.',
714	COMPILER_FAIL])
715
716	if (probe['builtin_signs']['wchar'] == 'unsigned'):
717	macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_UNSIGNED'})
718	if (probe['builtin_signs']['wchar'] == 'signed'):
719	macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_SIGNED'})
720
721	fnd = True
722
723	if (not 'wint' in probe['builtin_sizes']):
724	print_warning(['The compiler does not provide the macro __WINT_TYPE__',
725	'for defining the compiler-native type wint_t. We are',
726	'forced to define wint_t as a hardwired type int32_t.',
727	COMPILER_WARNING])
728	fnd = False
729
730	if (probe['builtin_sizes']['wint']['value'] != 4):
731	print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
732	'the compiler-native type wint_t is not compliant with',
733	'HelenOS. We are forced to define wint_t as a hardwired',
734	'type int32_t.',
735	COMPILER_WARNING])
736	fnd = False
737
738	if (not fnd):
739	macros.append({'oldmacro': "int32_t", 'newmacro': "wint_t"})
740	else:
741	macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
742
743	if (not 'wint' in probe['builtin_signs']):
744	print_error(['Unable to determine whether wint_t is signed or unsigned.',
745	COMPILER_FAIL])
746
747	if (probe['builtin_signs']['wint'] == 'unsigned'):
748	macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_UNSIGNED'})
749	if (probe['builtin_signs']['wint'] == 'signed'):
750	macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_SIGNED'})
751
752	return {'macros': macros, 'typedefs': typedefs}
753
754	def create_makefile(mkname, common):
755	"Create makefile output"
756
757	outmk = open(mkname, 'w')
758
759	outmk.write('#########################################\n')
760	outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
761	outmk.write('## Generated by: tools/autotool.py ##\n')
762	outmk.write('#########################################\n\n')
763
764	for key, value in common.items():
765	if (type(value) is list):
766	outmk.write('%s = %s\n' % (key, " ".join(value)))
767	else:
768	outmk.write('%s = %s\n' % (key, value))
769
770	outmk.close()
771
772	def create_header(hdname, maps, int128):
773	"Create header output"
774
775	outhd = open(hdname, 'w')
776
777	outhd.write('/***************************************\n')
778	outhd.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')
779	outhd.write(' * Generated by: tools/autotool.py *\n')
780	outhd.write(' ***************************************/\n\n')
781
782	outhd.write('#ifndef %s\n' % GUARD)
783	outhd.write('#define %s\n\n' % GUARD)
784
785	for macro in maps['macros']:
786	outhd.write('#define %s %s\n' % (macro['newmacro'], macro['oldmacro']))
787
788	outhd.write('\n')
789
790	for typedef in maps['typedefs']:
791	outhd.write('typedef %s %s;\n' % (typedef['oldtype'], typedef['newtype']))
792
793	if (int128):
794	outhd.write('typedef unsigned int __attribute((mode(TI))) uint128_t;\n')
795	outhd.write('typedef signed int __attribute((mode(TI))) int128_t;\n')
796
797	outhd.write('\n#endif\n')
798	outhd.close()
799
800	def main():
801	config = {}
802	common = {}
803
804	# Read and check configuration
805	if os.path.exists(CONFIG):
806	read_config(CONFIG, config)
807	else:
808	print_error(["Configuration file %s not found! Make sure that the" % CONFIG,
809	"configuration phase of HelenOS build went OK. Try running",
810	"\"make config\" again."])
811
812	check_config(config, "PLATFORM")
813	check_config(config, "COMPILER")
814	check_config(config, "BARCH")
815
816	# Cross-compiler prefix
817	if ('CROSS_PREFIX' in os.environ):
818	cross_prefix = os.environ['CROSS_PREFIX']
819	else:
820	cross_prefix = "/usr/local/cross"
821
822	# HelenOS cross-compiler prefix
823	if ('CROSS_HELENOS_PREFIX' in os.environ):
824	cross_helenos_prefix = os.environ['CROSS_HELENOS_PREFIX']
825	else:
826	cross_helenos_prefix = "/usr/local/cross-helenos"
827
828	# Prefix binutils tools on Solaris
829	if (os.uname()[0] == "SunOS"):
830	binutils_prefix = "g"
831	else:
832	binutils_prefix = ""
833
834	owd = sandbox_enter()
835
836	try:
837	# Common utilities
838	check_app(["ln", "--version"], "Symlink utility", "usually part of coreutils")
839	check_app(["rm", "--version"], "File remove utility", "usually part of coreutils")
840	check_app(["mkdir", "--version"], "Directory creation utility", "usually part of coreutils")
841	check_app(["cp", "--version"], "Copy utility", "usually part of coreutils")
842	check_app(["find", "--version"], "Find utility", "usually part of findutils")
843	check_app(["diff", "--version"], "Diff utility", "usually part of diffutils")
844	check_app(["make", "--version"], "Make utility", "preferably GNU Make")
845	check_app(["makedepend", "-f", "-"], "Makedepend utility", "usually part of imake or xutils")
846
847	# Compiler
848	common['CC_ARGS'] = []
849	if (config['COMPILER'] == "gcc_cross"):
850	target, cc_args, gnu_target, clang_target, helenos_target = get_target(config)
851
852	if (target is None) or (gnu_target is None):
853	print_error(["Unsupported compiler target for GNU GCC.",
854	"Please contact the developers of HelenOS."])
855
856	path = "%s/%s/bin" % (cross_prefix, target)
857	prefix = "%s-" % gnu_target
858
859	check_gcc(path, prefix, common, PACKAGE_CROSS)
860	check_binutils(path, prefix, common, PACKAGE_CROSS)
861
862	check_common(common, "GCC")
863	common['CC'] = common['GCC']
864	common['CC_ARGS'].extend(cc_args)
865
866	if (config['COMPILER'] == "gcc_helenos"):
867	target, cc_args, gnu_target, clang_target, helenos_target = get_target(config)
868
869	if (target is None) or (helenos_target is None):
870	print_error(["Unsupported compiler target for GNU GCC.",
871	"Please contact the developers of HelenOS."])
872
873	path = "%s/%s/bin" % (cross_helenos_prefix, target)
874	prefix = "%s-" % helenos_target
875
876	check_gcc(path, prefix, common, PACKAGE_CROSS)
877	check_binutils(path, prefix, common, PACKAGE_CROSS)
878
879	check_common(common, "GCC")
880	common['CC'] = common['GCC']
881	common['CC_ARGS'].extend(cc_args)
882
883	if (config['COMPILER'] == "gcc_native"):
884	check_gcc(None, "", common, PACKAGE_GCC)
885	check_binutils(None, binutils_prefix, common, PACKAGE_BINUTILS)
886
887	check_common(common, "GCC")
888	common['CC'] = common['GCC']
889
890	if (config['COMPILER'] == "icc"):
891	common['CC'] = "icc"
892	check_app([common['CC'], "-V"], "Intel C++ Compiler", "support is experimental")
893	check_gcc(None, "", common, PACKAGE_GCC)
894	check_binutils(None, binutils_prefix, common, PACKAGE_BINUTILS)
895
896	if (config['COMPILER'] == "clang"):
897	target, cc_args, gnu_target, clang_target, helenos_target = get_target(config)
898
899	if (target is None) or (gnu_target is None) or (clang_target is None):
900	print_error(["Unsupported compiler target for clang.",
901	"Please contact the developers of HelenOS."])
902
903	path = "%s/%s/bin" % (cross_prefix, target)
904	prefix = "%s-" % gnu_target
905
906	check_app(["clang", "--version"], "clang compiler", "preferably version 1.0 or newer")
907	check_gcc(path, prefix, common, PACKAGE_GCC)
908	check_binutils(path, prefix, common, PACKAGE_BINUTILS)
909
910	check_common(common, "GCC")
911	common['CC'] = "clang"
912	common['CC_ARGS'].extend(cc_args)
913	common['CC_ARGS'].append("-target")
914	common['CC_ARGS'].append(clang_target)
915	common['CLANG_TARGET'] = clang_target
916
917	check_python()
918
919	# Platform-specific utilities
920	if ((config['BARCH'] == "amd64") or (config['BARCH'] == "ia32") or (config['BARCH'] == "ppc32") or (config['BARCH'] == "sparc64")):
921	common['GENISOIMAGE'] = check_app_alternatives(["mkisofs", "genisoimage"], ["--version"], "ISO 9660 creation utility", "usually part of genisoimage")
922
923	probe = probe_compiler(common,
924	[
925	{'type': 'long long int', 'tag': 'LLONG', 'strc': '"ll"', 'conc': '"LL"'},
926	{'type': 'long int', 'tag': 'LONG', 'strc': '"l"', 'conc': '"L"'},
927	{'type': 'int', 'tag': 'INT', 'strc': '""', 'conc': '""'},
928	{'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
929	{'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
930	],
931	[
932	{'type': 'long double', 'tag': 'LONG_DOUBLE'},
933	{'type': 'double', 'tag': 'DOUBLE'},
934	{'type': 'float', 'tag': 'FLOAT'}
935	]
936	)
937
938	int128 = probe_int128(common)
939
940	maps = detect_sizes(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'], ['LONG_DOUBLE', 'DOUBLE', 'FLOAT'])
941
942	finally:
943	sandbox_leave(owd)
944
945	common['AUTOGEN'] = "%s/autogen.py" % os.path.dirname(os.path.abspath(sys.argv[0]))
946
947	create_makefile(MAKEFILE, common)
948	create_header(HEADER, maps, int128)
949
950	return 0
951
952	if __name__ == '__main__':
953	sys.exit(main())

Note: See TracBrowser for help on using the repository browser.

Download in other formats: