Context Navigation

source: mainline/tools/autotool.py@ bc7ec7c

Visit:

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

Last change on this file since bc7ec7c was 058c240, checked in by Dzejrou <dzejrou@…>, 7 years ago
cpp: added c++ to the build system, created libcpp, added and implemented the header file cstdio to libcpp
Property mode set to `100755`
File size: 21.7 KB

Rev	Line
[ce55b43]	1	#!/usr/bin/env python2
[177e4ea]	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'
[cc92076]	44	HEADER = 'common.h.new'
[ce55b43]	45	GUARD = '_AUTOTOOL_COMMON_H_'
[4e9aaf5]	46
	47	PROBE_SOURCE = 'probe.c'
	48	PROBE_OUTPUT = 'probe.s'
[177e4ea]	49
	50	PACKAGE_BINUTILS = "usually part of binutils"
[a4a0f1d]	51	PACKAGE_GCC = "preferably version 4.7.0 or newer"
[177e4ea]	52	PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
[84eb4edd]	53	PACKAGE_CLANG = "reasonably recent version of clang needs to be installed"
[177e4ea]	54
[4e9aaf5]	55	COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
[96b89acb]	56	COMPILER_WARNING = "The compilation of HelenOS might fail."
[4e9aaf5]	57
[ce55b43]	58	PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, tag, name, signedness, base, size, compatible) \\
[4e9aaf5]	59	asm volatile ( \\
[ce55b43]	60	"AUTOTOOL_DECLARE\\t" category "\\t" tag "\\t" name "\\t" signedness "\\t" base "\\t%[size_val]\\t%[cmp_val]\\n" \\
[4e9aaf5]	61	: \\
[ce55b43]	62	: [size_val] "n" (size), [cmp_val] "n" (compatible) \\
[4e9aaf5]	63	)
	64
[96b89acb]	65	#define STRING(arg) STRING_ARG(arg)
	66	#define STRING_ARG(arg) #arg
	67
	68	#define DECLARE_BUILTIN_TYPE(tag, type) \\
[ce55b43]	69	AUTOTOOL_DECLARE("unsigned long long int", tag, STRING(type), "unsigned", "long long", sizeof(type), __builtin_types_compatible_p(type, unsigned long long int)); \\
	70	AUTOTOOL_DECLARE("unsigned long int", tag, STRING(type), "unsigned", "long", sizeof(type), __builtin_types_compatible_p(type, unsigned long int)); \\
	71	AUTOTOOL_DECLARE("unsigned int", tag, STRING(type), "unsigned", "int", sizeof(type), __builtin_types_compatible_p(type, unsigned int)); \\
	72	AUTOTOOL_DECLARE("unsigned short int", tag, STRING(type), "unsigned", "short", sizeof(type), __builtin_types_compatible_p(type, unsigned short int)); \\
	73	AUTOTOOL_DECLARE("unsigned char", tag, STRING(type), "unsigned", "char", sizeof(type), __builtin_types_compatible_p(type, unsigned char)); \\
	74	AUTOTOOL_DECLARE("signed long long int", tag, STRING(type), "signed", "long long", sizeof(type), __builtin_types_compatible_p(type, signed long long int)); \\
	75	AUTOTOOL_DECLARE("signed long int", tag, STRING(type), "signed", "long", sizeof(type), __builtin_types_compatible_p(type, signed long int)); \\
	76	AUTOTOOL_DECLARE("signed int", tag, STRING(type), "signed", "int", sizeof(type), __builtin_types_compatible_p(type, signed int)); \\
	77	AUTOTOOL_DECLARE("signed short int", tag, STRING(type), "signed", "short", sizeof(type), __builtin_types_compatible_p(type, signed short int)); \\
	78	AUTOTOOL_DECLARE("signed char", tag, STRING(type), "signed", "char", sizeof(type), __builtin_types_compatible_p(type, signed char)); \\
	79	AUTOTOOL_DECLARE("pointer", tag, STRING(type), "N/A", "pointer", sizeof(type), __builtin_types_compatible_p(type, void*)); \\
	80	AUTOTOOL_DECLARE("long double", tag, STRING(type), "signed", "long double", sizeof(type), __builtin_types_compatible_p(type, long double)); \\
	81	AUTOTOOL_DECLARE("double", tag, STRING(type), "signed", "double", sizeof(type), __builtin_types_compatible_p(type, double)); \\
	82	AUTOTOOL_DECLARE("float", tag, STRING(type), "signed", "float", sizeof(type), __builtin_types_compatible_p(type, float));
[a4a0f1d]	83
[795e2bf]	84	extern int main(int, char *[]);
	85
[4e9aaf5]	86	int main(int argc, char *argv[])
	87	{
	88	"""
	89
	90	PROBE_TAIL = """}
	91	"""
	92
[177e4ea]	93	def read_config(fname, config):
	94	"Read HelenOS build configuration"
[a35b458]	95
[28f4adb]	96	inf = open(fname, 'r')
[a35b458]	97
[177e4ea]	98	for line in inf:
	99	res = re.match(r'^(?:#!# )?([^#]\w)\s=\s(.?)\s*$', line)
	100	if (res):
	101	config[res.group(1)] = res.group(2)
[a35b458]	102
[177e4ea]	103	inf.close()
	104
	105	def print_error(msg):
	106	"Print a bold error message"
[a35b458]	107
[177e4ea]	108	sys.stderr.write("\n")
	109	sys.stderr.write("######################################################################\n")
	110	sys.stderr.write("HelenOS build sanity check error:\n")
	111	sys.stderr.write("\n")
	112	sys.stderr.write("%s\n" % "\n".join(msg))
	113	sys.stderr.write("######################################################################\n")
	114	sys.stderr.write("\n")
[a35b458]	115
[177e4ea]	116	sys.exit(1)
	117
[96b89acb]	118	def print_warning(msg):
	119	"Print a bold error message"
[a35b458]	120
[96b89acb]	121	sys.stderr.write("\n")
	122	sys.stderr.write("######################################################################\n")
	123	sys.stderr.write("HelenOS build sanity check warning:\n")
	124	sys.stderr.write("\n")
	125	sys.stderr.write("%s\n" % "\n".join(msg))
	126	sys.stderr.write("######################################################################\n")
	127	sys.stderr.write("\n")
[a35b458]	128
[96b89acb]	129	time.sleep(5)
	130
[4e9aaf5]	131	def sandbox_enter():
	132	"Create a temporal sandbox directory for running tests"
[a35b458]	133
[4e9aaf5]	134	if (os.path.exists(SANDBOX)):
	135	if (os.path.isdir(SANDBOX)):
	136	try:
	137	shutil.rmtree(SANDBOX)
	138	except:
	139	print_error(["Unable to cleanup the directory \"%s\"." % SANDBOX])
	140	else:
	141	print_error(["Please inspect and remove unexpected directory,",
	142	"entry \"%s\"." % SANDBOX])
[a35b458]	143
[4e9aaf5]	144	try:
	145	os.mkdir(SANDBOX)
	146	except:
	147	print_error(["Unable to create sandbox directory \"%s\"." % SANDBOX])
[a35b458]	148
[4e9aaf5]	149	owd = os.getcwd()
	150	os.chdir(SANDBOX)
[a35b458]	151
[4e9aaf5]	152	return owd
	153
	154	def sandbox_leave(owd):
	155	"Leave the temporal sandbox directory"
[a35b458]	156
[4e9aaf5]	157	os.chdir(owd)
	158
[177e4ea]	159	def check_config(config, key):
	160	"Check whether the configuration key exists"
[a35b458]	161
[177e4ea]	162	if (not key in config):
	163	print_error(["Build configuration of HelenOS does not contain %s." % key,
	164	"Try running \"make config\" again.",
	165	"If the problem persists, please contact the developers of HelenOS."])
	166
[4e9aaf5]	167	def check_common(common, key):
	168	"Check whether the common key exists"
[a35b458]	169
[4e9aaf5]	170	if (not key in common):
	171	print_error(["Failed to determine the value %s." % key,
	172	"Please contact the developers of HelenOS."])
	173
[95e370f8]	174	def get_target(config):
[b08941d]	175	platform = None
[39ba6d5]	176	gnu_target = None
[8f2eca0]	177	helenos_target = None
[b08941d]	178	target = None
[7f25c4e]	179	cc_args = []
[a35b458]	180
[39ba6d5]	181	if (config['PLATFORM'] == "abs32le"):
	182	check_config(config, "CROSS_TARGET")
[b08941d]	183	platform = config['CROSS_TARGET']
[a35b458]	184
[39ba6d5]	185	if (config['CROSS_TARGET'] == "arm32"):
	186	gnu_target = "arm-linux-gnueabi"
[232ec3a1]	187	helenos_target = "arm-helenos"
[a35b458]	188
[39ba6d5]	189	if (config['CROSS_TARGET'] == "ia32"):
	190	gnu_target = "i686-pc-linux-gnu"
[232ec3a1]	191	helenos_target = "i686-helenos"
[a35b458]	192
[39ba6d5]	193	if (config['CROSS_TARGET'] == "mips32"):
[795e2bf]	194	cc_args.append("-mabi=32")
[39ba6d5]	195	gnu_target = "mipsel-linux-gnu"
[8f2eca0]	196	helenos_target = "mipsel-helenos"
[a35b458]	197
[39ba6d5]	198	if (config['PLATFORM'] == "amd64"):
[b08941d]	199	platform = config['PLATFORM']
[bfdb7c63]	200	gnu_target = "amd64-unknown-elf"
[8f2eca0]	201	helenos_target = "amd64-helenos"
[a35b458]	202
[39ba6d5]	203	if (config['PLATFORM'] == "arm32"):
[b08941d]	204	platform = config['PLATFORM']
[39ba6d5]	205	gnu_target = "arm-linux-gnueabi"
[232ec3a1]	206	helenos_target = "arm-helenos"
[a35b458]	207
[39ba6d5]	208	if (config['PLATFORM'] == "ia32"):
[b08941d]	209	platform = config['PLATFORM']
[39ba6d5]	210	gnu_target = "i686-pc-linux-gnu"
[232ec3a1]	211	helenos_target = "i686-helenos"
[a35b458]	212
[39ba6d5]	213	if (config['PLATFORM'] == "ia64"):
[b08941d]	214	platform = config['PLATFORM']
[39ba6d5]	215	gnu_target = "ia64-pc-linux-gnu"
[232ec3a1]	216	helenos_target = "ia64-helenos"
[a35b458]	217
[39ba6d5]	218	if (config['PLATFORM'] == "mips32"):
	219	check_config(config, "MACHINE")
[7f25c4e]	220	cc_args.append("-mabi=32")
[a35b458]	221
[b183ce0a]	222	if ((config['MACHINE'] == "msim") or (config['MACHINE'] == "lmalta")):
[b08941d]	223	platform = config['PLATFORM']
[39ba6d5]	224	gnu_target = "mipsel-linux-gnu"
[8f2eca0]	225	helenos_target = "mipsel-helenos"
[a35b458]	226
[b183ce0a]	227	if ((config['MACHINE'] == "bmalta")):
[b08941d]	228	platform = "mips32eb"
[39ba6d5]	229	gnu_target = "mips-linux-gnu"
[8f2eca0]	230	helenos_target = "mips-helenos"
[a35b458]	231
[39ba6d5]	232	if (config['PLATFORM'] == "mips64"):
	233	check_config(config, "MACHINE")
[7f25c4e]	234	cc_args.append("-mabi=64")
[a35b458]	235
[39ba6d5]	236	if (config['MACHINE'] == "msim"):
[b08941d]	237	platform = config['PLATFORM']
[39ba6d5]	238	gnu_target = "mips64el-linux-gnu"
[8f2eca0]	239	helenos_target = "mips64el-helenos"
[a35b458]	240
[39ba6d5]	241	if (config['PLATFORM'] == "ppc32"):
[b08941d]	242	platform = config['PLATFORM']
[39ba6d5]	243	gnu_target = "ppc-linux-gnu"
[8f2eca0]	244	helenos_target = "ppc-helenos"
[a35b458]	245
[114d098]	246	if (config['PLATFORM'] == "riscv64"):
[b08941d]	247	platform = config['PLATFORM']
[114d098]	248	gnu_target = "riscv64-unknown-linux-gnu"
	249	helenos_target = "riscv64-helenos"
[a35b458]	250
[39ba6d5]	251	if (config['PLATFORM'] == "sparc64"):
[b08941d]	252	platform = config['PLATFORM']
[39ba6d5]	253	gnu_target = "sparc64-linux-gnu"
[8f2eca0]	254	helenos_target = "sparc64-helenos"
[a35b458]	255
[b08941d]	256	if (config['COMPILER'] == "gcc_helenos"):
	257	target = helenos_target
	258	else:
	259	target = gnu_target
[a35b458]	260
[b08941d]	261	return (platform, cc_args, target)
[39ba6d5]	262
[177e4ea]	263	def check_app(args, name, details):
	264	"Check whether an application can be executed"
[a35b458]	265
[177e4ea]	266	try:
	267	sys.stderr.write("Checking for %s ... " % args[0])
	268	subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE).wait()
	269	except:
	270	sys.stderr.write("failed\n")
	271	print_error(["%s is missing." % name,
	272	"",
	273	"Execution of \"%s\" has failed. Please make sure that it" % " ".join(args),
	274	"is installed in your system (%s)." % details])
[a35b458]	275
[177e4ea]	276	sys.stderr.write("ok\n")
	277
[7174403]	278	def check_app_alternatives(alts, args, name, details):
	279	"Check whether an application can be executed (use several alternatives)"
[a35b458]	280
[7174403]	281	tried = []
	282	found = None
[a35b458]	283
[7174403]	284	for alt in alts:
	285	working = True
	286	cmdline = [alt] + args
	287	tried.append(" ".join(cmdline))
[a35b458]	288
[7174403]	289	try:
	290	sys.stderr.write("Checking for %s ... " % alt)
	291	subprocess.Popen(cmdline, stdout = subprocess.PIPE, stderr = subprocess.PIPE).wait()
	292	except:
	293	sys.stderr.write("failed\n")
	294	working = False
[a35b458]	295
[7174403]	296	if (working):
	297	sys.stderr.write("ok\n")
	298	found = alt
	299	break
[a35b458]	300
[7174403]	301	if (found is None):
	302	print_error(["%s is missing." % name,
	303	"",
	304	"Please make sure that it is installed in your",
	305	"system (%s)." % details,
	306	"",
	307	"The following alternatives were tried:"] + tried)
[a35b458]	308
[7174403]	309	return found
	310
[a0a273e]	311	def check_clang(path, prefix, common, details):
	312	"Check for clang"
[a35b458]	313
[a0a273e]	314	common['CLANG'] = "%sclang" % prefix
[a35b458]	315
[a0a273e]	316	if (not path is None):
	317	common['CLANG'] = "%s/%s" % (path, common['CLANG'])
[a35b458]	318
[a0a273e]	319	check_app([common['CLANG'], "--version"], "clang", details)
	320
[177e4ea]	321	def check_gcc(path, prefix, common, details):
	322	"Check for GCC"
[a35b458]	323
[177e4ea]	324	common['GCC'] = "%sgcc" % prefix
[058c240]	325	common['GPP'] = "%sg++" % prefix
[a35b458]	326
[177e4ea]	327	if (not path is None):
	328	common['GCC'] = "%s/%s" % (path, common['GCC'])
[058c240]	329	common['GPP'] = "%s/%s" % (path, common['GPP'])
[a35b458]	330
[177e4ea]	331	check_app([common['GCC'], "--version"], "GNU GCC", details)
	332
	333	def check_binutils(path, prefix, common, details):
	334	"Check for binutils toolchain"
[a35b458]	335
[177e4ea]	336	common['AS'] = "%sas" % prefix
	337	common['LD'] = "%sld" % prefix
	338	common['AR'] = "%sar" % prefix
	339	common['OBJCOPY'] = "%sobjcopy" % prefix
	340	common['OBJDUMP'] = "%sobjdump" % prefix
[a4125fb1]	341	common['STRIP'] = "%sstrip" % prefix
[a35b458]	342
[177e4ea]	343	if (not path is None):
[a4125fb1]	344	for key in ["AS", "LD", "AR", "OBJCOPY", "OBJDUMP", "STRIP"]:
[177e4ea]	345	common[key] = "%s/%s" % (path, common[key])
[a35b458]	346
[177e4ea]	347	check_app([common['AS'], "--version"], "GNU Assembler", details)
	348	check_app([common['LD'], "--version"], "GNU Linker", details)
	349	check_app([common['AR'], "--version"], "GNU Archiver", details)
	350	check_app([common['OBJCOPY'], "--version"], "GNU Objcopy utility", details)
	351	check_app([common['OBJDUMP'], "--version"], "GNU Objdump utility", details)
[a4125fb1]	352	check_app([common['STRIP'], "--version"], "GNU strip", details)
[177e4ea]	353
[96b89acb]	354	def decode_value(value):
	355	"Decode integer value"
[a35b458]	356
[96b89acb]	357	base = 10
[a35b458]	358
[96b89acb]	359	if ((value.startswith('$')) or (value.startswith('#'))):
	360	value = value[1:]
[a35b458]	361
[96b89acb]	362	if (value.startswith('0x')):
	363	value = value[2:]
	364	base = 16
[a35b458]	365
[96b89acb]	366	return int(value, base)
	367
[ce55b43]	368	def probe_compiler(common, typesizes):
[4e9aaf5]	369	"Generate, compile and parse probing source"
[a35b458]	370
[4e9aaf5]	371	check_common(common, "CC")
[a35b458]	372
[28f4adb]	373	outf = open(PROBE_SOURCE, 'w')
[4e9aaf5]	374	outf.write(PROBE_HEAD)
[a35b458]	375
[ce55b43]	376	for typedef in typesizes:
	377	if 'def' in typedef:
	378	outf.write("#ifdef %s\n" % typedef['def'])
	379	outf.write("\tDECLARE_BUILTIN_TYPE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
	380	if 'def' in typedef:
	381	outf.write("#endif\n")
[a35b458]	382
[4e9aaf5]	383	outf.write(PROBE_TAIL)
	384	outf.close()
[a35b458]	385
[a0a273e]	386	args = common['CC_AUTOGEN'].split(' ')
[2429e4a]	387	args.extend(["-S", "-o", PROBE_OUTPUT, PROBE_SOURCE])
[a35b458]	388
[4e9aaf5]	389	try:
	390	sys.stderr.write("Checking compiler properties ... ")
	391	output = subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE).communicate()
	392	except:
	393	sys.stderr.write("failed\n")
	394	print_error(["Error executing \"%s\"." % " ".join(args),
	395	"Make sure that the compiler works properly."])
[a35b458]	396
[4e9aaf5]	397	if (not os.path.isfile(PROBE_OUTPUT)):
	398	sys.stderr.write("failed\n")
[28f4adb]	399	print(output[1])
[4e9aaf5]	400	print_error(["Error executing \"%s\"." % " ".join(args),
	401	"The compiler did not produce the output file \"%s\"." % PROBE_OUTPUT,
	402	"",
	403	output[0],
	404	output[1]])
[a35b458]	405
[4e9aaf5]	406	sys.stderr.write("ok\n")
[a35b458]	407
[28f4adb]	408	inf = open(PROBE_OUTPUT, 'r')
[4e9aaf5]	409	lines = inf.readlines()
	410	inf.close()
[a35b458]	411
[ce55b43]	412	builtins = {}
[a35b458]	413
[4e9aaf5]	414	for j in range(len(lines)):
	415	tokens = lines[j].strip().split("\t")
[a35b458]	416
[4e9aaf5]	417	if (len(tokens) > 0):
	418	if (tokens[0] == "AUTOTOOL_DECLARE"):
[ce55b43]	419	if (len(tokens) < 8):
[4e9aaf5]	420	print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
[a35b458]	421
[4e9aaf5]	422	category = tokens[1]
[ce55b43]	423	tag = tokens[2]
	424	name = tokens[3]
	425	signedness = tokens[4]
	426	base = tokens[5]
	427	size = tokens[6]
	428	compatible = tokens[7]
[a35b458]	429
[ce55b43]	430	try:
	431	compatible_int = decode_value(compatible)
	432	size_int = decode_value(size)
	433	except:
	434	print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
[a35b458]	435
[ce55b43]	436	if (compatible_int == 1):
	437	builtins[tag] = {
	438	'tag': tag,
	439	'name': name,
	440	'sign': signedness,
	441	'base': base,
	442	'size': size_int,
	443	}
[a35b458]	444
[ce55b43]	445	for typedef in typesizes:
	446	if not typedef['tag'] in builtins:
	447	print_error(['Unable to determine the properties of type %s.' % typedef['tag'],
[a4a0f1d]	448	COMPILER_FAIL])
[ce55b43]	449	if 'sname' in typedef:
	450	builtins[typedef['tag']]['sname'] = typedef['sname']
[a35b458]	451
[ce55b43]	452	return builtins
	453
	454	def get_suffix(type):
	455	if type['sign'] == 'unsigned':
	456	return {
	457	"char": "",
	458	"short": "",
	459	"int": "U",
	460	"long": "UL",
	461	"long long": "ULL",
	462	}[type['base']]
[96b89acb]	463	else:
[ce55b43]	464	return {
	465	"char": "",
	466	"short": "",
	467	"int": "",
	468	"long": "L",
	469	"long long": "LL",
	470	}[type['base']]
	471
	472	def get_max(type):
	473	val = (1 << (type['size']*8 - 1))
	474	if type['sign'] == 'unsigned':
	475	val *= 2
	476	return val - 1
	477
	478	def detect_sizes(probe):
	479	"Detect properties of builtin types"
[a35b458]	480
[ce55b43]	481	macros = {}
[a35b458]	482
[ce55b43]	483	for type in probe.values():
	484	macros['__SIZEOF_%s__' % type['tag']] = type['size']
[a35b458]	485
[ce55b43]	486	if ('sname' in type):
	487	macros['__%s_TYPE__' % type['sname']] = type['name']
	488	macros['__%s_WIDTH__' % type['sname']] = type['size']*8
	489	macros['__%s_%s__' % (type['sname'], type['sign'].upper())] = "1"
	490	macros['__%s_C_SUFFIX__' % type['sname']] = get_suffix(type)
	491	macros['__%s_MAX__' % type['sname']] = "%d%s" % (get_max(type), get_suffix(type))
[a35b458]	492
[ce55b43]	493	if (probe['SIZE_T']['sign'] != 'unsigned'):
	494	print_error(['The type size_t is not unsigned.', COMPILER_FAIL])
[a35b458]	495
[ce55b43]	496	return macros
[4e9aaf5]	497
	498	def create_makefile(mkname, common):
	499	"Create makefile output"
[a35b458]	500
[28f4adb]	501	outmk = open(mkname, 'w')
[a35b458]	502
[4e9aaf5]	503	outmk.write('#########################################\n')
	504	outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
[571239a]	505	outmk.write('## Generated by: tools/autotool.py ##\n')
[4e9aaf5]	506	outmk.write('#########################################\n\n')
[a35b458]	507
[177e4ea]	508	for key, value in common.items():
[7174403]	509	if (type(value) is list):
	510	outmk.write('%s = %s\n' % (key, " ".join(value)))
	511	else:
	512	outmk.write('%s = %s\n' % (key, value))
[a35b458]	513
[4e9aaf5]	514	outmk.close()
	515
[ce55b43]	516	def create_header(hdname, macros):
[4e9aaf5]	517	"Create header output"
[a35b458]	518
[28f4adb]	519	outhd = open(hdname, 'w')
[a35b458]	520
[4e9aaf5]	521	outhd.write('/***************************************\n')
	522	outhd.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')
[571239a]	523	outhd.write(' * Generated by: tools/autotool.py *\n')
[4e9aaf5]	524	outhd.write(' ***************************************/\n\n')
[a35b458]	525
[4e9aaf5]	526	outhd.write('#ifndef %s\n' % GUARD)
	527	outhd.write('#define %s\n\n' % GUARD)
[a35b458]	528
[ce55b43]	529	for macro in sorted(macros):
	530	outhd.write('#ifndef %s\n' % macro)
	531	outhd.write('#define %s %s\n' % (macro, macros[macro]))
	532	outhd.write('#endif\n\n')
[a35b458]	533
[4e9aaf5]	534	outhd.write('\n#endif\n')
	535	outhd.close()
[177e4ea]	536
	537	def main():
	538	config = {}
	539	common = {}
[a35b458]	540
[177e4ea]	541	# Read and check configuration
[4e9aaf5]	542	if os.path.exists(CONFIG):
	543	read_config(CONFIG, config)
[177e4ea]	544	else:
[4e9aaf5]	545	print_error(["Configuration file %s not found! Make sure that the" % CONFIG,
[177e4ea]	546	"configuration phase of HelenOS build went OK. Try running",
	547	"\"make config\" again."])
[a35b458]	548
[177e4ea]	549	check_config(config, "PLATFORM")
	550	check_config(config, "COMPILER")
	551	check_config(config, "BARCH")
[a35b458]	552
[177e4ea]	553	# Cross-compiler prefix
	554	if ('CROSS_PREFIX' in os.environ):
	555	cross_prefix = os.environ['CROSS_PREFIX']
	556	else:
[603c8740]	557	cross_prefix = "/usr/local/cross"
[a35b458]	558
[8f2eca0]	559	# HelenOS cross-compiler prefix
	560	if ('CROSS_HELENOS_PREFIX' in os.environ):
	561	cross_helenos_prefix = os.environ['CROSS_HELENOS_PREFIX']
	562	else:
	563	cross_helenos_prefix = "/usr/local/cross-helenos"
[a35b458]	564
[177e4ea]	565	# Prefix binutils tools on Solaris
	566	if (os.uname()[0] == "SunOS"):
	567	binutils_prefix = "g"
	568	else:
	569	binutils_prefix = ""
[a35b458]	570
[4e9aaf5]	571	owd = sandbox_enter()
[a35b458]	572
[4e9aaf5]	573	try:
	574	# Common utilities
	575	check_app(["ln", "--version"], "Symlink utility", "usually part of coreutils")
	576	check_app(["rm", "--version"], "File remove utility", "usually part of coreutils")
	577	check_app(["mkdir", "--version"], "Directory creation utility", "usually part of coreutils")
	578	check_app(["cp", "--version"], "Copy utility", "usually part of coreutils")
	579	check_app(["find", "--version"], "Find utility", "usually part of findutils")
	580	check_app(["diff", "--version"], "Diff utility", "usually part of diffutils")
	581	check_app(["make", "--version"], "Make utility", "preferably GNU Make")
[9ce911d]	582	check_app(["unzip"], "unzip utility", "usually part of zip/unzip utilities")
[75701004]	583	check_app(["tar", "--version"], "tar utility", "usually part of tar")
[a35b458]	584
[b08941d]	585	platform, cc_args, target = get_target(config)
[a35b458]	586
[b08941d]	587	if (platform is None) or (target is None):
	588	print_error(["Unsupported compiler target.",
	589	"Please contact the developers of HelenOS."])
[a35b458]	590
[b08941d]	591	path = "%s/%s/bin" % (cross_prefix, target)
[a35b458]	592
[b08941d]	593	# Compatibility with earlier toolchain paths.
	594	if not os.path.exists(path):
	595	if (config['COMPILER'] == "gcc_helenos"):
	596	check_path = "%s/%s/%s" % (cross_helenos_prefix, platform, target)
	597	if not os.path.exists(check_path):
	598	print_error(["Toolchain for target is not installed, or CROSS_PREFIX is not set correctly."])
	599	path = "%s/%s/bin" % (cross_helenos_prefix, platform)
	600	else:
	601	check_path = "%s/%s/%s" % (cross_prefix, platform, target)
	602	if not os.path.exists(check_path):
	603	print_error(["Toolchain for target is not installed, or CROSS_PREFIX is not set correctly."])
	604	path = "%s/%s/bin" % (cross_prefix, platform)
[a35b458]	605
[2660ee3]	606	common['TARGET'] = target
[b08941d]	607	prefix = "%s-" % target
[a35b458]	608
[b08941d]	609	# Compiler
	610	if (config['COMPILER'] == "gcc_cross" or config['COMPILER'] == "gcc_helenos"):
[8f2eca0]	611	check_gcc(path, prefix, common, PACKAGE_CROSS)
	612	check_binutils(path, prefix, common, PACKAGE_CROSS)
[a35b458]	613
[8f2eca0]	614	check_common(common, "GCC")
[a0a273e]	615	common['CC'] = " ".join([common['GCC']] + cc_args)
	616	common['CC_AUTOGEN'] = common['CC']
[a35b458]	617
[058c240]	618	check_common(common, "GPP")
	619	common['CPP'] = common['GPP']
	620
[4e9aaf5]	621	if (config['COMPILER'] == "gcc_native"):
	622	check_gcc(None, "", common, PACKAGE_GCC)
	623	check_binutils(None, binutils_prefix, common, PACKAGE_BINUTILS)
[a35b458]	624
[4e9aaf5]	625	check_common(common, "GCC")
	626	common['CC'] = common['GCC']
[a0a273e]	627	common['CC_AUTOGEN'] = common['CC']
[a35b458]	628
[4e9aaf5]	629	if (config['COMPILER'] == "clang"):
[84eb4edd]	630	check_binutils(path, prefix, common, PACKAGE_CROSS)
	631	check_clang(path, prefix, common, PACKAGE_CLANG)
[a35b458]	632
[a0a273e]	633	check_common(common, "CLANG")
	634	common['CC'] = " ".join([common['CLANG']] + cc_args)
	635	common['CC_AUTOGEN'] = common['CC'] + " -no-integrated-as"
[a35b458]	636
[a0a273e]	637	if (config['INTEGRATED_AS'] == "yes"):
	638	common['CC'] += " -integrated-as"
[a35b458]	639
[a0a273e]	640	if (config['INTEGRATED_AS'] == "no"):
	641	common['CC'] += " -no-integrated-as"
[a35b458]	642
[4e9aaf5]	643	# Platform-specific utilities
	644	if ((config['BARCH'] == "amd64") or (config['BARCH'] == "ia32") or (config['BARCH'] == "ppc32") or (config['BARCH'] == "sparc64")):
[ff87f70]	645	common['GENISOIMAGE'] = check_app_alternatives(["genisoimage", "mkisofs", "xorriso"], ["--version"], "ISO 9660 creation utility", "usually part of genisoimage")
[b6bbc74]	646	if common['GENISOIMAGE'] == 'xorriso':
[92c07dc]	647	common['GENISOIMAGE'] += ' -as genisoimage'
[a35b458]	648
[4e9aaf5]	649	probe = probe_compiler(common,
	650	[
[ce55b43]	651	{'type': 'long long int', 'tag': 'LONG_LONG', 'sname': 'LLONG' },
	652	{'type': 'long int', 'tag': 'LONG', 'sname': 'LONG' },
	653	{'type': 'int', 'tag': 'INT', 'sname': 'INT' },
	654	{'type': 'short int', 'tag': 'SHORT', 'sname': 'SHRT'},
	655	{'type': 'void*', 'tag': 'POINTER'},
[a4a0f1d]	656	{'type': 'long double', 'tag': 'LONG_DOUBLE'},
	657	{'type': 'double', 'tag': 'DOUBLE'},
[ce55b43]	658	{'type': 'float', 'tag': 'FLOAT'},
	659	{'type': '__SIZE_TYPE__', 'tag': 'SIZE_T', 'def': '__SIZE_TYPE__', 'sname': 'SIZE' },
	660	{'type': '__PTRDIFF_TYPE__', 'tag': 'PTRDIFF_T', 'def': '__PTRDIFF_TYPE__', 'sname': 'PTRDIFF' },
	661	{'type': '__WINT_TYPE__', 'tag': 'WINT_T', 'def': '__WINT_TYPE__', 'sname': 'WINT' },
	662	{'type': '__WCHAR_TYPE__', 'tag': 'WCHAR_T', 'def': '__WCHAR_TYPE__', 'sname': 'WCHAR' },
	663	{'type': '__INTMAX_TYPE__', 'tag': 'INTMAX_T', 'def': '__INTMAX_TYPE__', 'sname': 'INTMAX' },
	664	{'type': 'unsigned __INTMAX_TYPE__', 'tag': 'UINTMAX_T', 'def': '__INTMAX_TYPE__', 'sname': 'UINTMAX' },
[4e9aaf5]	665	]
	666	)
[a35b458]	667
[ce55b43]	668	macros = detect_sizes(probe)
[a35b458]	669
[4e9aaf5]	670	finally:
	671	sandbox_leave(owd)
[a35b458]	672
[4e9aaf5]	673	create_makefile(MAKEFILE, common)
[ce55b43]	674	create_header(HEADER, macros)
[a35b458]	675
[177e4ea]	676	return 0
	677
	678	if __name__ == '__main__':
	679	sys.exit(main())

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

Download in other formats: