Changeset 3e828ea in mainline for tools

Timestamp:

2019-09-23T12:49:29Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

9be2358

Parents:

9259d20 (diff), 1a4ec93f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jiri Svoboda <jiri@…> (2019-09-22 12:49:07)

git-committer:

Jiri Svoboda <jiri@…> (2019-09-23 12:49:29)

Message:

Merge changes from master, especially Meson build

Location:

tools

Files:

• README (added)
• autocheck.awk (modified) (4 diffs)
• autotool.py (deleted)
• build-ccheck.sh (modified) (1 diff)
• build_all.sh (added)
• cc.sh (modified) (2 diffs)
• ccheck.sh (modified) (4 diffs)
• config.py (modified) (16 diffs)
• dest_build.py (deleted)
• ew.py (modified) (12 diffs)
• export.sh (moved) (moved from uspace/app/vlaunch/Makefile ) (2 diffs, 1 prop)
• grub/grub-update.sh (modified) (3 diffs)
• grub/mkimage.sh (modified) (1 diff)
• list_profiles.sh (added)
• mkarray_for_meson.sh (moved) (moved from boot/Makefile.uboot ) (2 diffs, 1 prop)
• release.sh (moved) (moved from tools/check.sh ) (2 diffs)
• srepl (modified) (1 diff)
• toolchain.sh (modified) (16 diffs)
• travis.sh (modified) (4 diffs)
• xcw/bin/helenos-bld-config (deleted)
• xcw/bin/helenos-cc (modified) (1 diff)
• xcw/bin/helenos-ld (deleted)
• xcw/bin/helenos-pkg-config (modified) (1 diff)
• xcw/demo/Makefile (modified) (1 diff)
• xcw/include/helenos (deleted)

tools/autocheck.awk

@@ -33 +33 @@
 BEGIN {
         filename = ARGV[1]
+        output_lines = 0
         print "// Generated file. Fix the included header if static assert fails."
-        print "#include \"" filename "\""
+        print "// Inlined \"" filename "\""
+}
+
+{
+        print $0
 }
 
@@ -44 +49 @@
         }
         macro_name = toupper(struct_name) "_SIZE"
-        print "_Static_assert(" macro_name " == sizeof(struct " struct_name "), \"\");"
+        output[output_lines++] = "_Static_assert(" macro_name " == sizeof(struct " struct_name "), \"\");"
         struct_name = ""
 }
@@ -55 +60 @@
 
                 macro_name = toupper(struct_name) "_OFFSET_" toupper(member)
-                print "_Static_assert(" macro_name " == __builtin_offsetof(struct " struct_name ", " member "), \"\");"
+                output[output_lines++] = "_Static_assert(" macro_name " == __builtin_offsetof(struct " struct_name ", " member "), \"\");"
 
                 macro_name = toupper(struct_name) "_SIZE_" toupper(member)
-                print "#ifdef " macro_name
-                print "_Static_assert(" macro_name " == sizeof(((struct " struct_name "){ })." member "), \"\");"
-                print "#endif"
+                output[output_lines++] = "#ifdef " macro_name
+                output[output_lines++] = "_Static_assert(" macro_name " == sizeof(((struct " struct_name "){ })." member "), \"\");"
+                output[output_lines++] = "#endif"
         }
 }
@@ -67 +72 @@
         struct_name = $3
 }
+
+END {
+        for ( i = 0; i < output_lines; i++ ) {
+                print output[i]
+        }
+}

tools/build-ccheck.sh

@@ -1 @@
-#!/bin/bash
+#!/bin/sh
 #
 # Copyright (c) 2019 Jiri Svoboda

tools/cc.sh

@@ -1 @@
-#! /bin/bash
+#!/bin/sh
 
 #
@@ -36 +36 @@
 EOF
 
+# Find out the path to the script.
+SOURCE_DIR=`which -- "$0" 2>/dev/null`
+# Maybe we are running bash.
+[ -z "$SOURCE_DIR" ] && SOURCE_DIR=`which -- "$BASH_SOURCE"`
+[ -z "$SOURCE_DIR" ] && exit 1
+SOURCE_DIR=`dirname -- "$SOURCE_DIR"`
+SOURCE_DIR=`cd $SOURCE_DIR && cd .. && echo $PWD`
+
 echo ""
 
-git grep 'Copyright ([cC])' | \
+git -C "$SOURCE_DIR" grep 'Copyright ([cC])' | \
         sed -E -n 's/^.*(Copyright \([cC]\) (20[0-9][0-9]-)?20[0-9][0-9],? [-a-zA-Z., ]*[-a-zA-Z.]$)/\1/p' | \
         sed -E 's/ ( )+/ /' | \

tools/ccheck.sh

@@ -1 @@
-#!/bin/bash
+#!/bin/sh
 #
 # Copyright (c) 2018 Jiri Svoboda
@@ -33 +33 @@
 fi
 
-if [ ."$1" == .--fix ] ; then
+if [ ."$1" = .--fix ]; then
         opt=--fix
 else
@@ -49 +49 @@
         outfile="$(mktemp)"
         "$ccheck" $opt $fname >"$outfile" 2>&1
-        rc=$?
-        if [ .$rc == .0 ]; then
+        if [ $? -eq 0 ]; then
                 if [ -s "$outfile" ] ; then
                         srepcnt=$((srepcnt + 1))
@@ -65 +64 @@
 done
 
-if [ $srepcnt == 0 -a $fcnt == 0 ] ; then
+if [ $srepcnt -eq 0 ] && [ $fcnt -eq 0 ]; then
         echo "Ccheck passed."
 else

tools/config.py

@@ -42 +42 @@
 import random
 
-RULES_FILE = sys.argv[1]
+ARGPOS_RULES = 1
+ARGPOS_PRESETS_DIR = 2
+ARGPOS_CHOICE = 3
+ARGPOS_PRESET = 4
+ARGPOS_MASK_PLATFORM = 3
+
+RULES_FILE = sys.argv[ARGPOS_RULES]
 MAKEFILE = 'Makefile.config'
 MACROS = 'config.h'
-PRESETS_DIR = 'defaults'
+PRESETS_DIR = sys.argv[ARGPOS_PRESETS_DIR]
+
+class BinaryOp:
+        def __init__(self, operator, left, right):
+                assert operator in ('&', '|', '=', '!=')
+
+                self._operator = operator
+                self._left = left
+                self._right = right
+
+        def evaluate(self, config):
+                if self._operator == '&':
+                        return self._left.evaluate(config) and \
+                            self._right.evaluate(config)
+                if self._operator == '|':
+                        return self._left.evaluate(config) or \
+                            self._right.evaluate(config)
+
+                # '=' or '!='
+                if not self._left in config:
+                        config_val = ''
+                else:
+                        config_val = config[self._left]
+                        if config_val == '*':
+                                config_val = 'y'
+
+                if self._operator == '=':
+                        return self._right == config_val
+                return self._right != config_val
+
+# Expression parser
+class CondParser:
+        TOKEN_EOE = 0
+        TOKEN_SPECIAL = 1
+        TOKEN_STRING = 2
+
+        def __init__(self, text):
+                self._text = text
+
+        def parse(self):
+                self._position = -1
+                self._next_char()
+                self._next_token()
+
+                res = self._parse_expr()
+                if self._token_type != self.TOKEN_EOE:
+                        self._error("Expected end of expression")
+                return res
+
+        def _next_char(self):
+                self._position += 1
+                if self._position >= len(self._text):
+                        self._char = None
+                else:
+                        self._char = self._text[self._position]
+                self._is_special_char = self._char in \
+                    ('&', '|', '=', '!', '(', ')')
+
+        def _error(self, msg):
+                raise RuntimeError("Error parsing expression: %s:\n%s\n%s^" %
+                    (msg, self._text, " " * self._token_position))
+
+        def _next_token(self):
+                self._token_position = self._position
+
+                # End of expression
+                if self._char == None:
+                        self._token = None
+                        self._token_type = self.TOKEN_EOE
+                        return
+
+                # '&', '|', '=', '!=', '(', ')'
+                if self._is_special_char:
+                        self._token = self._char
+                        self._next_char()
+                        if self._token == '!':
+                                if self._char != '=':
+                                        self._error("Expected '='")
+                                self._token += self._char
+                                self._next_char()
+                        self._token_type = self.TOKEN_SPECIAL
+                        return
+
+                # <var> or <val>
+                self._token = ''
+                self._token_type = self.TOKEN_STRING
+                while True:
+                        self._token += self._char
+                        self._next_char()
+                        if self._is_special_char or self._char == None:
+                                break
+
+        def _parse_expr(self):
+                """ <expr> ::= <or_expr> ('&' <or_expr>)* """
+
+                left = self._parse_or_expr()
+                while self._token == '&':
+                        self._next_token()
+                        left = BinaryOp('&', left, self._parse_or_expr())
+                return left
+
+        def _parse_or_expr(self):
+                """ <or_expr> ::= <factor> ('|' <factor>)* """
+
+                left = self._parse_factor()
+                while self._token == '|':
+                        self._next_token()
+                        left = BinaryOp('|', left, self._parse_factor())
+                return left
+
+        def _parse_factor(self):
+                """ <factor> ::= <var> <cond> | '(' <expr> ')' """
+
+                if self._token == '(':
+                        self._next_token()
+                        res = self._parse_expr()
+                        if self._token != ')':
+                                self._error("Expected ')'")
+                        self._next_token()
+                        return res
+
+                if self._token_type == self.TOKEN_STRING:
+                        var = self._token
+                        self._next_token()
+                        return self._parse_cond(var)
+
+                self._error("Expected '(' or <var>")
+
+        def _parse_cond(self, var):
+                """ <cond> ::= '=' <val> | '!=' <val> """
+
+                if self._token not in ('=', '!='):
+                        self._error("Expected '=' or '!='")
+
+                oper = self._token
+                self._next_token()
+
+                if self._token_type != self.TOKEN_STRING:
+                        self._error("Expected <val>")
+
+                val = self._token
+                self._next_token()
+
+                return BinaryOp(oper, var, val)
 
 def read_config(fname, config):
@@ -59 +208 @@
         inf.close()
 
-def check_condition(text, config, rules):
-        "Check that the condition specified on input line is True (only CNF and DNF is supported)"
-
-        ctype = 'cnf'
-
-        if (')|' in text) or ('|(' in text):
-                ctype = 'dnf'
-
-        if ctype == 'cnf':
-                conds = text.split('&')
-        else:
-                conds = text.split('|')
-
-        for cond in conds:
-                if cond.startswith('(') and cond.endswith(')'):
-                        cond = cond[1:-1]
-
-                inside = check_inside(cond, config, ctype)
-
-                if (ctype == 'cnf') and (not inside):
-                        return False
-
-                if (ctype == 'dnf') and inside:
-                        return True
-
-        if ctype == 'cnf':
-                return True
-
-        return False
-
-def check_inside(text, config, ctype):
-        "Check for condition"
-
-        if ctype == 'cnf':
-                conds = text.split('|')
-        else:
-                conds = text.split('&')
-
-        for cond in conds:
-                res = re.match(r'^(.*?)(!?=)(.*)$', cond)
-                if not res:
-                        raise RuntimeError("Invalid condition: %s" % cond)
-
-                condname = res.group(1)
-                oper = res.group(2)
-                condval = res.group(3)
-
-                if not condname in config:
-                        varval = ''
-                else:
-                        varval = config[condname]
-                        if (varval == '*'):
-                                varval = 'y'
-
-                if ctype == 'cnf':
-                        if (oper == '=') and (condval == varval):
-                                return True
-
-                        if (oper == '!=') and (condval != varval):
-                                return True
-                else:
-                        if (oper == '=') and (condval != varval):
-                                return False
-
-                        if (oper == '!=') and (condval == varval):
-                                return False
-
-        if ctype == 'cnf':
-                return False
-
-        return True
-
 def parse_rules(fname, rules):
         "Parse rules file"
@@ -149 +226 @@
 
                         cond = res.group(1)
+                        if cond:
+                                cond = CondParser(cond).parse()
                         varname = res.group(2)
                         vartype = res.group(3)
@@ -232 +311 @@
                 varname, vartype, name, choices, cond = rule
 
-                if cond and (not check_condition(cond, config, rules)):
+                if cond and not cond.evaluate(config):
                         continue
 
@@ -279 +358 @@
 
         # First check that this rule would make sense
-        if cond:
-                if not check_condition(cond, config, rules):
-                        return random_choices(config, rules, start_index + 1)
+        if cond and not cond.evaluate(config):
+                return random_choices(config, rules, start_index + 1)
 
         # Remember previous choices for backtracking
@@ -460 +538 @@
 
         try:
-                version = subprocess.Popen(['git', 'log', '-1', '--pretty=%h'], stdout = subprocess.PIPE).communicate()[0].decode().strip()
+                version = subprocess.Popen(['git', '-C', os.path.dirname(RULES_FILE), 'log', '-1', '--pretty=%h'], stdout = subprocess.PIPE).communicate()[0].decode().strip()
                 sys.stderr.write("ok\n")
         except:
@@ -487 +565 @@
 
         for varname, vartype, name, choices, cond in rules:
-                if cond and (not check_condition(cond, config, rules)):
+                if cond and not cond.evaluate(config):
                         continue
 
@@ -514 +592 @@
         outmk.write('TIMESTAMP_UNIX = %d\n' % timestamp_unix)
         outmc.write('#define TIMESTAMP_UNIX %d\n' % timestamp_unix)
-        defs += ' "-DTIMESTAMP_UNIX=%d"\n' % timestamp_unix
+        defs += ' "-DTIMESTAMP_UNIX=%d"' % timestamp_unix
 
         outmk.write('TIMESTAMP = %s\n' % timestamp)
         outmc.write('#define TIMESTAMP %s\n' % timestamp)
-        defs += ' "-DTIMESTAMP=%s"\n' % timestamp
-
-        outmk.write(defs)
+        defs += ' "-DTIMESTAMP=%s"' % timestamp
+
+        outmk.write('%s\n' % defs)
 
         outmk.close()
@@ -604 +682 @@
         parse_rules(RULES_FILE, rules)
 
+        if len(sys.argv) > ARGPOS_CHOICE:
+                choice = sys.argv[ARGPOS_CHOICE]
+        else:
+                choice = None
+
+        if len(sys.argv) > ARGPOS_PRESET:
+                preset = sys.argv[ARGPOS_PRESET]
+        else:
+                preset = None
+
+        mask_platform = (len(sys.argv) > ARGPOS_MASK_PLATFORM and sys.argv[ARGPOS_MASK_PLATFORM] == "--mask-platform")
+
         # Input configuration file can be specified on command line
         # otherwise configuration from previous run is used.
-        if len(sys.argv) >= 4:
-                profile = parse_profile_name(sys.argv[3])
+        if preset is not None:
+                profile = parse_profile_name(preset)
                 read_presets(profile, config)
         elif os.path.exists(MAKEFILE):
@@ -613 +703 @@
 
         # Default mode: check values and regenerate configuration files
-        if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
+        if choice == 'default':
                 if (infer_verify_choices(config, rules)):
                         preprocess_config(config, rules)
@@ -621 +711 @@
         # Hands-off mode: check values and regenerate configuration files,
         # but no interactive fallback
-        if (len(sys.argv) >= 3) and (sys.argv[2] == 'hands-off'):
-                # We deliberately test sys.argv >= 4 because we do not want
+        if choice == 'hands-off':
+                # We deliberately test this because we do not want
                 # to read implicitly any possible previous run configuration
-                if len(sys.argv) < 4:
+                if preset is None:
                         sys.stderr.write("Configuration error: No presets specified\n")
                         return 2
@@ -637 +727 @@
 
         # Check mode: only check configuration
-        if (len(sys.argv) >= 3) and (sys.argv[2] == 'check'):
+        if choice == 'check':
                 if infer_verify_choices(config, rules):
                         return 0
@@ -643 +733 @@
 
         # Random mode
-        if (len(sys.argv) == 3) and (sys.argv[2] == 'random'):
+        if choice == 'random':
                 ok = random_choices(config, rules, 0)
                 if not ok:
@@ -669 +759 @@
                         options = []
                         opt2row = {}
-                        cnt = 1
-
-                        options.append("  --- Load preconfigured defaults ... ")
+                        cnt = 0
+
+                        if not mask_platform:
+                                cnt += 1
+                                options.append("  --- Load preconfigured defaults ... ")
 
                         for rule in rules:
                                 varname, vartype, name, choices, cond = rule
 
-                                if cond and (not check_condition(cond, config, rules)):
+                                if cond and not cond.evaluate(config):
                                         continue
+
+                                if mask_platform and (varname == "PLATFORM" or varname == "MACHINE" or varname == "COMPILER"):
+                                        rule = varname, vartype, "(locked) " + name, choices, cond
 
                                 if varname == selname:
@@ -725 +820 @@
                                         continue
 
-                        if value == 0:
+                        if value == 0 and not mask_platform:
                                 profile = choose_profile(PRESETS_DIR, MAKEFILE, screen, config)
                                 if profile != None:
@@ -742 +837 @@
                         else:
                                 value = config[selname]
+
+                        if mask_platform and (selname == "PLATFORM" or selname == "MACHINE" or selname == "COMPILER"):
+                                        continue
 
                         if seltype == 'choice':

tools/ew.py

@@ -33 +33 @@
 """
 
+import inspect
 import os
+import platform
+import re
+import subprocess
 import sys
-import subprocess
-import autotool
-import platform
 import thread
 import time
 
 overrides = {}
+
+CONFIG = 'Makefile.config'
+
+TOOLS_DIR = os.path.dirname(inspect.getabsfile(inspect.currentframe()))
+
+def read_config():
+        "Read HelenOS build configuration"
+
+        inf = open(CONFIG, 'r')
+        config = {}
+
+        for line in inf:
+                res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
+                if (res):
+                        config[res.group(1)] = res.group(2)
+
+        inf.close()
+        return config
 
 def is_override(str):
@@ -57 +76 @@
 
 def termemu_detect():
-        for termemu in ['xfce4-terminal', 'xterm']:
+        emus = ['gnome-terminal', 'xfce4-terminal', 'xterm']
+        for termemu in emus:
                 try:
                         subprocess.check_output('which ' + termemu, shell = True)
@@ -64 +84 @@
                         pass
 
+        print('Could not find any of the terminal emulators %s.'%(emus))
+        sys.exit(1)
+
 def run_in_console(cmd, title):
-        ecmd = cmd.replace('"', '\\"')
-        cmdline = termemu_detect() + ' -T ' + '"' + title + '"' + ' -e "' + ecmd + '"'
+        temu = termemu_detect()
+        if temu == 'gnome-terminal':
+                cmdline = temu + ' -- ' + cmd
+        else:
+                ecmd = cmd.replace('"', '\\"')
+                cmdline = temu + ' -T ' + '"' + title + '"' + ' -e "' + ecmd + '"'
+
         print(cmdline)
         if not is_override('dryrun'):
@@ -87 +115 @@
 
 def malta_options():
-        return '-cpu 4Kc'
+        return '-cpu 4Kc -append "console=devices/\\hw\\pci0\\00:0a.0\\com1\\a"'
+
+def find_firmware(name, environ_var, default_paths, extra_info=None):
+        """Find firmware image(s)."""
+
+        if environ_var in os.environ:
+                return os.environ[environ_var]
+
+        for path in default_paths:
+                if os.path.exists(path):
+                        return path
+
+        sys.stderr.write("Cannot find %s binary image(s)!\n" % name)
+        sys.stderr.write(
+            "Either set %s environment variable accordingly or place the image(s) in one of the default locations: %s.\n" %
+            (environ_var, ", ".join(default_paths)))
+        if extra_info is not None:
+                sys.stderr.write(extra_info)
+        return None
 
 def platform_to_qemu_options(platform, machine, processor):
@@ -94 +140 @@
         elif platform == 'arm32':
                 return 'system-arm', '-M integratorcp'
+        elif platform == 'arm64':
+                # Search for the EDK2 firmware image
+                default_paths = (
+                        '/usr/local/qemu-efi-aarch64/QEMU_EFI.fd', # Custom
+                        '/usr/share/edk2/aarch64/QEMU_EFI.fd',     # Fedora
+                        '/usr/share/qemu-efi-aarch64/QEMU_EFI.fd', # Ubuntu
+                )
+                extra_info = ("Pre-compiled binary can be obtained from "
+                    "http://snapshots.linaro.org/components/kernel/leg-virt-tianocore-edk2-upstream/latest/QEMU-AARCH64/RELEASE_GCC49/QEMU_EFI.fd.\n")
+                efi_path = find_firmware(
+                    "EDK2", 'EW_QEMU_EFI_AARCH64', default_paths, extra_info)
+                if efi_path is None:
+                        raise Exception
+
+                return 'system-aarch64', \
+                    '-M virt -cpu cortex-a57 -m 1024 -bios %s' % efi_path
         elif platform == 'ia32':
                 return 'system-i386', pc_options(32)
@@ -108 +170 @@
                 if processor == 'us':
                         return 'system-sparc64', '-M sun4u --prom-env boot-args="console=devices/\\hw\\pci0\\01:01.0\\com1\\a"'
-                elif processor == 'sun4v':
-                        default_path = '/usr/local/opensparc/image/'
-                try:
-                        if os.path.exists(default_path):
-                                opensparc_bins = default_path
-                        elif os.path.exists(os.environ['OPENSPARC_BINARIES']):
-                                opensparc_bins = os.environ['OPENSPARC_BINARIES']
-                        else:
-                                raise Exception
-                except:
-                        print("Cannot find OpenSPARC binary images!")
-                        print("Either set OPENSPARC_BINARIES environment variable accordingly or place the images in %s." % (default_path))
+
+                # processor = 'sun4v'
+                opensparc_bins = find_firmware(
+                    "OpenSPARC", 'OPENSPARC_BINARIES',
+                    ('/usr/local/opensparc/image/', ))
+                if opensparc_bins is None:
                         raise Exception
 
@@ -127 +183 @@
 def hdisk_mk():
         if not os.path.exists('hdisk.img'):
-                subprocess.call('tools/mkfat.py 1048576 uspace/dist/data hdisk.img', shell = True)
+                subprocess.call(TOOLS_DIR + '/mkfat.py 1048576 dist/data hdisk.img', shell = True)
 
 def qemu_bd_options():
@@ -208 +264 @@
                 cmdline += ' ' + options
 
-        cmdline += qemu_bd_options()
-
+        if (not 'hdd' in cfg.keys() or cfg['hdd']):
+                cmdline += qemu_bd_options()
         if (not 'net' in cfg.keys()) or cfg['net']:
                 cmdline += qemu_net_options()
@@ -234 +290 @@
         if cfg['image'] == 'image.iso':
                 cmdline += ' -boot d -cdrom image.iso'
+        elif cfg['image'] == 'image.iso@arm64':
+                # Define image.iso cdrom backend.
+                cmdline += ' -drive if=none,file=image.iso,id=cdrom,media=cdrom'
+                # Define scsi bus.
+                cmdline += ' -device virtio-scsi-device'
+                # Define cdrom frontend connected to this scsi bus.
+                cmdline += ' -device scsi-cd,drive=cdrom'
         elif cfg['image'] == 'image.boot':
                 cmdline += ' -kernel image.boot'
@@ -254 +317 @@
 
 def ski_run(platform, machine, processor):
-        run_in_console('ski -i tools/conf/ski.conf', 'HelenOS/ia64 on ski')
+        run_in_console('ski -i ' + TOOLS_DIR + '/conf/ski.conf', 'HelenOS/ia64 on ski')
 
 def msim_run(platform, machine, processor):
         hdisk_mk()
-        run_in_console('msim -c tools/conf/msim.conf', 'HelenOS/mips32 on msim')
+        run_in_console('msim -c ' + TOOLS_DIR + '/conf/msim.conf', 'HelenOS/mips32 on msim')
 
 def spike_run(platform, machine, processor):
@@ -276 +339 @@
                         'xhci' : False,
                         'tablet' : False
+                }
+        },
+        'arm64' : {
+                'virt' : {
+                        'run' : qemu_run,
+                        'image' : 'image.iso@arm64',
+                        'audio' : False,
+                        'console' : True,
+                        'hdd' : False,
+                        'net' : False,
+                        'tablet' : False,
+                        'usb' : False,
+                        'xhci' : False
                 }
         },
@@ -438 +514 @@
                         exit()
 
-        config = {}
-        autotool.read_config(autotool.CONFIG, config)
+        config = read_config()
 
         if 'PLATFORM' in config.keys():

tools/export.sh

@@ +1 @@
+#!/bin/sh
+
 #
-# Copyright (c) 2012 Petr Koupy
+# Copyright (c) 2019 Jiří Zárevúcky
 # All rights reserved.
 #
@@ -27 +29 @@
 #
 
-USPACE_PREFIX = ../..
+if [ "$#" -ne 1 ]; then
+        echo "Must define export directory."
+        exit 1
+fi
 
-# TODO: Should be just "gui", rest is transitive dependencies.
-LIBS = gui draw softrend compress math
+EXPORT_DIR="$1"
 
-BINARY = vlaunch
+# Only (re)build files we actually want to export.
 
-IMG = image
-IMGS = $(IMG)s
+EXPORT_LIBS=" \
+        uspace/lib/libmath.a \
+        uspace/lib/libclui.a \
+        uspace/lib/libgui.a \
+        uspace/lib/libdraw.a \
+        uspace/lib/libsoftrend.a \
+        uspace/lib/libhound.a \
+        uspace/lib/libpcm.a \
+        uspace/lib/libcpp.a \
+        uspace/lib/libc.a \
+        uspace/lib/c/libstartfiles.a \
+        uspace/lib/libposix.a \
+"
 
-SOURCES = \
-        vlaunch.c \
-        $(IMGS).s \
-        $(IMGS)_desc.c
+EXPORT_CONFIGS=" \
+        meson/part/exports/config.mk \
+        meson/part/exports/config.sh \
+"
 
-IMAGES = \
-        gfx/helenos.tga
+ninja $EXPORT_LIBS $EXPORT_CONFIGS
+ninja devel-headers
 
-PRE_DEPEND = $(IMGS).s $(IMGS).h $(IMGS)_desc.c
-EXTRA_CLEAN = $(IMGS).s $(IMGS).h $(IMGS)_desc.c $(IMGS).zip
-
-include $(USPACE_PREFIX)/Makefile.common
-
-$(IMGS).s: $(IMGS).zip
-        unzip -p $< $@ > $@
-
-$(IMGS).h: $(IMGS).zip
-        unzip -p $< $@ > $@
-
-$(IMGS)_desc.c: $(IMGS).zip
-        unzip -p $< $@ > $@
-
-$(IMGS).zip: $(IMAGES)
-        $(ROOT_PATH)/tools/mkarray.py $(IMGS) $(IMG) "$(AS_PROLOG)" .data $^
+mkdir -p "$EXPORT_DIR/lib"
+cp -t "$EXPORT_DIR/lib" $EXPORT_LIBS
+rm -rf "$EXPORT_DIR/include"
+cp -R dist/include "$EXPORT_DIR/include"
+cp -t "$EXPORT_DIR" $EXPORT_CONFIGS

tools/grub/grub-update.sh

@@ -40 +40 @@
 grub_rev="bc220962e366b1b46769ed6f9fa5be603ba58ab5"
 
+build_ia32amd64_pc=false
+build_ia32amd64_efi=false
+build_arm64_efi=false
+
 function grub_build()
 {
-        target="$1"
-        platform="$2"
+        platform="$1"
+        conf_target="$2"
+        conf_platform="$3"
 
-        ./configure --prefix="$builddir/$target-$platform" --target="$target" --with-platform="$platform" --disable-werror || exit 1
+        ./configure --prefix="$builddir/$platform" --target="$conf_target" --with-platform="$conf_platform" --disable-werror || exit 1
         make clean || exit 1
         make install || exit 1
@@ -55 +60 @@
         platform="$2"
 
-        rm -rf "$helenosdir"/boot/"$gdir"/"$platform" || exit 1
-        cp -R "$builddir"/"$platform"/lib64/grub/"$platform" "$helenosdir"/boot/"$gdir" || exit 1
-        rm -f "$helenosdir"/boot/"$gdir"/"$platform"/*.image || exit 1
-        rm -f "$helenosdir"/boot/"$gdir"/"$platform"/*.module || exit 1
-        git add "$helenosdir"/boot/"$gdir"/"$platform" || exit 1
+        echo "$grub_rev" > "$helenosdir"/boot/grub/"$gdir"/REVISION || exit 1
+        rm -rf "$helenosdir"/boot/grub/"$gdir"/"$platform" || exit 1
+        cp -R "$builddir"/"$platform"/lib*/grub/"$platform" "$helenosdir"/boot/grub/"$gdir" || exit 1
+        rm -f "$helenosdir"/boot/grub/"$gdir"/"$platform"/*.image || exit 1
+        rm -f "$helenosdir"/boot/grub/"$gdir"/"$platform"/*.module || exit 1
+        git add "$helenosdir"/boot/grub/"$gdir"/"$platform" || exit 1
 }
+
+function show_usage()
+{
+        echo "Script to generate/update prebuild Grub2 in HelenOS source tree"
+        echo
+        echo "Syntax:"
+        echo " $0 <target>"
+        echo
+        echo "Possible targets are:"
+        echo " ia32+amd64-pc"
+        echo " ia32+amd64-efi"
+        echo " arm64-efi"
+        echo " all             build all targets"
+        echo
+
+        exit 3
+}
+
+if [ "$#" -ne "1" ] ; then
+        show_usage
+fi
+
+case "$1" in
+        ia32+amd64-pc)
+                build_ia32amd64_pc=true
+                ;;
+        ia32+amd64-efi)
+                build_ia32amd64_efi=true
+                ;;
+        arm64-efi)
+                build_arm64_efi=true
+                ;;
+        all)
+                build_ia32amd64_pc=true
+                build_ia32amd64_efi=true
+                build_arm64_efi=true
+                ;;
+        *)
+                show_usage
+                ;;
+esac
 
 # Prepare a clone of Grub2 repo
@@ -72 +119 @@
 git reset --hard "$grub_rev" || exit 1
 
-echo "$grub_rev" >"$helenosdir"/boot/grub.pc/REVISION || exit 1
-echo "$grub_rev" > "$helenosdir"/boot/grub.efi/REVISION || exit 1
+./autogen.sh || exit 1
 
-# Build each platform to a different directory
-./autogen.sh || exit 1
-grub_build i386 pc
-grub_build i386 efi
-grub_build x86_64 efi
+if $build_ia32amd64_pc ; then
+        cd "$workdir" || exit 1
+        grub_build i386-pc i386 pc
 
-# Extract El Torrito boot image for i386-pc
-cd "$helenosdir"/boot/grub.pc || exit 1
-rm -f pc.img || exit 1
-"$builddir"/i386-pc/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
+        # Extract El Torrito boot image for i386-pc
+        cd "$helenosdir"/boot/grub/ia32-pc || exit 1
+        rm -f pc.img || exit 1
+        "$builddir"/i386-pc/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
 
-# Extract El Torrito boot image for i386-efi
-cd "$helenosdir"/boot/grub.efi || exit 1
-rm -f efi.img.gz || exit 1
-"$builddir"/i386-efi/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
-mv efi.img i386-efi.img
+        grub_files_update ia32-pc i386-pc
+fi
 
-# Extract El Torrito boot image for x86_64-efi
-cd "$helenosdir"/boot/grub.efi || exit 1
-rm -f efi.img.gz || exit 1
-"$builddir"/x86_64-efi/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
+if $build_ia32amd64_efi ; then
+        cd "$workdir" || exit 1
 
-# Combine El Torrito boot images for x86_64-efi and i386-efi
-mkdir tmp || exit 1
-mcopy -ns -i i386-efi.img ::efi tmp || exit 1
-mcopy -s -i efi.img tmp/* :: || exit 1
-gzip efi.img || exit 1
-rm -rf tmp || exit 1
-rm -f i386-efi.img || exit 1
+        # Build each platform to a different directory
+        grub_build i386-efi i386 efi
+        grub_build x86_64-efi x86_64 efi
 
-# Update Grub files for all platforms
-grub_files_update grub.pc i386-pc
-grub_files_update grub.efi i386-efi
-grub_files_update grub.efi x86_64-efi
+        # Extract El Torrito boot image for i386-efi
+        cd "$helenosdir"/boot/grub/ia32-efi || exit 1
+        rm -f efi.img.gz || exit 1
+        "$builddir"/i386-efi/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
+        mv efi.img i386-efi.img
+
+        # Extract El Torrito boot image for x86_64-efi
+        cd "$helenosdir"/boot/grub/ia32-efi || exit 1
+        rm -f efi.img.gz || exit 1
+        "$builddir"/x86_64-efi/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
+
+        # Combine El Torrito boot images for x86_64-efi and i386-efi
+        mkdir tmp || exit 1
+        mcopy -ns -i i386-efi.img ::efi tmp || exit 1
+        mcopy -s -i efi.img tmp/* :: || exit 1
+        gzip efi.img || exit 1
+        rm -rf tmp || exit 1
+        rm -f i386-efi.img || exit 1
+
+        # Update Grub files for all platforms
+        grub_files_update ia32-efi i386-efi
+        grub_files_update ia32-efi x86_64-efi
+fi
+
+if $build_arm64_efi ; then
+        cd "$workdir" || exit 1
+
+        # Check that the expected compiler is present on PATH
+        if ! [ -x "$(command -v aarch64-linux-gnu-gcc)" ] ; then
+                echo "Error: aarch64-linux-gnu-gcc is missing" >&2
+                exit 1
+        fi
+
+        grub_build arm64-efi aarch64-linux-gnu efi
+
+        # Extract El Torrito boot image for arm64-efi
+        cd "$helenosdir"/boot/grub/arm64-efi || exit 1
+        rm -f efi.img.gz || exit 1
+        "$builddir"/arm64-efi/bin/grub-mkrescue -o phony --xorriso="$origdir/getimage.sh" || exit 1
+        gzip efi.img || exit 1
+
+        grub_files_update arm64-efi arm64-efi
+fi
 
 echo "GRUB update successful."

tools/grub/mkimage.sh

@@ -39 +39 @@
 orig_dir="$(cd "$(dirname "$0")" && pwd)"
 grub_tools_dir="$orig_dir/grub-build/i386-pc/bin"
-grub_mod_dir="$orig_dir/../../boot/grub.pc/i386-pc"
+grub_mod_dir="$orig_dir/../../boot/grub/ia32-pc/i386-pc"
 
 "$grub_tools_dir"/grub-mkimage --directory "$grub_mod_dir" \

tools/mkarray_for_meson.sh

@@ +1 @@
+#!/bin/sh
+
 #
-# Copyright (c) 2010 Jiri Svoboda
+# Copyright (c) 2019 Jiří Zárevúcky
 # All rights reserved.
 #
@@ -27 +29 @@
 #
 
-.PHONY: all clean
+TOOLS_DIR=`which -- "$0" 2>/dev/null`
+if [ -z "$TOOLS_DIR" ]; then
+        TOOLS_DIR=`which -- "$BASH_SOURCE" 2>/dev/null`
+fi
+TOOLS_DIR=`dirname $TOOLS_DIR`
+TOOLS_DIR=`cd $TOOLS_DIR && echo $PWD`
 
-include Makefile.common
 
-IMAGE_NAME = HelenOS-$(RELEASE)
-BIN_OUTPUT = image.bin
+_outdir="$1"
+_arg1="$2"
+_arg2="$3"
+_arg3="$4"
+_arg4="$5"
+_inputs=""
 
-all: $(POST_OUTPUT)
+shift 5
 
-$(BIN_OUTPUT): $(BOOT_OUTPUT)
-        $(OBJCOPY) -O binary $< $@
+for file in "$@"; do
+        _inputs="$_inputs $PWD/${file}"
+done
 
-$(POST_OUTPUT): $(BIN_OUTPUT)
-        $(MKUIMAGE) -name "$(IMAGE_NAME)" -laddr $(LADDR) -saddr $(SADDR) -ostype $(UIMAGE_OS) $< $@
-
-clean:
-        rm -f $(BIN_OUTPUT)
+cd $_outdir
+$TOOLS_DIR/mkarray.py "$_arg1" "$_arg2" "$_arg3" "$_arg4" $_inputs > /dev/null

tools/release.sh

@@ -1 @@
-#! /bin/bash
+#!/bin/sh
 
 #
-# Copyright (c) 2010 Jakub Jermar
+# Copyright (c) 2019 Jiří Zárevúcky
 # All rights reserved.
 #
@@ -29 +29 @@
 #
 
-if [ $1" " == "-h " ];
-then
-        echo "Perform pre-integration hands-off build of all profiles."
-        echo
-        echo "Syntax:"
-        echo " $0 [-h] [args...]"
-        echo
-        echo " -h        Print this help."
-        echo " args...   All other args are passed to make (e.g. -j 6)"
-        echo
+# Find out the path to the script.
+SOURCE_DIR=`which -- "$0" 2>/dev/null`
+# Maybe we are running bash.
+[ -z "$SOURCE_DIR" ] && SOURCE_DIR=`which -- "$BASH_SOURCE"`
+[ -z "$SOURCE_DIR" ] && exit 1
+SOURCE_DIR=`dirname -- "$SOURCE_DIR"`
+SOURCE_DIR=`cd $SOURCE_DIR && cd .. && echo $PWD`
 
-        exit
-fi
 
-FAILED=""
-PASSED=""
-PROFILES=""
-DIRS=`find defaults/ -name Makefile.config | sed 's/^defaults\/\(.*\)\/Makefile.config/\1/' | sort`
+echo "Running tools/build_all.sh"
 
-for D in $DIRS;
-do
-        for H in $DIRS;
-        do
-                if [ `echo $H | grep "^$D\/.*"`x != "x"  ];
-                then
-                        continue 2
-                fi
-        done
-        PROFILES="$PROFILES $D"
-done
+mkdir -p build_all
+cd build_all
+sh "${SOURCE_DIR}/tools/build_all.sh"
+cd ..
 
-echo ">>> Going to build the following profiles:"
-echo $PROFILES
-
-for P in $PROFILES;
-do
-        echo -n ">>>> Building $P... "
-        ( make distclean && make PROFILE=$P HANDS_OFF=y "$@" ) >>/dev/null 2>>/dev/null
-        if [ $? -ne 0 ];
-        then
-                FAILED="$FAILED $P"
-                echo "failed."
-        else
-                PASSED="$PASSED $P"
-                echo "ok."
-        fi
-done
-
-echo ">>> Done."
+echo
 echo
 
-echo ">>> The following profiles passed:"
-echo $PASSED
-echo
+PROFILES=`sh ${SOURCE_DIR}/tools/list_profiles.sh`
+RELEASE=`sed -n 's:^HELENOS_RELEASE \?= \?\(.*\)$:\1:p' "${SOURCE_DIR}/version"`
+SRC_ARCHIVE="HelenOS-${RELEASE}-src.tar"
 
-echo ">>> The following profiles failed:"
-echo $FAILED
-echo
+git -C "${SOURCE_DIR}" archive master -o "${PWD}/${SRC_ARCHIVE}"
+bzip2 -f "${SRC_ARCHIVE}"
+echo "Created ${SRC_ARCHIVE}.bz2"
 
+for profile in $PROFILES; do
+        image_name=`cat build_all/$profile/image_path`
+        if [ -z "$image_name" ]; then
+                continue
+        fi
+
+        image_path="build_all/$profile/`cat build_all/$profile/image_path`"
+        image_suffix=`echo "$image_name" | sed 's:.*\.::'`
+
+        release_name="HelenOS-${RELEASE}-`echo $profile | tr '/' '-'`.$image_suffix"
+        cp "$image_path" "$release_name"
+
+        echo "Created $release_name"
+done

tools/srepl

@@ -1 +1 @@
 #!/bin/sh
+
+#
+# Copyright (c) 2019 Jiří Zárevúcky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
 
 usage()

tools/toolchain.sh

@@ -1 @@
-#! /bin/bash
+#!/bin/sh
 
 #
@@ -66 +66 @@
         echo " amd64      AMD64 (x86-64, x64)"
         echo " arm32      ARM 32b"
+        echo " arm64      AArch64"
         echo " ia32       IA-32 (x86, i386)"
         echo " ia64       IA-64 (Itanium)"
@@ -102 +103 @@
         echo
         
-        if [ -z "$1" ] || [ "$1" == "all" ] ; then
-                PLATFORMS=("amd64" "arm32" "ia32" "ia64" "mips32" "mips32eb" "ppc32" "riscv64" "sparc64")
+        if [ -z "$1" ] || [ "$1" = "all" ] ; then
+                PLATFORMS='amd64 arm32 arm64 ia32 ia64 mips32 mips32eb ppc32 riscv64 sparc64'
         else
-                PLATFORMS=("$1")
+                PLATFORMS="$1"
         fi
         
@@ -113 +114 @@
         fi
 
-        for i in "${PLATFORMS[@]}"
+        for i in $PLATFORMS
         do
                 PLATFORM="$i"
@@ -120 +121 @@
 
                 echo "== $PLATFORM =="
-                test_app_version "Binutils" "ld" "GNU\ ld\ \(GNU\ Binutils\)\ ((\.|[0-9])+)" "$BINUTILS_VERSION"
-                test_app_version "GCC" "gcc" "gcc\ version\ ((\.|[0-9])+)" "$GCC_VERSION"
-                test_app_version "GDB" "gdb" "GNU\ gdb\ \(GDB\)\s+((\.|[0-9])+)" "$GDB_VERSION"
+                test_app_version "Binutils" "ld" "GNU ld (.*) \([.0-9]*\)" "$BINUTILS_VERSION"
+                test_app_version "GCC" "gcc" "gcc version \([.0-9]*\)" "$GCC_VERSION"
+                test_app_version "GDB" "gdb" "GNU gdb (.*)[[:space:]]\+\([.0-9]*\)" "$GDB_VERSION"
         done
 
@@ -139 +140 @@
                 echo "- $PKGNAME is missing"
         else
-                {
-                        OUT=$(${APP} -v 2>&1)
-                } &> /dev/null
-
-                if [[ "$OUT" =~ $REGEX ]]; then
-                VERSION="${BASH_REMATCH[1]}"
-                if [ "$INS_VERSION" = "$VERSION" ]; then
-                        echo "+ $PKGNAME is uptodate ($INS_VERSION)"
-                else
-                        echo "- $PKGNAME ($VERSION) is outdated ($INS_VERSION)"
-                fi
-            else
-                echo "- $PKGNAME Unexpected output"
-            fi
+                VERSION=`${APP} -v 2>&1 | sed -n "s:^${REGEX}.*:\1:p"`
+
+                if [ -z "$VERSION" ]; then
+                        echo "- $PKGNAME Unexpected output"
+                        return 1
+                fi
+
+                if [ "$INS_VERSION" = "$VERSION" ]; then
+                        echo "+ $PKGNAME is uptodate ($INS_VERSION)"
+                else
+                        echo "- $PKGNAME ($VERSION) is outdated ($INS_VERSION)"
+                fi
         fi
 }
@@ -159 +158 @@
 
 change_title() {
-        echo -en "\e]0;$1\a"
+        printf "\e]0;$1\a"
 }
 
@@ -170 +169 @@
         fi
 
-        echo -n "${TM} "
+        printf "${TM} "
         change_title "${TM}"
         sleep 1
@@ -221 +220 @@
         OUTSIDE="$1"
         BASE="$2"
-        ORIGINAL="`pwd`"
+        ORIGINAL="$PWD"
+
+        cd "${BASE}"
+        check_error $? "Unable to change directory to ${BASE}."
+        ABS_BASE="$PWD"
+        cd "${ORIGINAL}"
+        check_error $? "Unable to change directory to ${ORIGINAL}."
 
         mkdir -p "${OUTSIDE}"
-
         cd "${OUTSIDE}"
         check_error $? "Unable to change directory to ${OUTSIDE}."
-        ABS_OUTSIDE="`pwd`"
-
-        cd "${BASE}"
-        check_error $? "Unable to change directory to ${BASE}."
-        ABS_BASE="`pwd`"
+
+        while [ "${#PWD}" -gt "${#ABS_BASE}" ]; do
+                cd ..
+        done
+
+        if [ "$PWD" = "$ABS_BASE" ]; then
+                echo
+                echo "CROSS_PREFIX cannot reside within the working directory."
+
+                exit 5
+        fi
 
         cd "${ORIGINAL}"
         check_error $? "Unable to change directory to ${ORIGINAL}."
-
-        BASE_LEN="${#ABS_BASE}"
-        OUTSIDE_TRIM="${ABS_OUTSIDE:0:${BASE_LEN}}"
-
-        if [ "${OUTSIDE_TRIM}" == "${ABS_BASE}" ] ; then
-                echo
-                echo "CROSS_PREFIX cannot reside within the working directory."
-
-                exit 5
-        fi
 }
 
@@ -275 +275 @@
                 "arm32")
                         GNU_ARCH="arm"
+                        ;;
+                "arm64")
+                        GNU_ARCH="aarch64"
                         ;;
                 "ia32")
@@ -341 +344 @@
                 mkdir -p "${WORKDIR}/sysroot/include"
                 mkdir "${WORKDIR}/sysroot/lib"
+                ARCH="$PLATFORM"
+                if [ "$ARCH" = "mips32eb" ]; then
+                        ARCH=mips32
+                fi
+
                 cp -r -L -t "${WORKDIR}/sysroot/include" \
                         ${SRCDIR}/../abi/include/* \
-                        ${SRCDIR}/../uspace/lib/c/arch/${PLATFORM}/include/* \
+                        ${SRCDIR}/../uspace/lib/c/arch/${ARCH}/include/* \
                         ${SRCDIR}/../uspace/lib/c/include/*
                 check_error $? "Failed to create build sysroot."
@@ -497 +505 @@
                 test_version
                 ;;
-        amd64|arm32|ia32|ia64|mips32|mips32eb|ppc32|riscv64|sparc64)
+        amd64|arm32|arm64|ia32|ia64|mips32|mips32eb|ppc32|riscv64|sparc64)
                 prepare
                 build_target "$1"
@@ -505 +513 @@
                 build_target "amd64"
                 build_target "arm32"
+                build_target "arm64"
                 build_target "ia32"
                 build_target "ia64"
@@ -517 +526 @@
                 build_target "amd64"
                 build_target "arm32"
+                build_target "arm64"
                 build_target "ia32"
                 build_target "ia64"
@@ -528 +538 @@
                 build_target "amd64" &
                 build_target "arm32" &
+                build_target "arm64" &
                 build_target "ia32" &
                 build_target "ia64" &
@@ -543 +554 @@
                 wait
 
+                build_target "arm64" &
                 build_target "ia32" &
+                wait
+
                 build_target "ia64" &
+                build_target "mips32" &
                 wait
 
-                build_target "mips32" &
                 build_target "mips32eb" &
+                build_target "ppc32" &
                 wait
 
-                build_target "ppc32" &
                 build_target "riscv64" &
-                wait
-
                 build_target "sparc64" &
                 wait

tools/travis.sh

@@ -52 +52 @@
 arm32/integratorcp:arm-helenos:image.boot
 arm32/raspberrypi:arm-helenos:uImage.bin
+arm64/virt:aarch64-helenos:image.iso
 ia32:i686-helenos:image.iso
 ia64/i460GX:ia64-helenos:image.boot
@@ -86 +87 @@
     echo "Will try to run C style check."
     echo
-    make ccheck || exit 1
+    cd tools
+    ./build-ccheck.sh || exit 1
+    cd ..
+    tools/ccheck.sh || exit 1
     echo "C style check passed."
     exit 0
@@ -153 +157 @@
     fi
 
-
     # Build it
-    make "PROFILE=$H_ARCH" HANDS_OFF=y || exit 1
-    test -s "$H_OUTPUT_FILENAME" || exit 1
+    SRCDIR="$PWD"
+
+    mkdir -p build/$H_ARCH || exit 1
+    cd build/$H_ARCH
+
+    export PATH="/usr/local/cross/bin:$PATH"
+
+    $SRCDIR/configure.sh $H_ARCH || exit 1
+    ninja || exit 1
+    ninja image_path || exit 1
+
+    cd $SRCDIR
 
     echo
@@ -185 +198 @@
             ) >hsct.conf || exit 1
 
-            "$HOME/helenos-harbours/hsct.sh" init "$H_HELENOS_HOME" || exit 1
+            "$HOME/helenos-harbours/hsct.sh" init "$H_HELENOS_HOME" $H_ARCH || exit 1
 
             # We cannot flood the output as Travis has limit of maximum output size

tools/xcw/bin/helenos-cc

@@ -32 +32 @@
 #
 
+
+
 XCW="$(dirname "$0")"
 SRC_ROOT="$XCW/../../.."
 if [ -z "$EXPORT_DIR" ]; then
-        EXPORT_DIR="$SRC_ROOT/uspace/export"
+        EXPORT_DIR="$SRC_ROOT/build/dist"
 fi
-UARCH="$("$XCW"/helenos-bld-config --uarch)"
-CC="$("$XCW"/helenos-bld-config --cc)"
-CFLAGS="$("$XCW"/helenos-bld-config --cflags)"
-ENDIAN="$("$XCW"/helenos-bld-config --endian)"
 
-echo helenos-cc "$@"
-"$CC" \
-    -O3 -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32LE -finput-charset=UTF-8 \
-    $CFLAGS \
-    -Wall -Wextra -Wno-clobbered -Wno-unused-parameter -Wmissing-prototypes \
-    -std=gnu99 -Werror-implicit-function-declaration -Wwrite-strings -ggdb \
-    -fno-omit-frame-pointer \
-    -D "$ENDIAN" \
-    "$@" \
-    -I"$XCW"/../include \
-    -I"$EXPORT_DIR"/include/libc \
-    -I"$EXPORT_DIR"/include
+HELENOS_EXPORT_ROOT="$EXPORT_DIR"
+
+source "${EXPORT_DIR}/config/config.sh"
+
+# CC is a compilation driver, so we should check which stage of compilation
+# is actually running and select which flags to provide. This makes no
+# difference for GCC, but e.g. clang warns when a flag is provided that is
+# unused
+
+needs_cflags=true
+needs_ldflags=true
+
+for flag in "$@"; do
+        case "$flag" in
+                -E)
+                        needs_cflags=false
+                        needs_ldflags=false
+                        break
+                        ;;
+                -c|-S)
+                        needs_ldflags=false
+                        break
+                        ;;
+        esac
+done
+
+flags="-fwide-exec-charset=UTF-32LE -finput-charset=UTF-8 -fexec-charset=UTF-8"
+flags="$flags -isystem ${HELENOS_EXPORT_ROOT}/include/libc -idirafter ${HELENOS_EXPORT_ROOT}/include"
+
+if $needs_cflags; then
+        flags="$flags -O3 \
+            -Wall -Wextra -Wno-clobbered -Wno-unused-parameter -Wmissing-prototypes \
+            -std=gnu99 -Werror-implicit-function-declaration -Wwrite-strings -ggdb"
+
+        flags="$flags $HELENOS_CFLAGS"
+fi
+
+if $needs_ldflags; then
+        flags="$flags $HELENOS_LDFLAGS"
+fi
+
+flags="$flags $@"
+
+if $needs_ldflags; then
+        flags="$flags $HELENOS_LDLIBS"
+fi
+
+echo "helenos-cc" "$@"
+PATH="$HELENOS_CROSS_PATH:$PATH" "${HELENOS_TARGET}-gcc" $flags

tools/xcw/bin/helenos-pkg-config

@@ -34 +34 @@
 XCW="$(dirname "$0")"
 SRC_ROOT="$XCW/../../.."
-UARCH="$("$XCW"/helenos-bld-config --uarch)"
 if [ -z "$EXPORT_DIR" ]; then
-        EXPORT_DIR="$SRC_ROOT/uspace/export"
+        EXPORT_DIR="$SRC_ROOT/build/dist"
 fi
 INCLUDE_DIR="$EXPORT_DIR/include"

tools/xcw/demo/Makefile

@@ -57 +57 @@
 
 $(output): $(objects)
-        $(LD) -o $@ $^ $(LIBS)
+        $(CC) -o $@ $^ $(LIBS)
 
 %.o: %.c