source: mainline/tools/autotool.py@ 8df0306

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 8df0306 was 84176f3, checked in by Jakub Jermář <jakub@…>, 6 years ago

arm64: Add support for the architecture

This changeset adds basic support to run HelenOS on AArch64, targeting
the QEMU virt platform.

Boot:

  • Boot relies on the EDK II firmware, GRUB2 for EFI and the HelenOS bootloader (UEFI application). EDK II loads GRUB2 from a CD, GRUB2 loads the HelenOS bootloader (via UEFI) which loads OS components.
  • UEFI applications use the PE/COFF format and must be relocatable. The first problem is solved by manually having the PE/COFF headers and tables written in assembler. The relocatable requirement is addressed by compiling the code with -fpic and having the bootloader relocate itself at its startup.

Kernel:

  • Kernel code for AArch64 consists mostly of stubbing out various architecture-specific hooks: virtual memory management, interrupt and exception handling, context switching (including FPU lazy switching), support for virtual timer, atomic sequences and barriers, cache and TLB maintenance, thread and process initialization.
  • The patch adds a kernel driver for GICv2 (interrupt controller).
  • The PL011 kernel driver is extended to allow userspace to take ownership of the console.
  • The current code is not able to dynamically obtain information about available devices on the underlying machine. The port instead implements a machine-func interface similar to the one implemented by arm32. It defines a machine for the QEMU AArch64 virt platform. The configuration (device addresses and IRQ numbers) is then baked into the machine definition.

User space:

  • Uspace code for AArch64 similarly mostly implements architecture-specific hooks: context saving/restoring, syscall support, TLS support.

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