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

Rev	Line
[177e4ea]	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	#
[3c80f2b]	29
[177e4ea]	30	"""
	31	Detect important prerequisites and parameters for building HelenOS
	32	"""
	33
	34	import sys
	35	import os
[4e9aaf5]	36	import shutil
[177e4ea]	37	import re
	38	import time
	39	import subprocess
	40
[4e9aaf5]	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'
[177e4ea]	49
[a420203]	50	PROBE_INT128_SOURCE = 'probe_int128.c'
	51	PROBE_INT128_OUTPUT = 'probe_int128.s'
	52
[177e4ea]	53	PACKAGE_BINUTILS = "usually part of binutils"
[a4a0f1d]	54	PACKAGE_GCC = "preferably version 4.7.0 or newer"
[177e4ea]	55	PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
	56
[4e9aaf5]	57	COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
[96b89acb]	58	COMPILER_WARNING = "The compilation of HelenOS might fail."
[4e9aaf5]	59
[dc0b964]	60	PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, strc, conc, value) \\
[4e9aaf5]	61	asm volatile ( \\
[dc0b964]	62	"AUTOTOOL_DECLARE\\t" category "\\t" subcategory "\\t" tag "\\t" name "\\t" strc "\\t" conc "\\t%[val]\\n" \\
[4e9aaf5]	63	: \\
	64	: [val] "n" (value) \\
	65	)
	66
[96b89acb]	67	#define STRING(arg) STRING_ARG(arg)
	68	#define STRING_ARG(arg) #arg
	69
	70	#define DECLARE_BUILTIN_TYPE(tag, type) \\
[a4a0f1d]	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));
[96b89acb]	82
[dc0b964]	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));
[4e9aaf5]	86
[a4a0f1d]	87	#define DECLARE_FLOATSIZE(tag, type) \\
	88	AUTOTOOL_DECLARE("floatsize", "", tag, #type, "", "", sizeof(type));
	89
[4e9aaf5]	90	int main(int argc, char *argv[])
	91	{
[96b89acb]	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
[4e9aaf5]	101	"""
	102
	103	PROBE_TAIL = """}
	104	"""
	105
[270bf4f]	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
[177e4ea]	124	def read_config(fname, config):
	125	"Read HelenOS build configuration"
	126
[28f4adb]	127	inf = open(fname, 'r')
[177e4ea]	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
[96b89acb]	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
[4e9aaf5]	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
[177e4ea]	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
[4e9aaf5]	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
[95e370f8]	205	def get_target(config):
[39ba6d5]	206	target = None
	207	gnu_target = None
[26bcc658]	208	clang_target = None
[8f2eca0]	209	helenos_target = None
[7f25c4e]	210	cc_args = []
[39ba6d5]	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"
[6db5d4b]	218	clang_target = "arm-unknown-linux"
[8f2eca0]	219	helenos_target = "arm-helenos-gnueabi"
[39ba6d5]	220
	221	if (config['CROSS_TARGET'] == "ia32"):
	222	gnu_target = "i686-pc-linux-gnu"
[6db5d4b]	223	clang_target = "i386-unknown-linux"
[8f2eca0]	224	helenos_target = "i686-pc-helenos"
[39ba6d5]	225
	226	if (config['CROSS_TARGET'] == "mips32"):
	227	gnu_target = "mipsel-linux-gnu"
[6db5d4b]	228	clang_target = "mipsel-unknown-linux"
[8f2eca0]	229	helenos_target = "mipsel-helenos"
[39ba6d5]	230	common['CC_ARGS'].append("-mabi=32")
	231
	232	if (config['PLATFORM'] == "amd64"):
	233	target = config['PLATFORM']
	234	gnu_target = "amd64-linux-gnu"
[95e370f8]	235	clang_target = "x86_64-unknown-linux"
[8f2eca0]	236	helenos_target = "amd64-helenos"
[39ba6d5]	237
	238	if (config['PLATFORM'] == "arm32"):
	239	target = config['PLATFORM']
	240	gnu_target = "arm-linux-gnueabi"
[6db5d4b]	241	clang_target = "arm-unknown-linux"
[8f2eca0]	242	helenos_target = "arm-helenos-gnueabi"
[39ba6d5]	243
	244	if (config['PLATFORM'] == "ia32"):
	245	target = config['PLATFORM']
	246	gnu_target = "i686-pc-linux-gnu"
[95e370f8]	247	clang_target = "i386-unknown-linux"
[8f2eca0]	248	helenos_target = "i686-pc-helenos"
[39ba6d5]	249
	250	if (config['PLATFORM'] == "ia64"):
	251	target = config['PLATFORM']
	252	gnu_target = "ia64-pc-linux-gnu"
[8f2eca0]	253	helenos_target = "ia64-pc-helenos"
[39ba6d5]	254
	255	if (config['PLATFORM'] == "mips32"):
	256	check_config(config, "MACHINE")
[7f25c4e]	257	cc_args.append("-mabi=32")
[39ba6d5]	258
[b183ce0a]	259	if ((config['MACHINE'] == "msim") or (config['MACHINE'] == "lmalta")):
[39ba6d5]	260	target = config['PLATFORM']
	261	gnu_target = "mipsel-linux-gnu"
[6db5d4b]	262	clang_target = "mipsel-unknown-linux"
[8f2eca0]	263	helenos_target = "mipsel-helenos"
[39ba6d5]	264
[b183ce0a]	265	if ((config['MACHINE'] == "bmalta")):
[39ba6d5]	266	target = "mips32eb"
	267	gnu_target = "mips-linux-gnu"
[6db5d4b]	268	clang_target = "mips-unknown-linux"
[8f2eca0]	269	helenos_target = "mips-helenos"
[39ba6d5]	270
	271	if (config['PLATFORM'] == "mips64"):
	272	check_config(config, "MACHINE")
[7f25c4e]	273	cc_args.append("-mabi=64")
[39ba6d5]	274
	275	if (config['MACHINE'] == "msim"):
	276	target = config['PLATFORM']
	277	gnu_target = "mips64el-linux-gnu"
[6db5d4b]	278	clang_target = "mips64el-unknown-linux"
[8f2eca0]	279	helenos_target = "mips64el-helenos"
[39ba6d5]	280
	281	if (config['PLATFORM'] == "ppc32"):
	282	target = config['PLATFORM']
	283	gnu_target = "ppc-linux-gnu"
[6db5d4b]	284	clang_target = "powerpc-unknown-linux"
[8f2eca0]	285	helenos_target = "ppc-helenos"
[39ba6d5]	286
[0c2d9bb]	287	if (config['PLATFORM'] == "sparc32"):
	288	target = config['PLATFORM'];
	289	gnu_target = "sparc-leon3-linux-gnu"
	290	helenos_target = "sparc-leon3-helenos"
[39ba6d5]	291
	292	if (config['PLATFORM'] == "sparc64"):
	293	target = config['PLATFORM']
	294	gnu_target = "sparc64-linux-gnu"
[6db5d4b]	295	clang_target = "sparc-unknown-linux"
[8f2eca0]	296	helenos_target = "sparc64-helenos"
[39ba6d5]	297
[8f2eca0]	298	return (target, cc_args, gnu_target, clang_target, helenos_target)
[39ba6d5]	299
[177e4ea]	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
[7174403]	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
[177e4ea]	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
[a4125fb1]	366	common['STRIP'] = "%sstrip" % prefix
[177e4ea]	367
	368	if (not path is None):
[a4125fb1]	369	for key in ["AS", "LD", "AR", "OBJCOPY", "OBJDUMP", "STRIP"]:
[177e4ea]	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)
[a4125fb1]	377	check_app([common['STRIP'], "--version"], "GNU strip", details)
[177e4ea]	378
[ec07933]	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
[96b89acb]	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
[a4a0f1d]	407	def probe_compiler(common, intsizes, floatsizes):
[4e9aaf5]	408	"Generate, compile and parse probing source"
	409
	410	check_common(common, "CC")
	411
[28f4adb]	412	outf = open(PROBE_SOURCE, 'w')
[4e9aaf5]	413	outf.write(PROBE_HEAD)
	414
[a4a0f1d]	415	for typedef in intsizes:
[dc0b964]	416	outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
[4e9aaf5]	417
[a4a0f1d]	418	for typedef in floatsizes:
	419	outf.write("\nDECLARE_FLOATSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
	420
[4e9aaf5]	421	outf.write(PROBE_TAIL)
	422	outf.close()
	423
[2429e4a]	424	args = [common['CC']]
	425	args.extend(common['CC_ARGS'])
	426	args.extend(["-S", "-o", PROBE_OUTPUT, PROBE_SOURCE])
[4e9aaf5]	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")
[28f4adb]	438	print(output[1])
[4e9aaf5]	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
[28f4adb]	447	inf = open(PROBE_OUTPUT, 'r')
[4e9aaf5]	448	lines = inf.readlines()
	449	inf.close()
	450
	451	unsigned_sizes = {}
	452	signed_sizes = {}
	453
[9539be6]	454	unsigned_tags = {}
	455	signed_tags = {}
	456
[dc0b964]	457	unsigned_strcs = {}
	458	signed_strcs = {}
	459
	460	unsigned_concs = {}
	461	signed_concs = {}
	462
[a4a0f1d]	463	float_tags = {}
	464
	465	builtin_sizes = {}
	466	builtin_signs = {}
[96b89acb]	467
[4e9aaf5]	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"):
[dc0b964]	473	if (len(tokens) < 7):
[4e9aaf5]	474	print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
	475
	476	category = tokens[1]
	477	subcategory = tokens[2]
[9539be6]	478	tag = tokens[3]
	479	name = tokens[4]
[dc0b964]	480	strc = tokens[5]
	481	conc = tokens[6]
	482	value = tokens[7]
[4e9aaf5]	483
	484	if (category == "intsize"):
	485	try:
[96b89acb]	486	value_int = decode_value(value)
[4e9aaf5]	487	except:
	488	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
	489
	490	if (subcategory == "unsigned"):
[96b89acb]	491	unsigned_sizes[value_int] = name
[9539be6]	492	unsigned_tags[tag] = value_int
[96b89acb]	493	unsigned_strcs[value_int] = strc
	494	unsigned_concs[value_int] = conc
[4e9aaf5]	495	elif (subcategory == "signed"):
[96b89acb]	496	signed_sizes[value_int] = name
[9539be6]	497	signed_tags[tag] = value_int
[96b89acb]	498	signed_strcs[value_int] = strc
	499	signed_concs[value_int] = conc
[4e9aaf5]	500	else:
	501	print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
[96b89acb]	502
[a4a0f1d]	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"):
[96b89acb]	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
[a4a0f1d]	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])
[4e9aaf5]	530
[a4a0f1d]	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}
[4e9aaf5]	532
[270bf4f]	533	def probe_int128(common):
	534	"Generate, compile and parse probing source for 128-bit integers"
	535
	536	check_common(common, "CC")
	537
[a420203]	538	outf = open(PROBE_INT128_SOURCE, 'w')
[270bf4f]	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'])
[a420203]	546	args.extend(["-S", "-o", PROBE_INT128_OUTPUT, PROBE_INT128_SOURCE])
[270bf4f]	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
[a420203]	555	if (not os.path.isfile(PROBE_INT128_OUTPUT)):
[270bf4f]	556	sys.stderr.write("no\n")
	557	return False
	558
[a420203]	559	inf = open(PROBE_INT128_OUTPUT, 'r')
[270bf4f]	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):
[a420203]	569	print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
[270bf4f]	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:
[a420203]	583	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
[270bf4f]	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:
[a420203]	594	print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_INT128_OUTPUT, j), COMPILER_FAIL])
[270bf4f]	595
	596	sys.stderr.write("yes\n")
	597	return True
	598
[a4a0f1d]	599	def detect_sizes(probe, bytes, inttags, floattags):
	600	"Detect correct types for fixed-size types"
[4e9aaf5]	601
[9539be6]	602	macros = []
[4e9aaf5]	603	typedefs = []
	604
	605	for b in bytes:
[96b89acb]	606	if (not b in probe['unsigned_sizes']):
[a4a0f1d]	607	print_error(['Unable to find appropriate unsigned integer type for %u bytes.' % b,
[4e9aaf5]	608	COMPILER_FAIL])
	609
[96b89acb]	610	if (not b in probe['signed_sizes']):
[a4a0f1d]	611	print_error(['Unable to find appropriate signed integer type for %u bytes.' % b,
[4e9aaf5]	612	COMPILER_FAIL])
[dc0b964]	613
[96b89acb]	614	if (not b in probe['unsigned_strcs']):
[a4a0f1d]	615	print_error(['Unable to find appropriate unsigned printf formatter for %u bytes.' % b,
[85369b1]	616	COMPILER_FAIL])
[dc0b964]	617
[96b89acb]	618	if (not b in probe['signed_strcs']):
[a4a0f1d]	619	print_error(['Unable to find appropriate signed printf formatter for %u bytes.' % b,
[85369b1]	620	COMPILER_FAIL])
[dc0b964]	621
[96b89acb]	622	if (not b in probe['unsigned_concs']):
[a4a0f1d]	623	print_error(['Unable to find appropriate unsigned literal macro for %u bytes.' % b,
[85369b1]	624	COMPILER_FAIL])
[dc0b964]	625
[96b89acb]	626	if (not b in probe['signed_concs']):
[a4a0f1d]	627	print_error(['Unable to find appropriate signed literal macro for %u bytes.' % b,
[96b89acb]	628	COMPILER_FAIL])
[dc0b964]	629
[96b89acb]	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)})
[dc0b964]	632
[d408ea0]	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
[96b89acb]	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)})
[9539be6]	641
[96b89acb]	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)})
[9539be6]	647
[96b89acb]	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
[a4a0f1d]	654	for tag in inttags:
[96b89acb]	655	newmacro = "U%s" % tag
	656	if (not tag in probe['unsigned_tags']):
[a4a0f1d]	657	print_error(['Unable to find appropriate size macro for %s.' % newmacro,
[9539be6]	658	COMPILER_FAIL])
	659
[96b89acb]	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})
[a4a0f1d]	663	macros.append({'oldmacro': "1", 'newmacro': 'U%s_SIZE_%s' % (tag, probe['unsigned_tags'][tag] * 8)})
[9539be6]	664
[96b89acb]	665	newmacro = tag
[a4a0f1d]	666	if (not tag in probe['signed_tags']):
[9539be6]	667	print_error(['Unable to find appropriate size macro for %s' % newmacro,
	668	COMPILER_FAIL])
[96b89acb]	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})
[a4a0f1d]	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])
[96b89acb]	689
	690	fnd = True
	691
[a4a0f1d]	692	if (not 'wchar' in probe['builtin_sizes']):
[96b89acb]	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
[a4a0f1d]	699	if (probe['builtin_sizes']['wchar']['value'] != 4):
[96b89acb]	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
[a4a0f1d]	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
[96b89acb]	721	fnd = True
	722
[a4a0f1d]	723	if (not 'wint' in probe['builtin_sizes']):
[96b89acb]	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
[a4a0f1d]	730	if (probe['builtin_sizes']['wint']['value'] != 4):
[96b89acb]	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"})
[9539be6]	742
[a4a0f1d]	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
[9539be6]	752	return {'macros': macros, 'typedefs': typedefs}
[4e9aaf5]	753
	754	def create_makefile(mkname, common):
	755	"Create makefile output"
[177e4ea]	756
[28f4adb]	757	outmk = open(mkname, 'w')
[177e4ea]	758
[4e9aaf5]	759	outmk.write('#########################################\n')
	760	outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
[571239a]	761	outmk.write('## Generated by: tools/autotool.py ##\n')
[4e9aaf5]	762	outmk.write('#########################################\n\n')
[177e4ea]	763
	764	for key, value in common.items():
[7174403]	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))
[4e9aaf5]	769
	770	outmk.close()
	771
[270bf4f]	772	def create_header(hdname, maps, int128):
[4e9aaf5]	773	"Create header output"
	774
[28f4adb]	775	outhd = open(hdname, 'w')
[4e9aaf5]	776
	777	outhd.write('/***************************************\n')
	778	outhd.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')
[571239a]	779	outhd.write(' * Generated by: tools/autotool.py *\n')
[4e9aaf5]	780	outhd.write(' ***************************************/\n\n')
[177e4ea]	781
[4e9aaf5]	782	outhd.write('#ifndef %s\n' % GUARD)
	783	outhd.write('#define %s\n\n' % GUARD)
	784
[9539be6]	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']:
[4e9aaf5]	791	outhd.write('typedef %s %s;\n' % (typedef['oldtype'], typedef['newtype']))
	792
[270bf4f]	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
[4e9aaf5]	797	outhd.write('\n#endif\n')
	798	outhd.close()
[177e4ea]	799
	800	def main():
	801	config = {}
	802	common = {}
	803
	804	# Read and check configuration
[4e9aaf5]	805	if os.path.exists(CONFIG):
	806	read_config(CONFIG, config)
[177e4ea]	807	else:
[4e9aaf5]	808	print_error(["Configuration file %s not found! Make sure that the" % CONFIG,
[177e4ea]	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:
[603c8740]	820	cross_prefix = "/usr/local/cross"
[177e4ea]	821
[8f2eca0]	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
[177e4ea]	828	# Prefix binutils tools on Solaris
	829	if (os.uname()[0] == "SunOS"):
	830	binutils_prefix = "g"
	831	else:
	832	binutils_prefix = ""
	833
[4e9aaf5]	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
[2429e4a]	848	common['CC_ARGS'] = []
[4e9aaf5]	849	if (config['COMPILER'] == "gcc_cross"):
[8f2eca0]	850	target, cc_args, gnu_target, clang_target, helenos_target = get_target(config)
[95e370f8]	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
[4e9aaf5]	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']
[7f25c4e]	864	common['CC_ARGS'].extend(cc_args)
[177e4ea]	865
[8f2eca0]	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
[4e9aaf5]	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']
[177e4ea]	889
[4e9aaf5]	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)
[177e4ea]	895
[4e9aaf5]	896	if (config['COMPILER'] == "clang"):
[0dd022ec]	897	target, cc_args, gnu_target, clang_target, helenos_target = get_target(config)
[95e370f8]	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
[39ba6d5]	903	path = "%s/%s/bin" % (cross_prefix, target)
	904	prefix = "%s-" % gnu_target
	905
[95e370f8]	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")
[4e9aaf5]	911	common['CC'] = "clang"
[7f25c4e]	912	common['CC_ARGS'].extend(cc_args)
[26bcc658]	913	common['CC_ARGS'].append("-target")
	914	common['CC_ARGS'].append(clang_target)
[95e370f8]	915	common['CLANG_TARGET'] = clang_target
[177e4ea]	916
[ec07933]	917	check_python()
	918
[4e9aaf5]	919	# Platform-specific utilities
	920	if ((config['BARCH'] == "amd64") or (config['BARCH'] == "ia32") or (config['BARCH'] == "ppc32") or (config['BARCH'] == "sparc64")):
[7174403]	921	common['GENISOIMAGE'] = check_app_alternatives(["mkisofs", "genisoimage"], ["--version"], "ISO 9660 creation utility", "usually part of genisoimage")
[177e4ea]	922
[4e9aaf5]	923	probe = probe_compiler(common,
	924	[
[96b89acb]	925	{'type': 'long long int', 'tag': 'LLONG', 'strc': '"ll"', 'conc': '"LL"'},
[dc0b964]	926	{'type': 'long int', 'tag': 'LONG', 'strc': '"l"', 'conc': '"L"'},
[96b89acb]	927	{'type': 'int', 'tag': 'INT', 'strc': '""', 'conc': '""'},
	928	{'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
	929	{'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
[a4a0f1d]	930	],
	931	[
	932	{'type': 'long double', 'tag': 'LONG_DOUBLE'},
	933	{'type': 'double', 'tag': 'DOUBLE'},
	934	{'type': 'float', 'tag': 'FLOAT'}
[4e9aaf5]	935	]
	936	)
[177e4ea]	937
[270bf4f]	938	int128 = probe_int128(common)
	939
[a4a0f1d]	940	maps = detect_sizes(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'], ['LONG_DOUBLE', 'DOUBLE', 'FLOAT'])
[177e4ea]	941
[4e9aaf5]	942	finally:
	943	sandbox_leave(owd)
	944
[57292d3]	945	common['AUTOGEN'] = "%s/autogen.py" % os.path.dirname(os.path.abspath(sys.argv[0]))
[270bf4f]	946
[4e9aaf5]	947	create_makefile(MAKEFILE, common)
[270bf4f]	948	create_header(HEADER, maps, int128)
[177e4ea]	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: