Write defines into a disk file instead of passing 100s of them on the command line directly. Fixes some issues with build commands on my machine, and makes it a lot easier to view the make VERBOSE=1 output.

Switch mbed-baremetal and mbed-os to be OBJECT libraries. Can reuse the existing create_distro function for this.

update to mbed_generate_bin_hex cmake function

Merge pull request #15126 from multiplemonomials/create-distro-reborn ...

mbed_create_distro() reborn: a function to make adding multiple targets easy

remove comment for renaming mapfile

remove comment

update comment on custom command

Revert "update README for new CMake version" ...

This reverts commit d4062f5.

Revert "Merge branch 'fix-memmap-diff'" ...

This reverts commit 3d22c88.

One more debug message

replace file(copy by cmake -E copy

Remove debug messages

Whoops, add license header

Add mbed-create-distro

update README for new CMake version

Merge branch 'fix-memmap-diff'

copy map file to .old before creating new one

CMake: Fix escaping of quotes in response file ...

We put macros in a response file compile_time_defs.txt and pass it
to the compiler. Adding a pair of single quotes around each -D flag
ensures macro values are quoted correctly.

For example,
* String
  * target_compile_definitions(): either FOO="BAR" or FOO=\"BAR\"
  * response file: '-DFOO="BAR"'
  * actual definition: #define FOO "BAR"
* Array of integers
  * target_compile_definitions(): FOO={1, 2, 3}
  * response file: '-DFOO={1, 2, 3}'
  * actual definition: #define FOO {1, 2, 3}

CMake: tests: Support skipping a test with a reason ...

Add a new argument `TEST_SKIPPED` to `mbed_greentea_add_test()` to
indicate a test is skipped and give a reason (e.g. the Mbed target
and/or configuration does not provide what the test requires).

The skip reason of a test is printed when running tests with `ctest`,
and the test is marked as "Skipped" in the test report.

cmake: Improve indentation of mbed_greentea_add_test doc

CMake: turn mbed_greentea_add_test() into a function ...

Unlike a macro, a function is more self-contained and can return
early if necessary.

CMake: greentea: Use more specific name for baremetal option ...

Make it obvious the option is used for greentea tests.

CMake: greentea: Port mbed-drivers-ticker to CTest ...

Call add_test in mbed_greentea_add_test and specify mbedhtrun as the
command to run.

An MBED_HTRUN_ARGUMENTS variable has been added, which is a semicolon
separated list of arguments to forward to htrun. The user is required to
pass in any arguments mbedhtrun needs to communicate with the device
under test at CMake configuration time.

We automate passing some of the htrun arguments in CMake using data
provided by mbed_config.cmake or gathered from the CMake environment.
The following arguments are passed to htrun from CMake:

* -f/--image-path
* -e/--enum-host-tests
* -m/--micro
* -R/--reset-timeout

--baud-rate is also passed if the MBED_CONF_PLATFORM_STDIO_BAUD_RATE
config parameter is defined.

Temporary checks have been added to mbed_greentea_add_test to keep the
old flow working until we port all of the greentea tests to CTest. These
checks should be removed after we make all greentea tests runnable by
CTest.

CMake: Do not set `CMAKE_AR` ...

The variable for archiver is automatically set by CMake. There is
no need to explicitly set it, unless a project really needs to
override the default archiver.

CMake: Enable improved armclang support in CMake 3.21 ...

CMake versions 3.20 and below always add compiler and linker flags
based on `CMAKE_SYSTEM_PROCESSOR`, for example `--cpu=Cortex-M33`.
This sometimes overrides flags we set in tools/cmake/cores/*.cmake
and results in link failure or unbootable binaries. To workaround
this, we added more linker flags to "counter" what CMake automatically
adds.

From CMake 3.21 onwards, CMake by default does not add flags to
armclang anymore, and it fully relies on projects to set all flags.
In this case we do not need to set `CMAKE_SYSTEM_PROCESSOR` or use
workarounds anymore. We still turn on workarounds when an older
version of CMake (3.19 and 3.20) is used, but in the future we might
require users to have at least CMake 3.21.

CMake: Cortex-A: Use MBED_CPU_CORE to set -mcpu ...

As we're moving away from the use of CMAKE_SYSTEM_PROCESSOR, use
MBED_CPU_CORE instead. They differ in cases, but both GCC and Arm
toolchains support case-insensitive CPU names.

CMake: Add test for multiple-executable support ...

Add a test to build two executables in two directories under a single
project.

Rework post-build to support multiple executables ...

When building greentea tests, each test is an executable with its
own output binary path. This is also the case when a user project
produces multiple executables. But the current implementation of
post-build operations always assumes there's only one executable,
at the root of the build directory.

The post-build command depends on Mbed target, and it always takes
the the executable we build as an input file. To achieve this, we
let each Mbed target (that has a post-build command) define a function

    function(mbed_post_build_function target)

which takes a CMake executable target as an argument from which it can
get its binary path using generator expressions. It generates and adds
to the passed executable target a post-build custom command.

Notes:
* The function name needs to be exact, because CMake only supports
literal function calls - CMake can't dereference a function name from
a variable. To avoid multiple definitions of this function, each Mbed
target needs to guard it with a macro to check if the user is
building this Mbed target.
* `mbed_post_build_function()` is a function, but it is usually
defined by another macro rather than a parent function, because
nesting functions would make many variables inaccessible inside the
innermost `mbed_post_build_function()`.
* There's no more need to force regenerate images. Previously, post-
build commands were custom *targets* which always got to run, so we
force regenerated images on every build to avoid patching an image
that's already been patched once on previous build. Now post-build
commands are custom *commands* of the same executable target, and they
are only run if the executable target itself is rebuilt.

CMake: Move post build functions out of root CMakeLists.txt ...

The 'post build' functions are made visible by adding the mbed-os
subdirectory. This is not ideal as any components in mbed-os wishing to
call the functions must be added after the functions are defined. To
improve modularity move these functions to a separate CMake script.

We include the post build CMake script in app.cmake for now so we don't
break user's projects.

python: Allow newer prettytable with newer python ...

This helps to allow installation of Mbed OS's Python requirements, when
CMake is used, into the same Python environment as mbed-os-tools. The
versions specified here are aligned with mbed-os-tools;
tools/cmake/requirements.txt depends on the same version of prettytable
as mbed-os-tools's requirements.txt.