tools/autotool.py

   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.new'
  45 GUARD = '_AUTOTOOL_COMMON_H_'
  46
  47 PROBE_SOURCE = 'probe.c'
  48 PROBE_OUTPUT = 'probe.s'
  49
  50 PACKAGE_BINUTILS = "usually part of binutils"
  51 PACKAGE_GCC = "preferably version 4.7.0 or newer"
  52 PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
  53 PACKAGE_CLANG = "reasonably recent version of clang needs to be installed"
  54
  55 TOOLCHAIN_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."]
  59 COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
  60 COMPILER_WARNING = "The compilation of HelenOS might fail."
  61
  62 PROBE_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
  88 extern int main(int, char *[]);
  89
  90 int main(int argc, char *argv[])
  91 {
  92 """
  93
  94 PROBE_TAIL = """}
  95 """
  96
  97 def 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
 109 def 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
 122 def 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
 135 def 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
 158 def sandbox_leave(owd):
 159         "Leave the temporal sandbox directory"
 160
 161         os.chdir(owd)
 162
 163 def 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
 171 def 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
 178 def 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
 247 def 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
 262 def 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
 271 def 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
 304 def 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
 314 def 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
 326 def 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
 350 def 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
 371 def 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
 385 def 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
 471 def 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
 489 def get_max(type):
 490         val = (1 << (type['size']*8 - 1))
 491         if type['sign'] == 'unsigned':
 492                 val *= 2
 493         return val - 1
 494
 495 def 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
 515 def 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
 533 def 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
 554 def 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
 673 if __name__ == '__main__':
 674         sys.exit(main())