Modern versions of GDB support multiple targets with the same gdb binary.
At least Ubuntu and Debian have dropped the gdb-arm-none-eabi package in favour
of gdb-multiarch.
Here, no $(PREFIX)-gdb binary is availiable, instead gdb-multiarch should be used.

This patch tries to automatically detect the presense of gdb-multiarch and uses it
instead of arm-none-eabi-gdb.

This currently does nothing but setting FLASHFILE when flashing.
This will allow passing the variable when flasher will use the FLASHFILE
variable.

Using 'link' was working too but will introduce a circular dependency
when FLASHFILE is one of the slot files.

This trims down to the minimal required dependency to work. It is now
the same as `ELFFILE` dependencies.

If FLASHFILE is set keep the original value.

It changes the variable from an immediate to a deferred variable but if
murdocks keeps working there is no issue.

The CPU variable in the boards Makefile.include file already contains the target
CPU, so there is no reason to provide it in each board again as avrdude flag.

This commit automatically sets the avrdude target from the CPU variable and
removes the unneeded flags.

Currently the flag "-P ${PORT}" is added to avrdude regardless of the programmer
used. But this flag should only be set for programmers that operate over a
serial port - e.g. like the various Arduino bootloaders. This commit changes
the behaviour so that the "-P flag" is only set for only of the default
programmers of the various AVR boards supported by RIOT. This allows to use
ICSP programmers (e.g. like the usbtiny) like this:

    make BOARD=arduino-uno PROGRAMMER=usbtiny

Introduce FLASHFILE variable to start migrating boards to use it.

This is the file that will be used for flashing.
Boards do not currently use it but will migrated in upcoming PRs.

Due to a recent fix in shell.c, remote echo is now working as originally
intended. Local echo must be disabled or otherwise it will add up to the
remote one, causing a character-by-character double echoing.

TERMPROG and TERMFLAGS variables do not need to be exported as they are
used directly by a make receipe.

Exporting them prevents overwriting 'RIOT_TERMINAL' in the test.

TERMPROG and TERMFLAGS variables do not need to be exported as they are
used directly by a make receipe.

Exporting them prevents overwriting 'RIOT_TERMINAL' in the test.

Allows to use avrdude as a flashing tool in any context
(e.g. not dependent on arduino or atmega) though it only
works (AFAIK) on atmega, but I thought it's better to
have it here as we have other flashing tools.

`command -v first second third` only works in `bash` and not in `sh`.
So replace with multiple calls to `command`.

This fixes using `objcopy` when the toolchain `objcopy` is not available.

It is only used by `Makefile.include` and should not be used by sub-make
instances.

This is required to prevent evaluating `LINKFLAGS` when not needed and a
required step to not evaluate it on the host with for example `avr-ld`
when building in docker.

I checked usage with:

    git grep -e '(LINKFLAGS)' -e '{LINKFLAGS}'

Packages may be using it but `LINKFLAGS` is a RIOT way of naming
things and even if `generate-xcompile-toolchain` uses `LINK` it does not
use `LINKFLAGS`.

arm-gcc version from ubuntu bionic repository is not supported in RIOT.
Both when building with `gnu` and `llvm`.

    arm-none-eabi-gcc --version
    arm-none-eabi-gcc (15:6.3.1+svn253039-1build1) 6.3.1 20170620

So detect this version and print an error if found.

The check is done on the building machine and not on the host when building in
docker.

The error can be disabled when building with WERROR=0.

The 'build' directory should be created before starting docker.
If not it will be created as root.

Also add mapping for the directory in docker.

Currently create the directory in the target until there is a directory
creation target.

This introduces a new environment variable for a common directory
that holds all output of the build process, such as application or
package binaries. This would also allow to easily redirect output
to any other location, e.g. for out-of-source builds.

By erasing slot 1 header the slot gets invalidated.
This is very useful while debugging, since we can
force the bootloader to ignore anything on that
slot.

riotboot looks for valid, available slots and compares its
version. The slot with the highest version is booted, otherwise
if no valid slot is found it loops on `while(1);`

riotboot is introduced here and makes use of riotboot_hdr,
which indentifies the images encapsulated as slots.
The slot size and offset is configurable, which makes
slots extendable if needed, e.g. 2 or more slots can be
transparently added.

Co-authored-by: Kaspar Schleiser <kaspar@schleiser.de>
Co-authored-by: Gaëtan Harter <gaetan.harter@fu-berlin.de>

make -f test-checks.mk test-ensure_value should succeed, while
make -f test-checks.mk test-ensure_value-negative should fail.

A call to `$(ensure_value x,y)` will fail with message y if x is empty, and
otherwise return x. This can be useto write more compact makefiles, while still
producing friendly error messages.

Mounting `/etc/localtime` directly does not work on macOS (anymore).
However, by resolving the symlink to its real path docker can handle
the mount.

When doing `make -j clean all' the directories can be cleaned after
files are made. To ensure files are created after clean, those targets
are made conditionally dependent on the clean target.

This copies the handling done in Makefile.include.

Get FLASH_FILE and ELFFILE from command line instead of environment variable.

The documentation was claiming ELFFILE was given as a command line argument
already, but is was not.

To keep Makefile.include clean and to be consistent with other tools,
the Eclipse IDE support is put in a separate file.

riotboot_hdr enables to partition the internal flash memory
into "slots", each one with a header providing information
about the partition. The concept for now is limited to
firmware partitions, which are recognised by the riotboot
bootloader. In the future the concept might be extended to
represent other content.

Co-authored-by: Kaspar Schleiser <kaspar@schleiser.de>

Get BINFILE and ELFFILE from command line instead of environment variable.

Rename 'HEXFILE' to 'BINFILE' in the script as the binary file is used.
The documentation was already talking about 'BINFILE' but 'BINFILE'
was never exported by the build system and it was using 'HEXFILE' in the
implementation.

USEMODULE += crypto_aes_precalculated enables the precalculated T tables (the old
code).
USEMODULE += crypto_aes_unroll causes loops to be unrolled.

This makes doing 'scan-build-analyze' produce an error at execution if
WERROR=1.

When used from `scan-build` it will not procude an error to display the result
webpage.

This correctly defines a `scan-build-analyze` target that does not display the
result webpage.

`scan-build-view` has now been moved to a private target as should not
be used directly.

The handling of displaying the page on the host system and implementing
'scan-build-analyze' are now explicitely done with separate targets and
not double implemented target when in docker or on the host that were executed
twice with different implementations.