From 9bad1f38e8f0a105f464b93490d79fb636d4a1a0 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Fri, 21 May 2021 21:34:58 +0200
Subject: [PATCH 01/20] scripts: gen_handles.py: take device start symbol as
 argument.

The current gen_handles.py script uses linker defined symbols.
As preparation for support of more linkers the gen_tables.py now takes
the device start symbol as argument.

For example, armlink and ld uses different symbols.
With ld those can be named explicitly, but for armlink the linker
decides the names.

For ld, Zephyr defines: __device_start
For armlink, the symbol is defined as: Image$$<section name>$$Base

Therefore knowledge of the linker symbol to be used must be passed to
gen_handles.py so that the correct symbol can be used for locating
devices.

To support this change, the creation of the asm, compiler, compiler-cpp,
linker targets has been moved from target_toolchain_flags.cmake to
target_toolchain.cmake.

All linkers has been updated to support the use of the
device_start_symbol on the linker target.

List of linkers updated:
- ld
- lld
- arcmwdt

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 CMakeLists.txt                     |  1 +
 cmake/linker/arcmwdt/target.cmake  |  1 +
 cmake/linker/ld/target.cmake       |  1 +
 cmake/linker/lld/target.cmake      |  1 +
 cmake/target_toolchain.cmake       |  6 ++++++
 cmake/target_toolchain_flags.cmake |  6 ------
 scripts/gen_handles.py             | 14 ++++++++++----
 7 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59f861039eb22c..4a41792546da67 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -795,6 +795,7 @@ if(CONFIG_HAS_DTS)
     --output-source dev_handles.c
     --kernel $<TARGET_FILE:${ZEPHYR_PREBUILT_EXECUTABLE}>
     --zephyr-base ${ZEPHYR_BASE}
+    --start-symbol "$<TARGET_PROPERTY:linker,devices_start_symbol>"
     DEPENDS ${ZEPHYR_PREBUILT_EXECUTABLE}
     )
   set_property(GLOBAL APPEND PROPERTY GENERATED_KERNEL_SOURCE_FILES dev_handles.c)
diff --git a/cmake/linker/arcmwdt/target.cmake b/cmake/linker/arcmwdt/target.cmake
index 4675f9344d5cd1..9c0a6271e08f1a 100644
--- a/cmake/linker/arcmwdt/target.cmake
+++ b/cmake/linker/arcmwdt/target.cmake
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+set_property(TARGET linker PROPERTY devices_start_symbol "__device_start")
 
 find_program(CMAKE_LINKER ${CROSS_COMPILE}lldac PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
 
diff --git a/cmake/linker/ld/target.cmake b/cmake/linker/ld/target.cmake
index 571964fcbe9345..2bef796673f01c 100644
--- a/cmake/linker/ld/target.cmake
+++ b/cmake/linker/ld/target.cmake
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+set_property(TARGET linker PROPERTY devices_start_symbol "__device_start")
 
 if(DEFINED TOOLCHAIN_HOME)
   # When Toolchain home is defined, then we are cross-compiling, so only look
diff --git a/cmake/linker/lld/target.cmake b/cmake/linker/lld/target.cmake
index a4d0b2f915d136..6aca2d6f35bc01 100644
--- a/cmake/linker/lld/target.cmake
+++ b/cmake/linker/lld/target.cmake
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+set_property(TARGET linker PROPERTY devices_start_symbol "__device_start")
 
 find_program(CMAKE_LINKER     ld.lld )
 
diff --git a/cmake/target_toolchain.cmake b/cmake/target_toolchain.cmake
index 1edb6385172819..0d8bbc2d32d0ca 100644
--- a/cmake/target_toolchain.cmake
+++ b/cmake/target_toolchain.cmake
@@ -32,6 +32,12 @@ set(CMAKE_SYSTEM_VERSION ${PROJECT_VERSION})
 # We are not building dynamically loadable libraries
 set(BUILD_SHARED_LIBS OFF)
 
+# Custom targets for compiler and linker flags.
+add_custom_target(asm)
+add_custom_target(compiler)
+add_custom_target(compiler-cpp)
+add_custom_target(linker)
+
 if(NOT (COMPILER STREQUAL "host-gcc"))
   include(${TOOLCHAIN_ROOT}/cmake/toolchain/${ZEPHYR_TOOLCHAIN_VARIANT}/target.cmake)
 endif()
diff --git a/cmake/target_toolchain_flags.cmake b/cmake/target_toolchain_flags.cmake
index b74c3e787220cc..35c1fb08f4f698 100644
--- a/cmake/target_toolchain_flags.cmake
+++ b/cmake/target_toolchain_flags.cmake
@@ -24,12 +24,6 @@ set(TOOLCHAIN_SIGNATURE ${CMAKE_C_COMPILER_MD5_SUM})
 string(MD5 COMPILER_SIGNATURE ${CMAKE_C_COMPILER}_${CMAKE_C_COMPILER_ID}_${CMAKE_C_COMPILER_VERSION})
 set(TOOLCHAIN_SIGNATURE ${TOOLCHAIN_SIGNATURE}_${COMPILER_SIGNATURE})
 
-# Custom targets for compiler and linker flags.
-add_custom_target(asm)
-add_custom_target(compiler)
-add_custom_target(compiler-cpp)
-add_custom_target(linker)
-
 # Loading of templates are strictly not needed as they does not set any
 # properties.
 # They purely provides an overview as well as a starting point for supporting
diff --git a/scripts/gen_handles.py b/scripts/gen_handles.py
index 441ad6419a4580..c8354d9ec8385b 100755
--- a/scripts/gen_handles.py
+++ b/scripts/gen_handles.py
@@ -73,6 +73,11 @@ def parse_args():
                         is not provided the environment will be checked for \
                         the ZEPHYR_BASE environment variable.")
 
+    parser.add_argument("-s", "--start-symbol", required=True,
+                        help="Symbol name of the section which contains the \
+                        devices. The symbol name must point to the first \
+                        device in that section.")
+
     args = parser.parse_args()
     if "VERBOSE" in os.environ:
         args.verbose = 1
@@ -145,7 +150,7 @@ def obj_handles(self):
             else:
                 format += "Q"
                 size = 8
-            offset = self.ld_constants["DEVICE_STRUCT_HANDLES_OFFSET"]
+            offset = self.ld_constants["_DEVICE_STRUCT_HANDLES_OFFSET"]
             self.__handles = struct.unpack(format, data[offset:offset + size])[0]
         return self.__handles
 
@@ -172,7 +177,8 @@ def main():
     devices = []
     handles = []
     # Leading _ are stripped from the stored constant key
-    want_constants = set(["__device_start",
+
+    want_constants = set([args.start_symbol,
                           "_DEVICE_STRUCT_SIZEOF",
                           "_DEVICE_STRUCT_HANDLES_OFFSET"])
     ld_constants = dict()
@@ -181,7 +187,7 @@ def main():
         if isinstance(section, SymbolTableSection):
             for sym in section.iter_symbols():
                 if sym.name in want_constants:
-                    ld_constants[sym.name.lstrip("_")] = sym.entry.st_value
+                    ld_constants[sym.name] = sym.entry.st_value
                     continue
                 if sym.entry.st_info.type != 'STT_OBJECT':
                     continue
@@ -204,7 +210,7 @@ def main():
 
     devices = sorted(devices, key = lambda k: k.sym.entry.st_value)
 
-    device_start_addr = ld_constants["device_start"]
+    device_start_addr = ld_constants[args.start_symbol]
     device_size = 0
 
     assert len(devices) == len(handles), 'mismatch devices and handles'

From 7a2a9a8e4763ba6ccc2100c9f6dfb744a56a3e52 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Tue, 20 Apr 2021 13:53:55 +0200
Subject: [PATCH 02/20] asm: .eabi_attribute Tag_ABI_align_preserved, 1

Tell armlink that files has ensured proper stack alignment.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 arch/arm/core/aarch32/cortex_m/vector_table.S | 4 ++++
 arch/arm/core/aarch32/isr_wrapper.S           | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/arch/arm/core/aarch32/cortex_m/vector_table.S b/arch/arm/core/aarch32/cortex_m/vector_table.S
index 8dcd4e06417922..d73aabdcb544ec 100644
--- a/arch/arm/core/aarch32/cortex_m/vector_table.S
+++ b/arch/arm/core/aarch32/cortex_m/vector_table.S
@@ -22,6 +22,10 @@
 #include "vector_table.h"
 
 _ASM_FILE_PROLOGUE
+/*
+ * Tell armclang that stack alignment are ensured.
+ */
+.eabi_attribute Tag_ABI_align_preserved, 1
 
 GDATA(z_main_stack)
 
diff --git a/arch/arm/core/aarch32/isr_wrapper.S b/arch/arm/core/aarch32/isr_wrapper.S
index f62ad0fc1b634d..0f60ade2ca36c8 100644
--- a/arch/arm/core/aarch32/isr_wrapper.S
+++ b/arch/arm/core/aarch32/isr_wrapper.S
@@ -12,6 +12,10 @@
  * Wrapper installed in vector table for handling dynamic interrupts that accept
  * a parameter.
  */
+/*
+ * Tell armclang that stack alignment are ensured.
+ */
+.eabi_attribute Tag_ABI_align_preserved, 1
 
 #include <toolchain.h>
 #include <linker/sections.h>

From db796aff9cecae6037f083c2d8079ffa5afb268c Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 10 Jun 2021 13:18:36 +0200
Subject: [PATCH 03/20] cmake: CMake linker functions implemented

This commit introduces zephyr_linker CMake functions for creation of
linker scripts.

The linker functions supports the following features:
- Configuration of memory sections
- Configuration of memory groups
- Creation of output sections
- Configuration of input section the should go into output section and
  how those should be treated, such as sorting, keep, priority.
- Defining linker symbols
- Specifying Kernel VMA to support virtual linking on x86

Overview of functions and macros introduce with this commit:
- pow2round
- zephyr_linker
- zephyr_linker_memory
- zephyr_linker_memory_ifdef
- zephyr_linker_group
- zephyr_linker_section
- zephyr_linker_section_ifdef
- zephyr_iterable_section
- zephyr_linker_section_obj_level
- zephyr_linker_section_configure
- zephyr_linker_symbol
- zephyr_linker_property_append

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/extensions.cmake | 649 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 649 insertions(+)

diff --git a/cmake/extensions.cmake b/cmake/extensions.cmake
index 9fe246f31ee47c..be85fdedc4bbab 100644
--- a/cmake/extensions.cmake
+++ b/cmake/extensions.cmake
@@ -21,6 +21,8 @@
 # 3.5. File system management
 # 4. Devicetree extensions
 # 4.1 dt_*
+# 5. Zephyr linker functions
+# 5.1. zephyr_linker*
 
 ########################################################
 # 1. Zephyr-aware extensions
@@ -1248,6 +1250,38 @@ function(check_dtc_flag flag ok)
   endif()
 endfunction()
 
+# Function to round number to next power of two.
+#
+# Usage:
+#   pow2round(<variable>)
+#
+# Example:
+# set(test 2)
+# pow2round(test)
+# # test is still 2
+#
+# set(test 5)
+# pow2round(test)
+# # test is now 8
+#
+# Arguments:
+# n   = Variable containing the number to round
+function(pow2round n)
+  math(EXPR x "${${n}} & (${${n}} - 1)")
+  if(${x} EQUAL 0)
+    return()
+  endif()
+
+  math(EXPR ${n} "${${n}} | (${${n}} >> 1)")
+  math(EXPR ${n} "${${n}} | (${${n}} >> 2)")
+  math(EXPR ${n} "${${n}} | (${${n}} >> 4)")
+  math(EXPR ${n} "${${n}} | (${${n}} >> 8)")
+  math(EXPR ${n} "${${n}} | (${${n}} >> 16)")
+  math(EXPR ${n} "${${n}} | (${${n}} >> 32)")
+  math(EXPR ${n} "${${n}} + 1")
+  set(${n} ${${n}} PARENT_SCOPE)
+endfunction()
+
 ########################################################
 # 2. Kconfig-aware extensions
 ########################################################
@@ -2809,3 +2843,618 @@ function(dt_chosen var)
     set(${var} ${${var}} PARENT_SCOPE)
   endif()
 endfunction()
+
+########################################################
+# 5. Zephyr linker function
+########################################################
+# 5.1. zephyr_linker*
+#
+# The following methods are for defining linker structure using CMake functions.
+#
+# This allows Zephyr developers to define linker sections and their content and
+# have this configuration rendered into an appropriate linker script based on
+# the toolchain in use.
+# For example:
+# ld linker scripts with GNU ld
+# ARM scatter files with ARM linker.
+#
+# Example usage:
+# zephyr_linker_section(
+#   NAME my_data
+#   VMA  RAM
+#   LMA  FLASH
+# )
+#
+# and to configure special input sections for the section
+# zephyr_linker_section_configure(
+#   SECTION my_data
+#   INPUT   "my_custom_data"
+#   KEEP
+# )
+
+
+# Usage:
+#   zephyr_linker([FORMAT <format>]
+#     [ENTRY <entry symbol>]
+#   )
+#
+# Zephyr linker general settings.
+# This function specifies general settings for the linker script to be generated.
+#
+# FORMAT <format>:            The output format of the linked executable.
+# ENTRY <entry symbolformat>: The code entry symbol.
+#
+function(zephyr_linker)
+  set(single_args "ENTRY;FORMAT")
+  cmake_parse_arguments(LINKER "" "${single_args}" "" ${ARGN})
+
+  if(LINKER_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "zephyr_linker(${ARGV0} ...) given unknown "
+                        "arguments: ${LINKER_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if(DEFINED LINKER_FORMAT)
+    get_property(format_defined TARGET linker PROPERTY FORMAT SET)
+    if(format_defined)
+      message(FATAL_ERROR "zephyr_linker(FORMAT ...) already configured.")
+    else()
+      set_property(TARGET linker PROPERTY FORMAT ${LINKER_FORMAT})
+    endif()
+  endif()
+
+  if(DEFINED LINKER_ENTRY)
+    get_property(entry_defined TARGET linker PROPERTY ENTRY SET)
+    if(entry_defined)
+      message(FATAL_ERROR "zephyr_linker(ENTRY ...) already configured.")
+    else()
+      set_property(TARGET linker PROPERTY ENTRY ${LINKER_ENTRY})
+    endif()
+  endif()
+endfunction()
+
+# Usage:
+#   zephyr_linker_memory(NAME <name> START <address> SIZE <size> FLAGS <flags>)
+#
+# Zephyr linker memory.
+# This function specifies a memory region for the platform in use.
+#
+# Note:
+#   This function should generally be called with values obtained from
+#   devicetree or Kconfig.
+#
+# NAME <name>    : Name of the memory region, for example FLASH.
+# START <address>: Start address of the memory region.
+#                  Start address can be given as decimal or hex value.
+# SIZE <size>    : Size of the memory region.
+#                  Size can be given as decimal value, hex value, or decimal with postfix k or m.
+#                  All the following are valid values:
+#                    1048576, 0x10000, 1024k, 1024K, 1m, and 1M.
+# FLAGS <flags>  : Flags describing properties of the memory region.
+#                  Currently supported:
+#                  r: Read-only region
+#                  w: Read-write region
+#                  x: Executable region
+#                  The flags r and x, or w and x may be combined like: rx, wx.
+function(zephyr_linker_memory)
+  set(single_args "FLAGS;NAME;SIZE;START")
+  cmake_parse_arguments(MEMORY "" "${single_args}" "" ${ARGN})
+
+  if(MEMORY_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "zephyr_linker_memory(${ARGV0} ...) given unknown "
+                        "arguments: ${MEMORY_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  foreach(arg ${single_args})
+    if(NOT DEFINED MEMORY_${arg})
+      message(FATAL_ERROR "zephyr_linker_memory(${ARGV0} ...) missing required "
+                          "argument: ${arg}"
+      )
+    endif()
+  endforeach()
+
+  set(MEMORY)
+  zephyr_linker_arg_val_list(MEMORY "${single_args}")
+
+  string(REPLACE ";" "\;" MEMORY "${MEMORY}")
+  set_property(TARGET linker
+               APPEND PROPERTY MEMORY_REGIONS "{${MEMORY}}"
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_memory_ifdef(<setting> NAME <name> START <address> SIZE <size> FLAGS <flags>)
+#
+# Will create memory region if <setting> is enabled.
+#
+# <setting>: Setting to check for True value before invoking
+#            zephyr_linker_memory()
+#
+# See zephyr_linker_memory() description for other supported arguments.
+#
+macro(zephyr_linker_memory_ifdef feature_toggle)
+  if(${${feature_toggle}})
+    zephyr_linker_memory(${ARGN})
+  endif()
+endmacro()
+
+# Usage:
+#   zephyr_linker_group(NAME <name> [VMA <region|group>] [LMA <region|group>])
+#   zephyr_linker_group(NAME <name> GROUP <group>)
+#
+# Zephyr linker group.
+# This function specifies a group inside a memory region or another group.
+#
+# The group ensures that all section inside the group are located together inside
+# the specified group.
+#
+# This also allows for section placement inside a given group without the section
+# itself needing the precise knowledge regarding the exact memory region this
+# section will be placed in, as that will be determined by the group setup.
+#
+# Each group will define the following linker symbols:
+# __<name>_start      : Start address of the group
+# __<name>_end        : End address of the group
+# __<name>_size       : Size of the group
+#
+# Note: <name> will be converted to lower casing for linker symbols definitions.
+#
+# NAME <name>         : Name of the group.
+# VMA <region|group>  : VMA Memory region or group to be used for this group.
+#                       If a group is used then the VMA region of that group will be used.
+# LMA <region|group>  : Memory region or group to be used for this group.
+# GROUP <group>       : Place the new group inside the existing group <group>
+#
+# Note: VMA and LMA are mutual exclusive with GROUP
+#
+# Example:
+#   zephyr_linker_memory(NAME memA START ... SIZE ... FLAGS ...)
+#   zephyr_linker_group(NAME groupA LMA memA)
+#   zephyr_linker_group(NAME groupB LMA groupA)
+#
+# will create two groups in same memory region as groupB will inherit the LMA
+# from groupA:
+#
+# +-----------------+
+# | memory region A |
+# |                 |
+# | +-------------+ |
+# | | groupA      | |
+# | +-------------+ |
+# |                 |
+# | +-------------+ |
+# | | groupB      | |
+# | +-------------+ |
+# |                 |
+# +-----------------+
+#
+# whereas
+#   zephyr_linker_memory(NAME memA START ... SIZE ... FLAGS ...)
+#   zephyr_linker_group(NAME groupA LMA memA)
+#   zephyr_linker_group(NAME groupB GROUP groupA)
+#
+# will create groupB inside groupA:
+#
+# +---------------------+
+# | memory region A     |
+# |                     |
+# | +-----------------+ |
+# | | groupA          | |
+# | |                 | |
+# | | +-------------+ | |
+# | | | groupB      | | |
+# | | +-------------+ | |
+# | |                 | |
+# | +-----------------+ |
+# |                     |
+# +---------------------+
+function(zephyr_linker_group)
+  set(single_args "NAME;GROUP;LMA;VMA")
+  cmake_parse_arguments(GROUP "" "${single_args}" "" ${ARGN})
+
+  if(GROUP_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "zephyr_linker_group(${ARGV0} ...) given unknown "
+                        "arguments: ${GROUP_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if(DEFINED GROUP_GROUP AND (DEFINED GROUP_VMA OR DEFINED GROUP_LMA))
+    message(FATAL_ERROR "zephyr_linker_group(GROUP ...) cannot be used with "
+                        "VMA or LMA"
+    )
+  endif()
+
+  set(GROUP)
+  zephyr_linker_arg_val_list(GROUP "${single_args}")
+
+  string(REPLACE ";" "\;" GROUP "${GROUP}")
+  set_property(TARGET linker
+               APPEND PROPERTY GROUPS "{${GROUP}}"
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_section(NAME <name> [GROUP <group>]
+#                         [VMA <region|group>] [LMA <region|group>]
+#                         [ADDRESS <address>] [ALIGN <alignment>]
+#                         [SUBALIGN <alignment>] [FLAGS <flags>]
+#                         [HIDDEN] [NOINPUT] [NOINIT]
+#                         [PASS <no> [<no>...]
+#   )
+#
+# Zephyr linker output section.
+# This function specifies an output section for the linker.
+#
+# When using zephyr_linker_section(NAME <name>) an output section with <name>
+# will be configured. This section will default include input sections of the
+# same name, unless NOINPUT is specified.
+# This means the section named `foo` will default include the sections matching
+# `foo` and `foo.*`
+# Each output section will define the following linker symbols:
+# __<name>_start      : Start address of the section
+# __<name>_end        : End address of the section
+# __<name>_size       : Size of the section
+# __<name>_load_start : Load address of the section, if VMA = LMA then this
+#                       value will be identical to `__<name>_start`
+#
+# The location of the output section can be controlled using LMA, VMA, and
+# address parameters
+#
+# NAME <name>         : Name of the output section.
+# VMA <region|group>  : VMA Memory region or group where code / data is located runtime (VMA)
+#                       If <group> is used here it means the section will use the
+#                       same VMA memory region as <group> but will not be placed
+#                       inside the group itself, see also GROUP argument.
+# KVMA <region|group> : Kernel VMA Memory region or group where code / data is located runtime (VMA)
+#                       When MMU is active and Kernel VM base and offset is different
+#                       from SRAM base and offset, then the region defined by KVMA will
+#                       be used as VMA.
+#                       If <group> is used here it means the section will use the
+#                       same VMA memory region as <group> but will not be placed
+#                       inside the group itself, see also GROUP argument.
+# LMA <region|group>  : Memory region or group where code / data is loaded (LMA)
+#                       If VMA is different from LMA, the code / data will be loaded
+#                       from LMA into VMA at bootup, this is usually the case for
+#                       global or static variables that are loaded in rom and copied
+#                       to ram at boot time.
+#                       If <group> is used here it means the section will use the
+#                       same LMA memory region as <group> but will not be placed
+#                       inside the group itself, see also GROUP argument.
+# GROUP <group>       : Place this section inside the group <group>
+# ADDRESS <address>   : Specific address to use for this section.
+# ALIGN_WITH_INPUT    : The alignment difference between VMA and LMA is kept
+#                       intact for this section.
+# ALIGN <alignment>   : Align the execution address with alignment.
+# SUBALIGN <alignment>: Align input sections with alignment value.
+# ENDALIGN <alignment>: Align the end so that next output section will start aligned.
+#                       This only has effect on Scatter scripts.
+#  Note: Regarding all alignment attributes. Not all linkers may handle alignment
+#        in identical way. For example the Scatter file will align both load and
+#        execution address (LMA and VMA) to be aligned when given the ALIGN attribute.
+# NOINPUT             : No default input sections will be defined, to setup input
+#                       sections for section <name>, the corresponding
+#                       `zephyr_linker_section_configure()` must be used.
+# PASS <no> [<no> ..] : Linker pass iteration where this section should be active.
+#                       Default a section will be present during all linker passes
+#                       But in cases a section shall only be present at a specific
+#                       pass, this argument can be used. For example to only have
+#                       this section present on the first linker pass, use `PASS 1`.
+#
+# Note: VMA and LMA are mutual exclusive with GROUP
+#
+function(zephyr_linker_section)
+  set(options     "ALIGN_WITH_INPUT;HIDDEN;NOINIT;NOINPUT")
+  set(single_args "ADDRESS;ALIGN;ENDALIGN;GROUP;KVMA;LMA;NAME;SUBALIGN;TYPE;VMA")
+  set(multi_args  "PASS")
+  cmake_parse_arguments(SECTION "${options}" "${single_args}" "${multi_args}" ${ARGN})
+
+  if(SECTION_UNPARSED_ARGUMENTS)
+    message(WARNING "zephyr_linker_section(${ARGV0} ...) given unknown "
+                    "arguments: ${SECTION_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if(DEFINED SECTION_GROUP AND (DEFINED SECTION_VMA OR DEFINED SECTION_LMA))
+    message(FATAL_ERROR "zephyr_linker_section(GROUP ...) cannot be used with "
+                        "VMA or LMA"
+    )
+  endif()
+
+  if(DEFINED SECTION_KVMA)
+    # If KVMA is set and the Kernel virtual memory settings reqs are met, we
+    # substitute the VMA setting with the specified KVMA value.
+    if(CONFIG_MMU)
+      math(EXPR KERNEL_MEM_VM_OFFSET
+           "(${CONFIG_KERNEL_VM_BASE} + ${CONFIG_KERNEL_VM_OFFSET})\
+            - (${CONFIG_SRAM_BASE_ADDRESS} + ${CONFIG_SRAM_OFFSET})"
+      )
+
+      if(NOT (${KERNEL_MEM_VM_OFFSET} EQUAL 0))
+        set(SECTION_VMA ${SECTION_KVMA})
+        set(SECTION_KVMA)
+      endif()
+    endif()
+  endif()
+
+  set(SECTION)
+  zephyr_linker_arg_val_list(SECTION "${single_args}")
+  zephyr_linker_arg_val_list(SECTION "${options}")
+  zephyr_linker_arg_val_list(SECTION "${multi_args}")
+
+  string(REPLACE ";" "\;" SECTION "${SECTION}")
+  set_property(TARGET linker
+               APPEND PROPERTY SECTIONS "{${SECTION}}"
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_section_ifdef(<setting>
+#                               NAME <name> [VMA <region>] [LMA <region>]
+#                               [ADDRESS <address>] [ALIGN <alignment>]
+#                               [SUBALIGN <alignment>] [FLAGS <flags>]
+#                               [HIDDEN] [NOINPUT] [NOINIT]
+#                               [PASS <no> [<no>...]
+#   )
+#
+# Will create an output section if <setting> is enabled.
+#
+# <setting>: Setting to check for True value before invoking
+#            zephyr_linker_section()
+#
+# See zephyr_linker_section() description for other supported arguments.
+#
+macro(zephyr_linker_section_ifdef feature_toggle)
+  if(${${feature_toggle}})
+    zephyr_linker_section(${ARGN})
+  endif()
+endmacro()
+
+# Usage:
+#   zephyr_iterable_section(NAME <name> [GROUP <group>]
+#                           [VMA <region|group>] [LMA <region|group>]
+#                           [ALIGN_WITH_INPUT] [SUBALIGN <alignment>]
+#   )
+#
+#
+# Define an output section which will set up an iterable area
+# of equally-sized data structures. For use with Z_STRUCT_SECTION_ITERABLE.
+# Input sections will be sorted by name in lexicographical order.
+#
+# Each list for an input section will define the following linker symbols:
+# _<name>_list_start: Start of the iterable list
+# _<name>_list_end  : End of the iterable list
+#
+# The output section will be named `<name>_area` and define the following linker
+# symbols:
+# __<name>_area_start      : Start address of the section
+# __<name>_area_end        : End address of the section
+# __<name>_area_size       : Size of the section
+# __<name>_area_load_start : Load address of the section, if VMA = LMA then this
+#                            value will be identical to `__<name>_area_start`
+#
+# NAME <name>         : Name of the struct type, the output section be named
+#                       accordingly as: <name>_area.
+# VMA <region|group>  : VMA Memory region where code / data is located runtime (VMA)
+# LMA <region|group>  : Memory region where code / data is loaded (LMA)
+#                       If VMA is different from LMA, the code / data will be loaded
+#                       from LMA into VMA at bootup, this is usually the case for
+#                       global or static variables that are loaded in rom and copied
+#                       to ram at boot time.
+# GROUP <group>       : Place this section inside the group <group>
+# ADDRESS <address>   : Specific address to use for this section.
+# ALIGN_WITH_INPUT    : The alignment difference between VMA and LMA is kept
+#                       intact for this section.
+# SUBALIGN <alignment>: Force input alignment with size <alignment>
+#  Note: Regarding all alignment attributes. Not all linkers may handle alignment
+#        in identical way. For example the Scatter file will align both load and
+#        execution address (LMA and VMA) to be aligned when given the ALIGN attribute.
+#/
+function(zephyr_iterable_section)
+  # ToDo - Should we use ROM, RAM, etc as arguments ?
+  set(options     "ALIGN_WITH_INPUT")
+  set(single_args "GROUP;LMA;NAME;SUBALIGN;VMA")
+  set(multi_args  "")
+  set(align_input)
+  cmake_parse_arguments(SECTION "${options}" "${single_args}" "${multi_args}" ${ARGN})
+
+  if(NOT DEFINED SECTION_NAME)
+    message(FATAL_ERROR "zephyr_iterable_section(${ARGV0} ...) missing "
+                        "required argument: NAME"
+    )
+  endif()
+
+  if(NOT DEFINED SECTION_SUBALIGN)
+    message(FATAL_ERROR "zephyr_iterable_section(${ARGV0} ...) missing "
+                        "required argument: SUBALIGN"
+    )
+  endif()
+
+  if(SECTION_ALIGN_WITH_INPUT)
+    set(align_input ALIGN_WITH_INPUT)
+  endif()
+
+  zephyr_linker_section(
+    NAME ${SECTION_NAME}_area
+    GROUP "${SECTION_GROUP}"
+    VMA "${SECTION_VMA}" LMA "${SECTION_LMA}"
+    NOINPUT ${align_input} SUBALIGN ${SECTION_SUBALIGN}
+  )
+  zephyr_linker_section_configure(
+    SECTION ${SECTION_NAME}_area
+    INPUT "._${SECTION_NAME}.static.*"
+    SYMBOLS _${SECTION_NAME}_list_start _${SECTION_NAME}_list_end
+    KEEP SORT NAME
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_section_obj_level(SECTION <section> LEVEL <level>)
+#
+# generate a symbol to mark the start of the objects array for
+# the specified object and level, then link all of those objects
+# (sorted by priority). Ensure the objects aren't discarded if there is
+# no direct reference to them.
+#
+# This is useful content such as struct devices.
+#
+# For example: zephyr_linker_section_obj_level(SECTION init LEVEL PRE_KERNEL_1)
+# will create an input section matching `.z_init_PRE_KERNEL_1?_` and
+# `.z_init_PRE_KERNEL_1??_`.
+#
+# SECTION <section>: Section in which the objects shall be placed
+# LEVEL <level>    : Priority level, all input sections matching the level
+#                    will be sorted.
+#
+function(zephyr_linker_section_obj_level)
+  set(single_args "SECTION;LEVEL")
+  cmake_parse_arguments(OBJ "" "${single_args}" "" ${ARGN})
+
+  if(NOT DEFINED OBJ_SECTION)
+    message(FATAL_ERROR "zephyr_linker_section_obj_level(${ARGV0} ...) "
+                        "missing required argument: SECTION"
+    )
+  endif()
+
+  if(NOT DEFINED OBJ_LEVEL)
+    message(FATAL_ERROR "zephyr_linker_section_obj_level(${ARGV0} ...) "
+                        "missing required argument: LEVEL"
+    )
+  endif()
+
+  zephyr_linker_section_configure(
+    SECTION ${OBJ_SECTION}
+    INPUT ".z_${OBJ_SECTION}_${OBJ_LEVEL}?_"
+    SYMBOLS __${OBJ_SECTION}_${OBJ_LEVEL}_start
+    KEEP SORT NAME
+  )
+  zephyr_linker_section_configure(
+    SECTION ${OBJ_SECTION}
+    INPUT ".z_${OBJ_SECTION}_${OBJ_LEVEL}??_"
+    KEEP SORT NAME
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_section_configure(SECTION <section> [ALIGN <alignment>]
+#                                   [PASS <no>] [PRIO <no>] [SORT <sort>]
+#                                   [ANY] [FIRST] [KEEP]
+#   )
+#
+# Configure an output section with additional input sections.
+# An output section can be configured with additional input sections besides its
+# default section.
+# For example, adding the input section `foo` to the output section bar, with KEEP
+# attribute, then call:
+#   zephyr_linker_section_configure(SECTION bar INPUT foo KEEP)
+#
+# ALIGN <alignment>   : Will align the input section placement inside the load
+#                       region with <alignment>
+# FIRST               : The first input section in the list should be marked as
+#                       first section in output.
+# SORT <NAME>         : Sort the input sections according to <type>.
+#                       Currently only `NAME` is supported.
+# KEEP                : Do no eliminate input section during linking
+# PRIO                : The priority of the input section. Per default, input
+#                       sections order is not guaranteed by all linkers, but
+#                       using priority, then Zephyr CMake linker will create
+#                       sections so order can be guaranteed. All unprioritized
+#                       sections will internally be given a CMake process order
+#                       priority counting from 100, so first unprioritized section
+#                       is handles internal pri0 100, next 101, and so on.
+#                       To ensure a specific input section come before those,
+#                       you may use `PRIO 50`, `PRIO 20` and so on.
+#                       To ensure an input section is at the end, it is advised
+#                       to use `PRIO 200` and above.
+# PASS <no>           : The call should only be considered for linker pass number <no>.
+#                       For example, `PASS 1` means the call is only effective
+#                       on first linker pass iteration. `PASS 2` on second iteration,
+#                       and so on.
+# FLAGS <flags>       : Special section flags such as "+RO", +XO, "+ZI".
+# ANY                 : ANY section flag in scatter file.
+#                       The FLAGS and ANY arguments only has effect for scatter files.
+#
+function(zephyr_linker_section_configure)
+  set(options     "ANY;FIRST;KEEP")
+  set(single_args "ALIGN;OFFSET;PASS;PRIO;SECTION;SORT")
+  set(multi_args  "FLAGS;INPUT;SYMBOLS")
+  cmake_parse_arguments(SECTION "${options}" "${single_args}" "${multi_args}" ${ARGN})
+
+  if(SECTION_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "zephyr_linker_section_configure(${ARGV0} ...) given unknown arguments: ${SECTION_UNPARSED_ARGUMENTS}")
+  endif()
+
+  if(DEFINED SECTION_SYMBOLS)
+    list(LENGTH SECTION_SYMBOLS symbols_count)
+    if(${symbols_count} GREATER 2)
+      message(FATAL_ERROR "zephyr_linker_section_configure(SYMBOLS [start_sym [end_sym]]) takes maximum two symbol names (start and end).")
+
+    endif()
+  endif()
+
+  set(SECTION)
+  zephyr_linker_arg_val_list(SECTION "${single_args}")
+  zephyr_linker_arg_val_list(SECTION "${options}")
+  zephyr_linker_arg_val_list(SECTION "${multi_args}")
+
+  string(REPLACE ";" "\;" SECTION "${SECTION}")
+  set_property(TARGET linker
+               APPEND PROPERTY SECTION_SETTINGS "{${SECTION}}"
+  )
+endfunction()
+
+# Usage:
+#   zephyr_linker_symbol(SYMBOL <name> EXPR <expr>)
+#
+# Add additional user defined symbol to the generated linker script.
+#
+# SYMBOL <name>: Symbol name to be available.
+# EXPR <expr>  : Expression that defines the symbol. Due to linker limitations
+#                all expressions should only contain simple math, such as
+#                `+, -, *` and similar. The expression will go directly into the
+#                linker, and all `%<symbol>%` will be replaced with the referred
+#                symbol.
+#
+# Example:
+#   To create a new symbol `bar` pointing to the start VMA address of section
+#   `foo` + 1024, one can write:
+#     zephyr_linker_symbol(SYMBOL bar EXPR "(%foo% + 1024)")
+#
+function(zephyr_linker_symbol)
+  set(single_args "EXPR;SYMBOL")
+  cmake_parse_arguments(SYMBOL "" "${single_args}" "" ${ARGN})
+
+  if(SECTION_UNPARSED_ARGUMENTS)
+    message(WARNING "zephyr_linker_symbol(${ARGV0} ...) given unknown "
+                    "arguments: ${SECTION_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  set(SYMBOL)
+  zephyr_linker_arg_val_list(SYMBOL "${single_args}")
+
+  string(REPLACE ";" "\;" SYMBOL "${SYMBOL}")
+  set_property(TARGET linker
+               APPEND PROPERTY SYMBOLS "{${SYMBOL}}"
+  )
+endfunction()
+
+# Internal helper macro for zephyr_linker*() functions.
+# The macro will create a list of argument-value pairs for defined arguments
+# that can be passed on to linker script generators and processed as a CMake
+# function call using cmake_parse_arguments.
+#
+# For example, having the following argument and value:
+# FOO: bar
+# BAZ: <undefined>
+# QUX: option set
+#
+# will create a list as: "FOO;bar;QUX:TRUE" which can then be parsed as argument
+# list later.
+macro(zephyr_linker_arg_val_list list arguments)
+  foreach(arg ${arguments})
+    if(DEFINED ${list}_${arg})
+      list(APPEND ${list} ${arg} "${${list}_${arg}}")
+    endif()
+  endforeach()
+endmacro()

From cf9f2c43a67ddc2c5ec1642b9a3e5b4a46474dca Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Wed, 11 Aug 2021 17:00:02 +0200
Subject: [PATCH 04/20] cmake: CMake devicetree related linker functions
 implemented

This commit introduces zephyr_linker_dts CMake functions for creation of
linker scripts based on devicetree nodes.

The linker devicetree functions supports the following features:
- Configuration of memory sections based on devicetree nodes

Overview of functions introduced with this commit:
- zephyr_linker_dts_memory

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/extensions.cmake | 71 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/cmake/extensions.cmake b/cmake/extensions.cmake
index be85fdedc4bbab..b5fe2898be1fd4 100644
--- a/cmake/extensions.cmake
+++ b/cmake/extensions.cmake
@@ -2979,6 +2979,77 @@ macro(zephyr_linker_memory_ifdef feature_toggle)
   endif()
 endmacro()
 
+# Usage:
+#   zephyr_linker_dts_memory(NAME <name> PATH <path> FLAGS <flags>)
+#   zephyr_linker_dts_memory(NAME <name> NODELABEL <nodelabel> FLAGS <flags>)
+#   zephyr_linker_dts_memory(NAME <name> CHOSEN <prop> FLAGS <flags>)
+#
+# Zephyr linker devicetree memory.
+# This function specifies a memory region for the platform in use based on its
+# devicetree configuration.
+#
+# The memory will only be defined if the devicetree node or a devicetree node
+# matching the nodelabel exists and has status okay.
+#
+# Only one of PATH, NODELABEL, and CHOSEN parameters may be given.
+#
+# NAME <name>      : Name of the memory region, for example FLASH.
+# PATH <path>      : Devicetree node identifier.
+# NODELABEL <label>: Node label
+# CHOSEN <prop>    : Chosen property, add memory section described by the
+#                    /chosen property if it exists.
+# FLAGS <flags>  : Flags describing properties of the memory region.
+#                  Currently supported:
+#                  r: Read-only region
+#                  w: Read-write region
+#                  x: Executable region
+#                  The flags r and x, or w and x may be combined like: rx, wx.
+#
+function(zephyr_linker_dts_memory)
+  set(single_args "CHOSEN;FLAGS;NAME;PATH;NODELABEL")
+  cmake_parse_arguments(DTS_MEMORY "" "${single_args}" "" ${ARGN})
+
+  if(DTS_MEMORY_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "zephyr_linker_dts_memory(${ARGV0} ...) given unknown "
+                        "arguments: ${DTS_MEMORY_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if((DEFINED DTS_MEMORY_PATH AND (DEFINED DTS_MEMORY_NODELABEL OR DEFINED DTS_MEMORY_CHOSEN))
+     OR (DEFINED DTS_MEMORY_NODELABEL AND DEFINED DTS_MEMORY_CHOSEN))
+    message(FATAL_ERROR "zephyr_linker_dts_memory(${ARGV0} ...), only one of "
+                        "PATH, NODELABEL, and CHOSEN is allowed."
+    )
+  endif()
+
+  if(DEFINED DTS_MEMORY_NODELABEL)
+    dt_nodelabel(DTS_MEMORY_PATH NODELABEL ${DTS_MEMORY_NODELABEL})
+  endif()
+
+  if(DEFINED DTS_MEMORY_CHOSEN)
+    dt_chosen(DTS_MEMORY_PATH PROPERTY ${DTS_MEMORY_CHOSEN})
+  endif()
+
+  if(NOT DEFINED DTS_MEMORY_PATH)
+    return()
+  endif()
+
+  dt_node_exists(exists PATH ${DTS_MEMORY_PATH})
+  if(NOT ${exists})
+    return()
+  endif()
+
+  dt_reg_addr(addr PATH ${DTS_MEMORY_PATH})
+  dt_reg_size(size PATH ${DTS_MEMORY_PATH})
+
+  zephyr_linker_memory(
+    NAME  ${DTS_MEMORY_NAME}
+    START ${addr}
+    SIZE  ${size}
+    FLAGS ${DTS_MEMORY_FLAGS}
+  )
+endfunction()
+
 # Usage:
 #   zephyr_linker_group(NAME <name> [VMA <region|group>] [LMA <region|group>])
 #   zephyr_linker_group(NAME <name> GROUP <group>)

From 5c195e8d344b50c8de978a39e0d8e47b0f3a1aff Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 6 May 2021 11:49:35 +0200
Subject: [PATCH 05/20] cmake: linker: converter arm and common ld scripts into
 CMake code

Converted existing ld script templates into CMake files.

This commit takes the common-ram.ld, common-rom.ld, debug-sections.ld,
and thread-local-storage.ld and creates corresponding CMake files for
the linker script generator.

The CMake files uses the new Zephyr CMake functions:
- zephyr_linker_section()
- zephyr_linker_section_configure()
- zephyr_linker_section_obj_level()

to generate the same linker result as the existing C preprocessor based
scheme.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 arch/common/CMakeLists.txt                    |   1 +
 cmake/linker_script/common/common-ram.cmake   | 104 ++++++++++
 cmake/linker_script/common/common-rom.cmake   | 183 ++++++++++++++++++
 .../linker_script/common/debug-sections.cmake |  50 +++++
 .../common/thread-local-storage.cmake         |  39 ++++
 5 files changed, 377 insertions(+)
 create mode 100644 cmake/linker_script/common/common-ram.cmake
 create mode 100644 cmake/linker_script/common/common-rom.cmake
 create mode 100644 cmake/linker_script/common/debug-sections.cmake
 create mode 100644 cmake/linker_script/common/thread-local-storage.cmake

diff --git a/arch/common/CMakeLists.txt b/arch/common/CMakeLists.txt
index 3f6e5984c26bf5..b39cc404ac0bd3 100644
--- a/arch/common/CMakeLists.txt
+++ b/arch/common/CMakeLists.txt
@@ -38,6 +38,7 @@ zephyr_linker_sources_ifdef(CONFIG_NOCACHE_MEMORY
 if (DEFINED CONFIG_ARM OR DEFINED CONFIG_X86 OR DEFINED CONFIG_ARM64
     OR DEFINED CONFIG_SOC_OPENISA_RV32M1_RISCV32)
   zephyr_linker_sources(ROM_START SORT_KEY 0x0 rom_start_offset.ld)
+  # Handled in ld.cmake
 endif()
 
 
diff --git a/cmake/linker_script/common/common-ram.cmake b/cmake/linker_script/common/common-ram.cmake
new file mode 100644
index 00000000000000..bb38b79e309d79
--- /dev/null
+++ b/cmake/linker_script/common/common-ram.cmake
@@ -0,0 +1,104 @@
+# originates from common-ram.ld
+
+if(CONFIG_GEN_SW_ISR_TABLE AND CONFIG_DYNAMIC_INTERRUPTS)
+  # ld align has been changed to subalign to provide identical behavior scatter vs. ld.
+  zephyr_linker_section(NAME sw_isr_table
+    GROUP DATA_REGION
+    ${XIP_ALIGN_WITH_INPUT} SUBALIGN ${CONFIG_ARCH_SW_ISR_TABLE_ALIGN}
+  )
+  zephyr_linker_section_configure(
+    SECTION sw_isr_table
+    INPUT ".gnu.linkonce.sw_isr_table*"
+  )
+endif()
+
+zephyr_linker_section(NAME device_states GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION device_states
+  KEEP INPUT ".z_devstate" ".z_devstate.*"
+)
+
+if(CONFIG_PM_DEVICE)
+  zephyr_linker_section(NAME pm_device_slots GROUP DATA_REGION TYPE NOLOAD NOINPUT ${XIP_ALIGN_WITH_INPUT})
+  zephyr_linker_section_configure(SECTION pm_device_slots KEEP INPUT ".z_pm_device_slots")
+endif()
+
+zephyr_linker_section(NAME initshell GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION initshell
+  KEEP INPUT ".shell_module_*"
+  SYMBOLS __shell_module_start __shell_module_end
+)
+zephyr_linker_section_configure(SECTION initshell
+  KEEP INPUT ".shell_cmd_*"
+  SYMBOLS __shell_cmd_start __shell_end_end
+)
+
+zephyr_linker_section(NAME log_dynamic GROUP DATA_REGION NOINPUT)
+zephyr_linker_section_configure(SECTION log_dynamic KEEP INPUT ".log_dynamic_*")
+
+zephyr_iterable_section(NAME _static_thread_data GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+
+if(CONFIG_USERSPACE)
+  # All kernel objects within are assumed to be either completely
+  # initialized at build time, or initialized automatically at runtime
+  # via iteration before the POST_KERNEL phase.
+  #
+  # These two symbols only used by gen_kobject_list.py
+  #   _static_kernel_objects_begin = .;
+endif()
+
+zephyr_iterable_section(NAME k_timer GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_mem_slab GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_mem_pool GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_heap GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_mutex GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_stack GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_msgq GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_mbox GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_pipe GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_sem GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_queue GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_iterable_section(NAME k_condvar GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+
+zephyr_linker_section(NAME _net_buf_pool_area GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+zephyr_linker_section_configure(SECTION _net_buf_pool_area
+  KEEP SORT NAME INPUT "._net_buf_pool.static.*"
+  SYMBOLS _net_buf_pool_list
+)
+
+if(CONFIG_NETWORKING)
+  zephyr_iterable_section(NAME net_if     GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+  zephyr_iterable_section(NAME net_if_dev GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+  zephyr_iterable_section(NAME net_l2     GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+  zephyr_iterable_section(NAME eth_bridge GROUP DATA_REGION ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+endif()
+
+if(CONFIG_UART_MUX)
+  zephyr_linker_section(NAME uart_mux GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} SUBALIGN 4)
+  zephyr_linker_section_configure(SECTION uart_mux
+    KEEP SORT NAME INPUT ".uart_mux.*"
+  )
+endif()
+
+if(CONFIG_USB_DEVICE_STACK)
+  zephyr_linker_section(NAME usb_descriptor GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} SUBALIGN 1)
+  zephyr_linker_section_configure(SECTION usb_descriptor
+    KEEP SORT NAME INPUT ".usb.descriptor*"
+  )
+
+  zephyr_linker_section(NAME usb_data GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} SUBALIGN 1)
+  zephyr_linker_section_configure(SECTION usb_data
+    KEEP SORT NAME INPUT ".usb.data*"
+  )
+endif()
+
+if(CONFIG_USB_DEVICE_BOS)
+  zephyr_linker_section(NAME usb_bos_desc GROUP DATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} SUBALIGN 1)
+  zephyr_linker_section_configure(SECTION usb_data
+    KEEP SORT NAME INPUT ".usb.bos_desc"
+  )
+endif()
+
+#if(CONFIG_USERSPACE)
+#	_static_kernel_objects_end = .;
+#endif()
+#
diff --git a/cmake/linker_script/common/common-rom.cmake b/cmake/linker_script/common/common-rom.cmake
new file mode 100644
index 00000000000000..6f873e5d6d0db8
--- /dev/null
+++ b/cmake/linker_script/common/common-rom.cmake
@@ -0,0 +1,183 @@
+# originates from common-rom.ld
+
+zephyr_linker_section(NAME init KVMA RAM_REGION GROUP RODATA_REGION)
+zephyr_linker_section_obj_level(SECTION init LEVEL PRE_KERNEL_1)
+zephyr_linker_section_obj_level(SECTION init LEVEL PRE_KERNEL_2)
+zephyr_linker_section_obj_level(SECTION init LEVEL POST_KERNEL)
+zephyr_linker_section_obj_level(SECTION init LEVEL APPLICATION)
+zephyr_linker_section_obj_level(SECTION init LEVEL SMP)
+
+zephyr_linker_section(NAME device KVMA RAM_REGION GROUP RODATA_REGION)
+zephyr_linker_section_obj_level(SECTION device LEVEL PRE_KERNEL_1)
+zephyr_linker_section_obj_level(SECTION device LEVEL PRE_KERNEL_2)
+zephyr_linker_section_obj_level(SECTION device LEVEL POST_KERNEL)
+zephyr_linker_section_obj_level(SECTION device LEVEL APPLICATION)
+zephyr_linker_section_obj_level(SECTION device LEVEL SMP)
+
+if(CONFIG_GEN_SW_ISR_TABLE AND NOT CONFIG_DYNAMIC_INTERRUPTS)
+  # ld align has been changed to subalign to provide identical behavior scatter vs. ld.
+  zephyr_linker_section(NAME sw_isr_table KVMA FLASH GROUP RODATA_REGION SUBALIGN ${CONFIG_ARCH_SW_ISR_TABLE_ALIGN} NOINPUT)
+  zephyr_linker_section_configure(
+    SECTION sw_isr_table
+    INPUT ".gnu.linkonce.sw_isr_table*"
+  )
+endif()
+
+zephyr_linker_section(NAME initlevel_error KVMA RAM_REGION GROUP RODATA_REGION NOINPUT)
+zephyr_linker_section_configure(SECTION initlevel_error INPUT ".z_init_[_A-Z0-9]*" KEEP SORT NAME)
+# How to do cross linker ?
+# ASSERT(SIZEOF(initlevel_error) == 0, "Undefined initialization levels used.")
+
+
+if(CONFIG_CPLUSPLUS)
+  zephyr_linker_section(NAME ctors KVMA RAM_REGION GROUP RODATA_REGION NOINPUT)
+  #
+  # The compiler fills the constructor pointers table below,
+  # hence symbol __CTOR_LIST__ must be aligned on word
+  # boundary.  To align with the C++ standard, the first elment
+  # of the array contains the number of actual constructors. The
+  # last element is NULL.
+  #
+# ToDo: Checkup on scatter loading. How to manage ?
+# https://www.keil.com/support/man/docs/armlink/armlink_pge1362066006368.htm
+# https://developer.arm.com/documentation/dui0378/g/The-ARM-C-and-C---Libraries
+#  if(CONFIG_64BIT)
+#		. = ALIGN(8);
+#		__CTOR_LIST__ = .;
+#		QUAD((__CTOR_END__ - __CTOR_LIST__) / 8 - 2)
+#		KEEP(*(SORT_BY_NAME(".ctors*")))
+#		QUAD(0)
+#		__CTOR_END__ = .;
+#  else()
+#		. = ALIGN(4);
+#		__CTOR_LIST__ = .;
+#		LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
+#		KEEP(*(SORT_BY_NAME(".ctors*")))
+#		LONG(0)
+#		__CTOR_END__ = .;
+#  endif()
+#	} GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)
+#
+#	SECTION_PROLOGUE(init_array,,)
+#	{
+#		. = ALIGN(4);
+#		__init_array_start = .;
+#		KEEP(*(SORT_BY_NAME(".init_array*")))
+#		__init_array_end = .;
+#	} GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)
+endif()
+
+if(CONFIG_USERSPACE)
+  # Build-time assignment of permissions to kernel objects to
+  # threads declared with K_THREAD_DEFINE()
+  zephyr_linker_section(
+    NAME z_object_assignment_area
+    VMA FLASH NOINPUT
+    SUBALIGN 4
+  )
+  zephyr_linker_section_configure(
+    SECTION z_object_assignment
+    INPUT ".z_object_assignment.static.*"
+    KEEP SORT NAME
+  )
+endif()
+
+zephyr_linker_section(
+  NAME app_shmem_regions
+  KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT}
+)
+zephyr_linker_section_configure(
+  SECTION app_shmem_regions
+  INPUT ".app_regions.*"
+  KEEP SORT NAME
+)
+
+if(CONFIG_NET_SOCKETS)
+  zephyr_iterable_section(NAME net_socket_register KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+
+if(CONFIG_NET_L2_PPP)
+  zephyr_iterable_section(NAME ppp_protocol_handler KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+zephyr_iterable_section(NAME bt_l2cap_fixed_chan KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+if(CONFIG_BT_BREDR)
+  zephyr_iterable_section(NAME bt_l2cap_br_fixed_chan KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_BT_CONN)
+  zephyr_iterable_section(NAME bt_conn_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+zephyr_iterable_section(NAME bt_gatt_service_static KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+if(CONFIG_BT_MESH)
+  zephyr_iterable_section(NAME bt_mesh_subnet_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+  zephyr_iterable_section(NAME bt_mesh_app_key_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+  zephyr_iterable_section(NAME bt_mesh_hb_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_BT_MESH_FRIEND)
+  zephyr_iterable_section(NAME bt_mesh_friend_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_BT_MESH_LOW_POWER)
+  zephyr_iterable_section(NAME bt_mesh_lpn_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_BT_MESH_PROXY)
+  zephyr_iterable_section(NAME bt_mesh_proxy_cb KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_EC_HOST_CMD)
+  zephyr_iterable_section(NAME ec_host_cmd_handler KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_SETTINGS)
+  zephyr_iterable_section(NAME settings_handler_static KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+zephyr_iterable_section(NAME k_p4wq_initparam KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+if(CONFIG_EMUL)
+  zephyr_linker_section(NAME emulators_section GROUP RODATA_REGION)
+  zephyr_linker_section_configure(SECTION emulators_section INPUT ".emulators" KEEP SORT NAME ${XIP_ALIGN_WITH_INPUT})
+endif()
+
+if(CONFIG_DNS_SD)
+  zephyr_iterable_section(NAME dns_sd_rec KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+endif()
+
+if(CONFIG_PCIE)
+  zephyr_linker_section(NAME irq_alloc GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+  zephyr_linker_section_configure(SECTION irq_alloc INPUT ".irq_alloc*" KEEP SORT NAME)
+endif()
+
+zephyr_linker_section(NAME log_strings KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION log_strings INPUT ".log_strings*" KEEP SORT NAME)
+
+zephyr_linker_section(NAME log_const KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION log_const INPUT ".log_const_*" KEEP SORT NAME)
+
+zephyr_linker_section(NAME log_backends KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION log_backends INPUT ".log_backends.*" KEEP)
+
+zephyr_iterable_section(NAME shell KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+zephyr_linker_section(NAME shell_root_cmds KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION shell_root_cmds INPUT ".shell_root_cmd_*" KEEP SORT NAME)
+
+zephyr_linker_section(NAME font_entry KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION font_entry INPUT "._cfb_font.*" KEEP SORT NAME)
+
+zephyr_iterable_section(NAME tracing_backend KVMA RAM_REGION GROUP RODATA_REGION SUBALIGN 4)
+
+zephyr_linker_section(NAME zephyr_dbg_info KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT})
+zephyr_linker_section_configure(SECTION zephyr_dbg_info INPUT ".zephyr_dbg_info" KEEP)
+
+zephyr_linker_section(NAME device_handles KVMA RAM_REGION GROUP RODATA_REGION NOINPUT ${XIP_ALIGN_WITH_INPUT} ENDALIGN 16)
+zephyr_linker_section_configure(SECTION device_handles INPUT .__device_handles_pass1* KEEP SORT NAME PASS 1)
+zephyr_linker_section_configure(SECTION device_handles INPUT .__device_handles_pass2* KEEP SORT NAME PASS 2)
diff --git a/cmake/linker_script/common/debug-sections.cmake b/cmake/linker_script/common/debug-sections.cmake
new file mode 100644
index 00000000000000..397d4bdb1d7eb2
--- /dev/null
+++ b/cmake/linker_script/common/debug-sections.cmake
@@ -0,0 +1,50 @@
+# Content of this file originates from include/linker/debug-sections.ld
+# Following sections are obtained via 'ld --verbose'
+
+# Stabs debugging sections.
+zephyr_linker_section(NAME  .stab ADDRESS 0)
+zephyr_linker_section(NAME  .stabstr ADDRESS 0)
+zephyr_linker_section(NAME  .stab.excl ADDRESS 0)
+zephyr_linker_section(NAME  .stab.exclstr ADDRESS 0)
+zephyr_linker_section(NAME  .stab.index ADDRESS 0)
+zephyr_linker_section(NAME  .stab.indexstr ADDRESS 0)
+zephyr_linker_section(NAME  .gnu.build.attributes ADDRESS 0)
+zephyr_linker_section(NAME  .comment ADDRESS 0)
+
+# DWARF debug sections.
+# Symbols in the DWARF debugging sections are relative to the beginning
+# of the section so we begin them at 0.
+# DWARF 1 */
+zephyr_linker_section(NAME  .debug ADDRESS 0)
+zephyr_linker_section(NAME  .line ADDRESS 0)
+
+# GNU DWARF 1 extensions
+zephyr_linker_section(NAME  .debug_srcinfo ADDRESS 0)
+zephyr_linker_section(NAME  .debug_sfnames ADDRESS 0)
+
+# DWARF 1.1 and DWARF 2
+zephyr_linker_section(NAME  .debug_aranges ADDRESS 0)
+zephyr_linker_section(NAME  .debug_pubnames ADDRESS 0)
+
+# DWARF 2
+zephyr_linker_section(NAME  .debug_info ADDRESS 0)
+zephyr_linker_section_configure(SECTION .debug_info INPUT ".gnu.linkonce.wi.*")
+zephyr_linker_section(NAME  .debug_abbrev ADDRESS 0)
+zephyr_linker_section(NAME  .debug_line ADDRESS 0)
+zephyr_linker_section_configure(SECTION .debug_line INPUT ".debug_line_end")
+zephyr_linker_section(NAME  .debug_frame ADDRESS 0)
+zephyr_linker_section(NAME  .debug_str ADDRESS 0)
+zephyr_linker_section(NAME  .debug_loc ADDRESS 0)
+zephyr_linker_section(NAME  .debug_macinfo ADDRESS 0)
+
+ #SGI/MIPS DWARF 2 extensions
+zephyr_linker_section(NAME  .debug_weaknames ADDRESS 0)
+zephyr_linker_section(NAME  .debug_funcnames ADDRESS 0)
+zephyr_linker_section(NAME  .debug_typenames ADDRESS 0)
+zephyr_linker_section(NAME  .debug_varnames ADDRESS 0)
+
+# DWARF 3
+zephyr_linker_section(NAME  .debug_pubtypes ADDRESS 0)
+zephyr_linker_section(NAME  .debug_ranges ADDRESS 0)
+# DWARF Extension.
+zephyr_linker_section(NAME  .debug_macro ADDRESS 0)
diff --git a/cmake/linker_script/common/thread-local-storage.cmake b/cmake/linker_script/common/thread-local-storage.cmake
new file mode 100644
index 00000000000000..96d09d6a04a276
--- /dev/null
+++ b/cmake/linker_script/common/thread-local-storage.cmake
@@ -0,0 +1,39 @@
+# originates from thread-local-storage.ld
+
+if(CONFIG_THREAD_LOCAL_STORAGE)
+  zephyr_linker_section(NAME .tdata LMA FLASH NOINPUT)
+  zephyr_linker_section_configure(SECTION .tdata INPUT ".gnu.linkonce.td.*")
+  # GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)
+
+  zephyr_linker_section(NAME .tbss LMA FLASH NOINPUT)
+  zephyr_linker_section_configure(SECTION .tbss INPUT ".gnu.linkonce.tb.*")
+  zephyr_linker_section_configure(SECTION .tbss INPUT ".tcommon")
+  # GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)
+
+  #
+  # These needs to be outside of the tdata/tbss
+  # sections or else they would be considered
+  # thread-local variables, and the code would use
+  # the wrong values.
+  #
+  # This scheme is not yet handled
+  if(CONFIG_XIP)
+#	/* The "master copy" of tdata should be only in flash on XIP systems */
+#	PROVIDE(__tdata_start = LOADADDR(tdata));
+  else()
+#	PROVIDE(__tdata_start = ADDR(tdata));
+  endif()
+#	PROVIDE(__tdata_size = SIZEOF(tdata));
+#	PROVIDE(__tdata_end = __tdata_start + __tdata_size);
+#	PROVIDE(__tdata_align = ALIGNOF(tdata));
+#
+#	PROVIDE(__tbss_start = ADDR(tbss));
+#	PROVIDE(__tbss_size = SIZEOF(tbss));
+#	PROVIDE(__tbss_end = __tbss_start + __tbss_size);
+#	PROVIDE(__tbss_align = ALIGNOF(tbss));
+#
+#	PROVIDE(__tls_start = __tdata_start);
+#	PROVIDE(__tls_end = __tbss_end);
+#	PROVIDE(__tls_size = __tbss_end - __tdata_start);
+
+endif()

From c96d7a5a1c99f26e5c20be701551c1611999705b Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Tue, 1 Jun 2021 10:04:31 +0200
Subject: [PATCH 06/20] arch: linker: specify intList section in the IDT_LIST
 region

This commit specifies the intList section in the IDT_LIST region in the
arch/common CMakeLists.txt file.

It uses zephyr_linker_section to setup the intList section for first
pass linker file and configures the section to hold irq_info and
intList input section.

For second pass linker file, the irq_info and intList input sections are
placed in the /DISCARD/ section.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 arch/common/CMakeLists.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/arch/common/CMakeLists.txt b/arch/common/CMakeLists.txt
index b39cc404ac0bd3..ca0062a317f697 100644
--- a/arch/common/CMakeLists.txt
+++ b/arch/common/CMakeLists.txt
@@ -24,6 +24,15 @@ zephyr_linker_sources_ifdef(CONFIG_GEN_ISR_TABLES
   ${ZEPHYR_BASE}/include/linker/intlist.ld
 )
 
+if(CONFIG_GEN_ISR_TABLES)
+  zephyr_linker_section(NAME .intList VMA IDT_LIST LMA IDT_LIST NOINPUT PASS 1)
+  zephyr_linker_section_configure(SECTION .intList KEEP INPUT ".irq_info" FIRST)
+  zephyr_linker_section_configure(SECTION .intList KEEP INPUT ".intList")
+
+  zephyr_linker_section_configure(SECTION /DISCARD/ KEEP INPUT ".irq_info" PASS 2)
+  zephyr_linker_section_configure(SECTION /DISCARD/ KEEP INPUT ".intList"  PASS 2)
+endif()
+
 zephyr_linker_sources_ifdef(CONFIG_ARCH_HAS_RAMFUNC_SUPPORT
   RAM_SECTIONS
   ramfunc.ld

From b18b442e04fa8c65ed2ac9fb452a83cdd7c42160 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 10 Jun 2021 15:38:20 +0200
Subject: [PATCH 07/20] cmake: linker: arm: adding Zephyr CMake linker files
 for arm arch

This is the initial version of a Zephyr CMake linker file for the arm
architecture.

This file defines memory regions, groups, linker sections and symbols
for the arm architecture.

It also sources the common common-ram.cmake, common-rom.cmake,
debug-sections,cmake, and thread-local-storage.cmake.

It configure sections for SoC families using zephyr_linker_sources()
functions:
- nxp_imx

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 CMakeLists.txt                       |   2 +
 cmake/linker_script/arm/linker.cmake | 169 +++++++++++++++++++++++++++
 soc/arm/nxp_imx/rt/CMakeLists.txt    |  22 ++++
 3 files changed, 193 insertions(+)
 create mode 100644 cmake/linker_script/arm/linker.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a41792546da67..ea473b688c172a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -77,6 +77,8 @@ zephyr_include_directories(
   ${STDINCLUDE}
 )
 
+include(${ZEPHYR_BASE}/cmake/linker_script/${ARCH}/linker.cmake OPTIONAL)
+
 # Don't add non-existing include directories, it creates noise and
 # warnings in some tooling
 foreach(optional_include_dir
diff --git a/cmake/linker_script/arm/linker.cmake b/cmake/linker_script/arm/linker.cmake
new file mode 100644
index 00000000000000..a98cb7b3060733
--- /dev/null
+++ b/cmake/linker_script/arm/linker.cmake
@@ -0,0 +1,169 @@
+set(COMMON_ZEPHYR_LINKER_DIR ${ZEPHYR_BASE}/cmake/linker_script/common)
+
+set_ifndef(region_min_align CONFIG_CUSTOM_SECTION_MIN_ALIGN_SIZE)
+
+# Set alignment to CONFIG_ARM_MPU_REGION_MIN_ALIGN_AND_SIZE if not set above
+# to make linker section alignment comply with MPU granularity.
+set_ifndef(region_min_align CONFIG_ARM_MPU_REGION_MIN_ALIGN_AND_SIZE)
+
+# If building without MPU support, use default 4-byte alignment.. if not set abve.
+set_ifndef(region_min_align 4)
+
+# Note, the `+ 0` in formulas below avoids errors in cases where a Kconfig
+#       variable is undefined and thus expands to nothing.
+math(EXPR FLASH_ADDR
+     "${CONFIG_FLASH_BASE_ADDRESS} + ${CONFIG_FLASH_LOAD_OFFSET} + 0"
+     OUTPUT_FORMAT HEXADECIMAL
+)
+
+math(EXPR FLASH_SIZE
+     "(${CONFIG_FLASH_SIZE} + 0) * 1024 - (${CONFIG_FLASH_LOAD_OFFSET} + 0)"
+     OUTPUT_FORMAT HEXADECIMAL
+)
+
+set(RAM_ADDR ${CONFIG_SRAM_BASE_ADDRESS})
+math(EXPR RAM_SIZE "(${CONFIG_SRAM_SIZE} + 0) * 1024" OUTPUT_FORMAT HEXADECIMAL)
+math(EXPR IDT_ADDR "${RAM_ADDR} + ${RAM_SIZE}" OUTPUT_FORMAT HEXADECIMAL)
+
+# ToDo: decide on the optimal location for this.
+# linker/ld/target.cmake based on arch, or directly in arch and scatter_script.cmake can ignore
+zephyr_linker(FORMAT "elf32-littlearm")
+zephyr_linker(ENTRY ${CONFIG_KERNEL_ENTRY})
+
+zephyr_linker_memory(NAME FLASH    FLAGS rx START ${FLASH_ADDR} SIZE ${FLASH_SIZE})
+zephyr_linker_memory(NAME RAM      FLAGS wx START ${RAM_ADDR}   SIZE ${RAM_SIZE})
+zephyr_linker_memory(NAME IDT_LIST FLAGS wx START ${IDT_ADDR}   SIZE 2K)
+
+if(CONFIG_XIP)
+  zephyr_linker_group(NAME ROM_REGION LMA FLASH)
+  set(rom_start ${FLASH_ADDR})
+  set(XIP_ALIGN_WITH_INPUT ALIGN_WITH_INPUT)
+else()
+  zephyr_linker_group(NAME ROM_REGION LMA RAM)
+  set(rom_start ${RAM_ADDR})
+endif()
+
+zephyr_linker_group(NAME RAM_REGION VMA RAM LMA ROM_REGION)
+zephyr_linker_group(NAME TEXT_REGION GROUP ROM_REGION)
+zephyr_linker_group(NAME RODATA_REGION GROUP ROM_REGION)
+zephyr_linker_group(NAME DATA_REGION GROUP RAM_REGION)
+
+# should go to a relocation.cmake - from include/linker/rel-sections.ld - start
+zephyr_linker_section(NAME  .rel.plt  HIDDEN)
+zephyr_linker_section(NAME  .rela.plt HIDDEN)
+zephyr_linker_section(NAME  .rel.dyn)
+zephyr_linker_section(NAME  .rela.dyn)
+# should go to a relocation.cmake - from include/linker/rel-sections.ld - end
+
+# Discard sections for GNU ld.
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".plt")
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".iplt")
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".got.plt")
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".igot.plt")
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".got")
+zephyr_linker_section_configure(SECTION /DISCARD/ INPUT ".igot")
+
+zephyr_linker_section(NAME .rom_start ADDRESS ${rom_start} GROUP ROM_REGION NOINPUT)
+
+zephyr_linker_section(NAME .text         GROUP TEXT_REGION)
+
+zephyr_linker_section_configure(SECTION .rel.plt  INPUT ".rel.iplt")
+zephyr_linker_section_configure(SECTION .rela.plt INPUT ".rela.iplt")
+
+zephyr_linker_section_configure(SECTION .text INPUT ".TEXT.*")
+zephyr_linker_section_configure(SECTION .text INPUT ".gnu.linkonce.t.*")
+
+zephyr_linker_section_configure(SECTION .text INPUT ".glue_7t")
+zephyr_linker_section_configure(SECTION .text INPUT ".glue_7")
+zephyr_linker_section_configure(SECTION .text INPUT ".vfp11_veneer")
+zephyr_linker_section_configure(SECTION .text INPUT ".v4_bx")
+
+if(CONFIG_CPLUSPLUS)
+  zephyr_linker_section(NAME .ARM.extab GROUP ROM_REGION)
+  zephyr_linker_section_configure(SECTION .ARM.extab INPUT ".gnu.linkonce.armextab.*")
+endif()
+
+zephyr_linker_section(NAME .ARM.exidx GROUP ROM_REGION)
+# Here the original linker would check for __GCC_LINKER_CMD__, need to check toolchain linker ?
+#if(__GCC_LINKER_CMD__)
+  zephyr_linker_section_configure(SECTION .ARM.exidx INPUT ".gnu.linkonce.armexidx.*")
+#endif()
+
+
+include(${COMMON_ZEPHYR_LINKER_DIR}/common-rom.cmake)
+include(${COMMON_ZEPHYR_LINKER_DIR}/thread-local-storage.cmake)
+
+zephyr_linker_section(NAME .rodata GROUP RODATA_REGION)
+zephyr_linker_section_configure(SECTION .rodata INPUT ".gnu.linkonce.r.*")
+if(CONFIG_USERSPACE AND CONFIG_XIP)
+  zephyr_linker_section_configure(SECTION .rodata INPUT ".kobject_data.rodata*")
+endif()
+zephyr_linker_section_configure(SECTION .rodata ALIGN 4)
+
+# ToDo - . = ALIGN(_region_min_align);
+# Symbol to add _image_ram_start = .;
+
+# This comes from ramfunc.ls, via snippets-ram-sections.ld
+zephyr_linker_section(NAME .ramfunc GROUP RAM_REGION SUBALIGN 8)
+# Todo: handle MPU_ALIGN(_ramfunc_size);
+
+# ToDo - handle if(CONFIG_USERSPACE)
+
+zephyr_linker_section(NAME .data GROUP DATA_REGION)
+zephyr_linker_section_configure(SECTION .data INPUT ".kernel.*")
+
+include(${COMMON_ZEPHYR_LINKER_DIR}/common-ram.cmake)
+#include(kobject.ld)
+
+if(NOT CONFIG_USERSPACE)
+  zephyr_linker_section(NAME .bss VMA RAM LMA FLASH TYPE BSS)
+  zephyr_linker_section_configure(SECTION .bss INPUT COMMON)
+  zephyr_linker_section_configure(SECTION .bss INPUT ".kernel_bss.*")
+  # As memory is cleared in words only, it is simpler to ensure the BSS
+  # section ends on a 4 byte boundary. This wastes a maximum of 3 bytes.
+  zephyr_linker_section_configure(SECTION .bss ALIGN 4)
+
+  zephyr_linker_section(NAME .noinit GROUP RAM_REGION TYPE NOLOAD NOINIT)
+  # This section is used for non-initialized objects that
+  # will not be cleared during the boot process.
+  zephyr_linker_section_configure(SECTION .noinit INPUT ".kernel_noinit.*")
+endif()
+
+zephyr_linker_symbol(SYMBOL __kernel_ram_start EXPR "(%__bss_start%)")
+zephyr_linker_symbol(SYMBOL __kernel_ram_end  EXPR "(${RAM_ADDR} + ${RAM_SIZE})")
+zephyr_linker_symbol(SYMBOL __kernel_ram_size EXPR "(%__kernel_ram_end% - %__bss_start%)")
+zephyr_linker_symbol(SYMBOL _image_ram_start  EXPR "(${RAM_ADDR})" SUBALIGN 32) # ToDo calculate 32 correctly
+zephyr_linker_symbol(SYMBOL ARM_LIB_STACKHEAP EXPR "(${RAM_ADDR} + ${RAM_SIZE})" SIZE -0x1000)
+
+set(VECTOR_ALIGN 4)
+if(CONFIG_CPU_CORTEX_M_HAS_VTOR)
+  math(EXPR VECTOR_ALIGN "4 * (16 + ${CONFIG_NUM_IRQS})")
+  if(${VECTOR_ALIGN} LESS 128)
+    set(VECTOR_ALIGN 128)
+  else()
+    pow2round(VECTOR_ALIGN)
+  endif()
+endif()
+
+zephyr_linker_section_configure(
+  SECTION .rom_start
+  INPUT ".exc_vector_table*"
+        ".gnu.linkonce.irq_vector_table*"
+        ".vectors"
+  OFFSET ${CONFIG_ROM_START_OFFSET}
+  KEEP FIRST
+  SYMBOLS _vector_start _vector_end
+  ALIGN ${VECTOR_ALIGN}
+  PRIO 50
+)
+
+zephyr_linker_section(NAME .ARM.attributes ADDRESS 0 NOINPUT)
+zephyr_linker_section_configure(SECTION .ARM.attributes INPUT ".ARM.attributes" KEEP)
+zephyr_linker_section_configure(SECTION .ARM.attributes INPUT ".gnu.attributes" KEEP)
+
+# armlink specific flags
+zephyr_linker_section_configure(SECTION .text ANY FLAGS "+RO" "+XO")
+zephyr_linker_section_configure(SECTION .data ANY FLAGS "+RW")
+zephyr_linker_section_configure(SECTION .bss ANY FLAGS "+ZI")
+
+include(${COMMON_ZEPHYR_LINKER_DIR}/debug-sections.cmake)
diff --git a/soc/arm/nxp_imx/rt/CMakeLists.txt b/soc/arm/nxp_imx/rt/CMakeLists.txt
index 9446f00bdc279b..dd85c46f741ba1 100644
--- a/soc/arm/nxp_imx/rt/CMakeLists.txt
+++ b/soc/arm/nxp_imx/rt/CMakeLists.txt
@@ -8,3 +8,25 @@ zephyr_sources_ifdef(CONFIG_SOC_SERIES_IMX_RT10XX soc_rt10xx.c)
 
 zephyr_linker_sources_ifdef(CONFIG_NXP_IMX_RT_BOOT_HEADER
   ROM_START SORT_KEY 0 boot_header.ld)
+
+zephyr_linker_section_configure(
+  SECTION .rom_start
+  INPUT ".boot_hdr.conf"
+  OFFSET ${CONFIG_FLEXSPI_CONFIG_BLOCK_OFFSET}
+  KEEP
+  PRIO 10
+)
+
+if(CONFIG_DEVICE_CONFIGURATION_DATA)
+  set(boot_hdr_dcd_data_section ".boot_hdr.dcd_data")
+endif()
+
+zephyr_linker_section_configure(
+  SECTION .rom_start
+  INPUT ".boot_hdr.ivt"
+        ".boot_hdr.data"
+        ${boot_hdr_dcd_data_section}
+  OFFSET ${CONFIG_IMAGE_VECTOR_TABLE_OFFSET}
+  KEEP
+  PRIO 11
+)

From 870d9b17995607c638f2b7065bcfada483844101 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Wed, 11 Aug 2021 17:02:22 +0200
Subject: [PATCH 08/20] cmake: linker: arm: memory regions from devicetree
 added

This commit add devicetree memory regions added to arm/linker.cmake.

The following memory regions are now added to the generated linker
script and scatter file if they exists in the devicetree.
- chosen:    zephyr,itcm
- chosen:    zephyr,dtcm
- nodelabel: ti_ccfg_partition
- nodelabel: sram1
- nodelabel: sram2
- nodelabel: sram3
- nodelabel: sram4
- nodelabel: sdram1
- nodelabel: sdram2
- nodelabel: backup_sram

Also support for the itcm and dtcm section and their placement in
corresponding memory regions has been added.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/linker_script/arm/linker.cmake | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/cmake/linker_script/arm/linker.cmake b/cmake/linker_script/arm/linker.cmake
index a98cb7b3060733..86b1b424e185ff 100644
--- a/cmake/linker_script/arm/linker.cmake
+++ b/cmake/linker_script/arm/linker.cmake
@@ -34,6 +34,21 @@ zephyr_linker_memory(NAME FLASH    FLAGS rx START ${FLASH_ADDR} SIZE ${FLASH_SIZ
 zephyr_linker_memory(NAME RAM      FLAGS wx START ${RAM_ADDR}   SIZE ${RAM_SIZE})
 zephyr_linker_memory(NAME IDT_LIST FLAGS wx START ${IDT_ADDR}   SIZE 2K)
 
+# TI CCFG Registers
+zephyr_linker_dts_memory(NAME FLASH_CCFG FLAGS rwx NODELABEL ti_ccfg_partition)
+
+# Data & Instruction Tightly Coupled Memory
+zephyr_linker_dts_memory(NAME ITCM        FLAGS rw CHOSEN "zephyr,itcm")
+zephyr_linker_dts_memory(NAME DTCM        FLAGS rw CHOSEN "zephyr,dtcm")
+
+zephyr_linker_dts_memory(NAME SRAM1       FLAGS rw NODELABEL sram1)
+zephyr_linker_dts_memory(NAME SRAM2       FLAGS rw NODELABEL sram2)
+zephyr_linker_dts_memory(NAME SRAM3       FLAGS rw NODELABEL sram3)
+zephyr_linker_dts_memory(NAME SRAM4       FLAGS rw NODELABEL sram4)
+zephyr_linker_dts_memory(NAME SDRAM1      FLAGS rw NODELABEL sdram1)
+zephyr_linker_dts_memory(NAME SDRAM2      FLAGS rw NODELABEL sdram2)
+zephyr_linker_dts_memory(NAME BACKUP_SRAM FLAGS rw NODELABEL backup_sram)
+
 if(CONFIG_XIP)
   zephyr_linker_group(NAME ROM_REGION LMA FLASH)
   set(rom_start ${FLASH_ADDR})
@@ -157,6 +172,28 @@ zephyr_linker_section_configure(
   PRIO 50
 )
 
+dt_chosen(chosen_itcm PROPERTY "zephyr,itcm")
+if(DEFINED chosen_itcm)
+  dt_node_has_status(status_result PATH ${chosen_itcm} STATUS okay)
+  if(${status_result})
+    zephyr_linker_group(NAME ITCM_REGION VMA ITCM LMA ROM_REGION)
+
+    zephyr_linker_section(NAME .itcm GROUP ITCM_REGION SUBALIGN 4)
+  endif()
+endif()
+
+dt_chosen(chosen_dtcm PROPERTY "zephyr,dtcm")
+if(DEFINED chosen_dtcm)
+  dt_node_has_status(status_result PATH ${chosen_dtcm} STATUS okay)
+  if(${status_result})
+    zephyr_linker_group(NAME DTCM_REGION VMA DTCM LMA ROM_REGION)
+
+    zephyr_linker_section(NAME .dtcm_bss GROUP DTCM_REGION SUBALIGN 4 TYPE BSS)
+    zephyr_linker_section(NAME .dtcm_noinit GROUP DTCM_REGION SUBALIGN 4 TYPE NOLOAD NOINIT)
+    zephyr_linker_section(NAME .dtcm_data GROUP DTCM_REGION SUBALIGN 4)
+  endif()
+endif()
+
 zephyr_linker_section(NAME .ARM.attributes ADDRESS 0 NOINPUT)
 zephyr_linker_section_configure(SECTION .ARM.attributes INPUT ".ARM.attributes" KEEP)
 zephyr_linker_section_configure(SECTION .ARM.attributes INPUT ".gnu.attributes" KEEP)

From 56690e1cf5b9b9c8b3fbcc6d6ce38eee7f5948d6 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Mon, 9 Aug 2021 10:41:20 +0200
Subject: [PATCH 09/20] cmake: ld: adding common linker script generator

Adding intial version of linker_script_common.cmake.

This script parses memory regions, groups, sections, settings, and
symbols defined in the Zephyr CMake build system.

The linker script creates objects for each type above and groups
sections, symbols, and groups together based on their configuration.

This creates a hierarchy which the `<linker>_script.cmake`
implementations can then use during linker script generation.

linker_script_common.cmake also provides stubs for <type>_to_string()
functions which are used when generating the output script.

Each specific `<linker>_script.cmake` must implement those to_string()
functions to create the final linker script.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/linker/linker_script_common.cmake | 672 ++++++++++++++++++++++++
 1 file changed, 672 insertions(+)
 create mode 100644 cmake/linker/linker_script_common.cmake

diff --git a/cmake/linker/linker_script_common.cmake b/cmake/linker/linker_script_common.cmake
new file mode 100644
index 00000000000000..67be753ca60d50
--- /dev/null
+++ b/cmake/linker/linker_script_common.cmake
@@ -0,0 +1,672 @@
+#
+# Create functions - start
+#
+
+function(create_system)
+  cmake_parse_arguments(OBJECT "" "ENTRY;FORMAT;NAME;OBJECT" "" ${ARGN})
+
+  set_property(GLOBAL PROPERTY SYSTEM_${OBJECT_NAME}          TRUE)
+  set_property(GLOBAL PROPERTY SYSTEM_${OBJECT_NAME}_OBJ_TYPE SYSTEM)
+  set_property(GLOBAL PROPERTY SYSTEM_${OBJECT_NAME}_NAME     ${OBJECT_NAME})
+  set_property(GLOBAL PROPERTY SYSTEM_${OBJECT_NAME}_FORMAT   ${OBJECT_FORMAT})
+  set_property(GLOBAL PROPERTY SYSTEM_${OBJECT_NAME}_ENTRY    ${OBJECT_ENTRY})
+
+  set(${OBJECT_OBJECT} SYSTEM_${OBJECT_NAME} PARENT_SCOPE)
+endfunction()
+
+function(create_region)
+  cmake_parse_arguments(OBJECT "" "NAME;OBJECT;SIZE;START;FLAGS" "" ${ARGN})
+
+  if(DEFINED OBJECT_SIZE)
+    if(${OBJECT_SIZE} MATCHES "^([0-9]*)[kK]$")
+      math(EXPR OBJECT_SIZE "1024 * ${CMAKE_MATCH_1}" OUTPUT_FORMAT HEXADECIMAL)
+    elseif(${OBJECT_SIZE} MATCHES "^([0-9]*)[mM]$")
+      math(EXPR OBJECT_SIZE "1024 * 1024 * ${CMAKE_MATCH_1}" OUTPUT_FORMAT HEXADECIMAL)
+    elseif(NOT (${OBJECT_SIZE} MATCHES "^([0-9]*)$" OR ${OBJECT_SIZE} MATCHES "^0x([0-9a-fA-F]*)$"))
+      message(FATAL_ERROR "SIZE format is unknown.")
+    endif()
+  endif()
+
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}          TRUE)
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}_OBJ_TYPE REGION)
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}_NAME     ${OBJECT_NAME})
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}_ADDRESS  ${OBJECT_START})
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}_FLAGS    ${OBJECT_FLAGS})
+  set_property(GLOBAL PROPERTY REGION_${OBJECT_NAME}_SIZE     ${OBJECT_SIZE})
+
+  set(${OBJECT_OBJECT} REGION_${OBJECT_NAME} PARENT_SCOPE)
+endfunction()
+
+function(get_parent)
+  cmake_parse_arguments(GET_PARENT "" "OBJECT;PARENT;TYPE" "" ${ARGN})
+
+  get_property(type GLOBAL PROPERTY ${GET_PARENT_OBJECT}_OBJ_TYPE)
+  if(${type} STREQUAL ${GET_PARENT_TYPE})
+    # Already the right type, so just set and return.
+    set(${GET_PARENT_PARENT} ${GET_PARENT_OBJECT} PARENT_SCOPE)
+    return()
+  endif()
+
+  get_property(parent GLOBAL PROPERTY ${GET_PARENT_OBJECT}_PARENT)
+  get_property(type   GLOBAL PROPERTY ${parent}_OBJ_TYPE)
+  while(NOT ${type} STREQUAL ${GET_PARENT_TYPE})
+    get_property(parent GLOBAL PROPERTY ${parent}_PARENT)
+    get_property(type   GLOBAL PROPERTY ${parent}_OBJ_TYPE)
+  endwhile()
+
+  set(${GET_PARENT_PARENT} ${parent} PARENT_SCOPE)
+endfunction()
+
+function(create_group)
+  cmake_parse_arguments(OBJECT "" "GROUP;LMA;NAME;OBJECT;VMA" "" ${ARGN})
+
+  set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}          TRUE)
+  set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_OBJ_TYPE GROUP)
+  set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_NAME     ${OBJECT_NAME})
+
+  if(DEFINED OBJECT_GROUP)
+    find_object(OBJECT parent NAME ${OBJECT_GROUP})
+  else()
+    if(DEFINED OBJECT_VMA)
+      find_object(OBJECT obj NAME ${OBJECT_VMA})
+      get_parent(OBJECT ${obj} PARENT parent TYPE REGION)
+
+      get_property(vma GLOBAL PROPERTY ${parent}_NAME)
+      set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_VMA ${vma})
+    endif()
+
+    if(DEFINED OBJECT_LMA)
+      find_object(OBJECT obj NAME ${OBJECT_LMA})
+      get_parent(OBJECT ${obj} PARENT parent TYPE REGION)
+
+      get_property(lma GLOBAL PROPERTY ${parent}_NAME)
+      set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_LMA ${lma})
+    endif()
+  endif()
+
+  get_property(GROUP_FLAGS_INHERITED GLOBAL PROPERTY ${parent}_FLAGS)
+  set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_FLAGS  ${GROUP_FLAGS_INHERITED})
+  set_property(GLOBAL PROPERTY GROUP_${OBJECT_NAME}_PARENT ${parent})
+
+  add_group(OBJECT ${parent} GROUP GROUP_${OBJECT_NAME})
+
+  set(${OBJECT_OBJECT} GROUP_${OBJECT_NAME} PARENT_SCOPE)
+endfunction()
+
+function(create_section)
+  set(single_args "NAME;ADDRESS;ALIGN_WITH_INPUT;TYPE;ALIGN;ENDALIGN;SUBALIGN;VMA;LMA;NOINPUT;NOINIT;NOSYMBOLS;GROUP;SYSTEM")
+  set(multi_args  "PASS")
+
+  cmake_parse_arguments(SECTION "" "${single_args}" "${multi_args}" ${ARGN})
+
+  if(DEFINED SECTION_PASS AND NOT "${PASS}" IN_LIST SECTION_PASS)
+    # This section is not active in this pass, ignore.
+    return()
+  endif()
+
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME} TRUE)
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_OBJ_TYPE         SECTION)
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_NAME             ${SECTION_NAME})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_ADDRESS          ${SECTION_ADDRESS})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_TYPE             ${SECTION_TYPE})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_ALIGN            ${SECTION_ALIGN})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_ALIGN_WITH_INPUT ${SECTION_ALIGN_WITH_INPUT})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_SUBALIGN         ${SECTION_SUBALIGN})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_ENDALIGN         ${SECTION_ENDALIGN})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_NOINPUT          ${SECTION_NOINPUT})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_NOINIT           ${SECTION_NOINIT})
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_NOSYMBOLS        ${SECTION_NOSYMBOLS})
+
+  string(REGEX REPLACE "^[\.]" "" name_clean "${SECTION_NAME}")
+  string(REPLACE "." "_" name_clean "${name_clean}")
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_NAME_CLEAN ${name_clean})
+
+  set_property(GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_start      ${name_clean})
+  set_property(GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_size       ${name_clean})
+  set_property(GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_load_start ${name_clean})
+  set_property(GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_end        ${name_clean})
+
+  set(INDEX 100)
+  set(settings_single "ALIGN;ANY;FIRST;KEEP;OFFSET;PASS;PRIO;SECTION;SORT")
+  set(settings_multi  "FLAGS;INPUT;SYMBOLS")
+  foreach(settings ${SECTION_SETTINGS})
+    if("${settings}" MATCHES "^{(.*)}$")
+      cmake_parse_arguments(SETTINGS "" "${settings_single}" "${settings_multi}" ${CMAKE_MATCH_1})
+
+      if(NOT ("${SETTINGS_SECTION}" STREQUAL "${SECTION_NAME}"))
+        continue()
+      endif()
+
+      if(DEFINED SETTINGS_PASS AND NOT "${PASS}" IN_LIST SETTINGS_PASS)
+        # This section setting is not active in this pass, ignore.
+        continue()
+      endif()
+
+      if(DEFINED SETTINGS_PRIO)
+        set(idx ${SETTINGS_PRIO})
+      else()
+        set(idx ${INDEX})
+        math(EXPR INDEX "${INDEX} + 1")
+      endif()
+
+      foreach(setting ${settings_single} ${settings_multi})
+        set_property(GLOBAL PROPERTY
+          SECTION_${SECTION_NAME}_SETTING_${idx}_${setting}
+          ${SETTINGS_${setting}}
+        )
+        if(DEFINED SETTINGS_SORT)
+          set_property(GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_end ${name_clean}_end)
+        endif()
+      endforeach()
+
+      set_property(GLOBAL APPEND PROPERTY SECTION_${SECTION_NAME}_SETTINGS_INDICIES ${idx})
+
+    endif()
+  endforeach()
+
+  get_property(indicies GLOBAL PROPERTY SECTION_${SECTION_NAME}_SETTINGS_INDICIES)
+  if(DEFINED indicies)
+    list(SORT indicies COMPARE NATURAL)
+    set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_SETTINGS_INDICIES ${indicies})
+  endif()
+
+  if(DEFINED SECTION_GROUP)
+    find_object(OBJECT parent NAME ${SECTION_GROUP})
+  elseif(DEFINED SECTION_VMA OR DEFINED SECTION_LMA)
+    if(DEFINED SECTION_VMA)
+      find_object(OBJECT object NAME ${SECTION_VMA})
+      get_parent(OBJECT ${object} PARENT parent TYPE REGION)
+
+      get_property(vma GLOBAL PROPERTY ${parent}_NAME)
+      set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_VMA ${vma})
+      set(SECTION_VMA ${vma})
+    endif()
+
+    if(DEFINED SECTION_LMA)
+      find_object(OBJECT object NAME ${SECTION_LMA})
+      get_parent(OBJECT ${object} PARENT parent TYPE REGION)
+
+      get_property(lma GLOBAL PROPERTY ${parent}_NAME)
+      set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_LMA ${lma})
+      set(SECTION_LMA ${lma})
+    endif()
+  else()
+    set(parent ${SECTION_SYSTEM})
+  endif()
+
+  set_property(GLOBAL PROPERTY SECTION_${SECTION_NAME}_PARENT ${parent})
+  add_section(OBJECT ${parent} SECTION ${SECTION_NAME} ADDRESS ${SECTION_ADDRESS} VMA ${SECTION_VMA})
+endfunction()
+
+function(create_symbol)
+  cmake_parse_arguments(SYM "" "OBJECT;EXPR;SIZE;SUBALIGN;SYMBOL" "" ${ARGN})
+
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL} TRUE)
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL}_OBJ_TYPE SYMBOL)
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL}_NAME     ${SYM_SYMBOL})
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL}_EXPR     ${SYM_EXPR})
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL}_SIZE     ${SYM_SIZE})
+  set_property(GLOBAL PROPERTY SYMBOL_${SYM_SYMBOL}_SYMBOL   ${SYM_SYMBOL})
+
+  set_property(GLOBAL PROPERTY SYMBOL_TABLE_${SYM_SYMBOL} ${SYM_SYMBOL})
+
+  add_symbol(OBJECT ${SYM_OBJECT} SYMBOL SYMBOL_${SYM_SYMBOL})
+endfunction()
+
+#
+# Create functions - end
+#
+
+#
+# Add functions - start
+#
+function(add_region)
+  cmake_parse_arguments(ADD_REGION "" "OBJECT;REGION" "" ${ARGN})
+
+  get_property(exists GLOBAL PROPERTY ${ADD_REGION_OBJECT})
+  if(NOT exists)
+    message(FATAL_ERROR
+      "Adding region ${ADD_REGION_REGION} to none-existing object: "
+      "${ADD_REGION_OBJECT}"
+    )
+  endif()
+
+  set_property(GLOBAL PROPERTY ${ADD_REGION_REGION}_PARENT ${ADD_REGION_OBJECT})
+  set_property(GLOBAL APPEND PROPERTY ${ADD_REGION_OBJECT}_REGIONS ${ADD_REGION_REGION})
+endfunction()
+
+function(add_group)
+  cmake_parse_arguments(ADD_GROUP "" "OBJECT;GROUP" "" ${ARGN})
+
+  get_property(exists GLOBAL PROPERTY ${ADD_GROUP_OBJECT})
+  if(NOT exists)
+    message(FATAL_ERROR
+      "Adding group ${ADD_GROUP_GROUP} to none-existing object: "
+      "${ADD_GROUP_OBJECT}"
+    )
+  endif()
+
+  get_property(vma GLOBAL PROPERTY ${ADD_GROUP_GROUP}_VMA)
+  get_property(object_name GLOBAL PROPERTY ${ADD_GROUP_OBJECT}_NAME)
+
+  if((NOT DEFINED vma) OR ("${vma}" STREQUAL ${object_name}))
+    set_property(GLOBAL APPEND PROPERTY ${ADD_GROUP_OBJECT}_GROUPS ${ADD_GROUP_GROUP})
+  else()
+    set_property(GLOBAL APPEND PROPERTY ${ADD_GROUP_OBJECT}_${vma}_GROUPS ${ADD_GROUP_GROUP})
+  endif()
+endfunction()
+
+function(add_section)
+  cmake_parse_arguments(ADD_SECTION "" "OBJECT;SECTION;ADDRESS;VMA" "" ${ARGN})
+
+  if(DEFINED ADD_SECTION_OBJECT)
+    get_property(type GLOBAL PROPERTY ${ADD_SECTION_OBJECT}_OBJ_TYPE)
+    get_property(object_name GLOBAL PROPERTY ${ADD_SECTION_OBJECT}_NAME)
+
+    if(NOT DEFINED type)
+      message(FATAL_ERROR
+              "Adding section ${ADD_SECTION_SECTION} to "
+              "none-existing object: ${ADD_SECTION_OBJECT}"
+      )
+    endif()
+  else()
+    set(ADD_SECTION_OBJECT RELOCATEABLE)
+  endif()
+
+  if("${ADD_SECTION_VMA}" STREQUAL "${object_name}" AND DEFINED ADD_SECTION_ADDRESS)
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_SECTIONS_FIXED
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  elseif(NOT DEFINED ADD_SECTION_VMA AND DEFINED SECTION_ADDRESS)
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_SECTIONS_FIXED
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  elseif("${ADD_SECTION_VMA}" STREQUAL "${object_name}")
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_SECTIONS
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  elseif(NOT DEFINED ADD_SECTION_VMA)
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_SECTIONS
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  elseif(DEFINED SECTION_ADDRESS)
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_${ADD_SECTION_VMA}_SECTIONS_FIXED
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  else()
+    set_property(GLOBAL APPEND PROPERTY
+      ${ADD_SECTION_OBJECT}_${ADD_SECTION_VMA}_SECTIONS
+      SECTION_${ADD_SECTION_SECTION}
+    )
+  endif()
+endfunction()
+
+function(add_symbol)
+  cmake_parse_arguments(ADD_SYMBOL "" "OBJECT;SYMBOL" "" ${ARGN})
+
+  # Section can be fixed address or not, VMA == LMA, .
+  #
+  get_property(exists GLOBAL PROPERTY ${ADD_SYMBOL_OBJECT})
+  if(NOT exists)
+    message(FATAL_ERROR
+      "Adding symbol ${ADD_SYMBOL_SYMBOL} to none-existing object: "
+      "${ADD_SYMBOL_OBJECT}"
+    )
+  endif()
+
+  set_property(GLOBAL APPEND PROPERTY ${ADD_SYMBOL_OBJECT}_SYMBOLS ${ADD_SYMBOL_SYMBOL})
+endfunction()
+
+#
+# Add functions - end
+#
+
+#
+# Retrieval functions - start
+#
+function(find_object)
+  cmake_parse_arguments(FIND "" "OBJECT;NAME" "" ${ARGN})
+
+  get_property(REGION  GLOBAL PROPERTY REGION_${FIND_NAME})
+  get_property(GROUP   GLOBAL PROPERTY GROUP_${FIND_NAME})
+  get_property(SECTION GLOBAL PROPERTY SECTION_${FIND_NAME})
+
+  if(REGION)
+    set(${FIND_OBJECT} REGION_${FIND_NAME} PARENT_SCOPE)
+  elseif(GROUP)
+    set(${FIND_OBJECT} GROUP_${FIND_NAME} PARENT_SCOPE)
+  elseif(SECTION)
+    set(${FIND_OBJECT} SECTION_${FIND_NAME} PARENT_SCOPE)
+  else()
+    message(WARNING "No object with name ${FIND_NAME} could be found.")
+  endif()
+endfunction()
+
+function(get_objects)
+  cmake_parse_arguments(GET "" "LIST;OBJECT;TYPE" "" ${ARGN})
+
+  get_property(type GLOBAL PROPERTY ${GET_OBJECT}_OBJ_TYPE)
+
+  if(${type} STREQUAL SECTION)
+    # A section doesn't have sub-items.
+    return()
+  endif()
+
+  if(NOT (${GET_TYPE} STREQUAL SECTION
+     OR   ${GET_TYPE} STREQUAL GROUP)
+  )
+    message(WARNING "Only retrieval of SECTION GROUP objects are supported.")
+    return()
+  endif()
+
+  set(out)
+
+  get_parent(OBJECT ${GET_OBJECT} PARENT parent TYPE SYSTEM)
+  get_property(regions GLOBAL PROPERTY ${parent}_REGIONS)
+  list(REMOVE_ITEM regions ${GET_OBJECT})
+
+  if(${GET_TYPE} STREQUAL SECTION)
+    get_property(sections GLOBAL PROPERTY ${GET_OBJECT}_SECTIONS_FIXED)
+    list(APPEND out ${sections})
+
+    get_property(groups GLOBAL PROPERTY ${GET_OBJECT}_GROUPS)
+    foreach(group ${groups})
+      get_objects(LIST sections OBJECT ${group} TYPE ${GET_TYPE})
+      list(APPEND out ${sections})
+    endforeach()
+
+    get_property(sections GLOBAL PROPERTY ${GET_OBJECT}_SECTIONS)
+    list(APPEND out ${sections})
+
+    foreach(region ${regions})
+      get_property(vma GLOBAL PROPERTY ${region}_NAME)
+
+      get_property(sections GLOBAL PROPERTY ${GET_OBJECT}_${vma}_SECTIONS_FIXED)
+      list(APPEND out ${sections})
+
+      get_property(groups GLOBAL PROPERTY ${GET_OBJECT}_${vma}_GROUPS)
+      foreach(group ${groups})
+        get_objects(LIST sections OBJECT ${group} TYPE ${GET_TYPE})
+        list(APPEND out ${sections})
+      endforeach()
+
+      get_property(sections GLOBAL PROPERTY ${GET_OBJECT}_${vma}_SECTIONS)
+      list(APPEND out ${sections})
+    endforeach()
+  endif()
+
+  if(${GET_TYPE} STREQUAL GROUP)
+    get_property(groups GLOBAL PROPERTY ${GET_OBJECT}_GROUPS)
+    list(APPEND out ${groups})
+
+    foreach(group ${groups})
+      get_objects(LIST subgroups OBJECT ${group} TYPE ${GET_TYPE})
+      list(APPEND out ${subgroups})
+    endforeach()
+
+    foreach(region ${regions})
+      get_property(vma GLOBAL PROPERTY ${region}_NAME)
+
+      get_property(groups GLOBAL PROPERTY ${GET_OBJECT}_${vma}_GROUPS)
+      list(APPEND out ${groups})
+
+      foreach(group ${groups})
+        get_objects(LIST subgroups OBJECT ${group} TYPE ${GET_TYPE})
+        list(APPEND out ${subgroups})
+      endforeach()
+    endforeach()
+  endif()
+
+  set(${GET_LIST} ${out} PARENT_SCOPE)
+endfunction()
+
+#
+# Retrieval functions - end
+#
+
+function(is_empty)
+  cmake_parse_arguments(IS_EMPTY "" "OBJECT" "" ${ARGN})
+
+  get_property(sections GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_SECTIONS_FIXED)
+  if(DEFINED sections)
+    set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+    return()
+  endif()
+
+  get_property(groups GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_GROUPS)
+  if(DEFINED groups)
+    set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+    return()
+  endif()
+
+
+  get_property(sections GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_SECTIONS)
+  if(DEFINED sections)
+    set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+    return()
+  endif()
+
+  get_parent(OBJECT ${IS_EMPTY_OBJECT} PARENT parent TYPE SYSTEM)
+  get_property(regions GLOBAL PROPERTY ${parent}_REGIONS)
+  list(REMOVE_ITEM regions ${IS_EMPTY_OBJECT})
+  foreach(region ${regions})
+    get_property(vma GLOBAL PROPERTY ${region}_NAME)
+    get_property(sections GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_${vma}_SECTIONS_FIXED)
+    if(DEFINED sections)
+      set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+      return()
+    endif()
+
+    get_property(groups GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_${vma}_GROUPS)
+    if(DEFINED groups)
+      set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+      return()
+    endif()
+
+    get_property(sections GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_${vma}_SECTIONS)
+    if(DEFINED sections)
+      set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY FALSE)
+      return()
+    endif()
+  endforeach()
+  set_property(GLOBAL PROPERTY ${IS_EMPTY_OBJECT}_EMPTY TRUE)
+endfunction()
+
+# This function post process the region for easier use.
+#
+# This is common post processing.
+# If the calling <linker>_script.cmake generator implements its own
+# process_region(), then the process_region_common() must be called explicitly
+# from the process_region() from the <linker>_script.cmake generator.
+#
+# This allows a custom <linker>_script.cmake generator to completely disable
+# the common post processing of regions.
+#
+# Tasks:
+# - Apply missing settings, such as initial address for first section in a region.
+# - Symbol names on sections
+# - Ordered list of all sections for easier retrival on printing and configuration.
+function(process_region_common)
+  cmake_parse_arguments(REGION_COMMON "" "OBJECT" "" ${ARGN})
+
+  is_empty(OBJECT ${REGION_COMMON_OBJECT})
+
+  set(sections)
+  get_objects(LIST sections OBJECT ${REGION_COMMON_OBJECT} TYPE SECTION)
+  set_property(GLOBAL PROPERTY ${REGION_COMMON_OBJECT}_SECTION_LIST_ORDERED ${sections})
+
+  set(groups)
+  get_objects(LIST groups OBJECT ${REGION_COMMON_OBJECT} TYPE GROUP)
+  set_property(GLOBAL PROPERTY ${REGION_COMMON_OBJECT}_GROUP_LIST_ORDERED ${groups})
+
+  list(LENGTH sections section_count)
+  if(section_count GREATER 0)
+    list(GET sections 0 section)
+    get_property(address GLOBAL PROPERTY ${section}_ADDRESS)
+    if(NOT DEFINED address)
+      get_parent(OBJECT ${REGION_COMMON_OBJECT} PARENT parent TYPE REGION)
+      get_property(address GLOBAL PROPERTY ${parent}_ADDRESS)
+      set_property(GLOBAL PROPERTY ${section}_ADDRESS ${address})
+    endif()
+  endif()
+
+  get_parent(OBJECT ${REGION_COMMON_OBJECT} PARENT parent TYPE SYSTEM)
+  get_property(regions GLOBAL PROPERTY ${parent}_REGIONS)
+  list(REMOVE_ITEM regions ${REGION_COMMON_OBJECT})
+  foreach(region ${regions})
+    get_property(vma GLOBAL PROPERTY ${region}_NAME)
+    set(sections_${vma})
+    get_property(sections GLOBAL PROPERTY ${REGION_COMMON_OBJECT}_${vma}_SECTIONS_FIXED)
+    list(APPEND sections_${vma} ${sections})
+
+    get_property(groups GLOBAL PROPERTY ${REGION_COMMON_OBJECT}_${vma}_GROUPS)
+    foreach(group ${groups})
+      get_objects(LIST sections OBJECT ${group} TYPE SECTION)
+      list(APPEND sections_${vma} ${sections})
+    endforeach()
+
+    get_property(sections GLOBAL PROPERTY ${REGION_COMMON_OBJECT}_${vma}_SECTIONS)
+    list(APPEND sections_${vma} ${sections})
+
+    list(LENGTH sections_${vma} section_count)
+    if(section_count GREATER 0)
+      list(GET sections_${vma} 0 section)
+      get_property(address GLOBAL PROPERTY ${section}_ADDRESS)
+      if(NOT DEFINED address)
+        get_property(address GLOBAL PROPERTY ${region}_ADDRESS)
+        set_property(GLOBAL PROPERTY ${section}_ADDRESS ${address})
+      endif()
+    endif()
+  endforeach()
+endfunction()
+
+if(NOT COMMAND process_region)
+  function(process_region)
+    process_region_common(${ARGN})
+  endfunction()
+endif()
+
+
+#
+# String functions - start
+#
+# Each linker must implement their own <type>_to_string() functions to
+# generate a correct linker script.
+#
+if(NOT COMMAND system_to_string)
+  function(system_to_string)
+    message(WARNING "No linker defined function found. Please implement a "
+                    "system_to_string() function for this linker."
+    )
+  endfunction()
+endif()
+
+if(NOT COMMAND group_to_string)
+  function(group_to_string)
+    message(WARNING "No linker defined function found. Please implement a "
+                    "group_to_string() function for this linker."
+    )
+  endfunction()
+endif()
+
+if(NOT COMMAND section_to_string)
+  function(section_to_string)
+    message(WARNING "No linker defined function found. Please implement a "
+                    "section_to_string() function for this linker."
+    )
+  endfunction()
+endif()
+
+if(NOT COMMAND symbol_to_string)
+  function(symbol_to_string)
+    message(WARNING "No linker defined function found. Please implement a "
+                    "symbol_to_string() function for this linker."
+    )
+  endfunction()
+endif()
+
+function(to_string)
+  cmake_parse_arguments(STRING "" "OBJECT;STRING" "" ${ARGN})
+
+  get_property(type GLOBAL PROPERTY ${STRING_OBJECT}_OBJ_TYPE)
+
+  if("${type}" STREQUAL SYSTEM)
+    system_to_string(OBJECT ${STRING_OBJECT} STRING ${STRING_STRING})
+  elseif(("${type}" STREQUAL REGION) OR ("${type}" STREQUAL GROUP))
+    group_to_string(OBJECT ${STRING_OBJECT} STRING ${STRING_STRING})
+  elseif("${type}" STREQUAL SECTION)
+    section_to_string(SECTION ${STRING_OBJECT} STRING ${STRING_STRING})
+  elseif("${type}" STREQUAL SYMBOL)
+    symbol_to_string(SYMBOL ${STRING_OBJECT} STRING ${STRING_STRING})
+  endif()
+
+  set(${STRING_STRING} ${${STRING_STRING}} PARENT_SCOPE)
+endfunction()
+
+#
+# String functions - end
+#
+
+create_system(OBJECT new_system NAME ZEPHYR_LINKER_v1 FORMAT ${FORMAT} ENTRY ${ENTRY})
+
+# Sorting the memory sections in ascending order.
+foreach(region ${MEMORY_REGIONS})
+  if("${region}" MATCHES "^{(.*)}$")
+    cmake_parse_arguments(REGION "" "NAME;START" "" ${CMAKE_MATCH_1})
+    math(EXPR start_dec "${REGION_START}" OUTPUT_FORMAT DECIMAL)
+    set(region_id ${start_dec}_${REGION_NAME})
+    set(region_${region_id} ${region})
+    string(REPLACE ";" "\;" region_${region_id} "${region_${region_id}}")
+    list(APPEND region_sort ${region_id})
+  endif()
+endforeach()
+
+list(SORT region_sort COMPARE NATURAL)
+set(MEMORY_REGIONS_SORTED)
+foreach(region_start ${region_sort})
+  list(APPEND MEMORY_REGIONS_SORTED "${region_${region_start}}")
+endforeach()
+# sorting complete.
+
+foreach(region ${MEMORY_REGIONS_SORTED})
+  if("${region}" MATCHES "^{(.*)}$")
+    create_region(OBJECT new_region ${CMAKE_MATCH_1})
+
+    add_region(OBJECT ${new_system} REGION ${new_region})
+  endif()
+endforeach()
+
+foreach(group ${GROUPS})
+  if("${group}" MATCHES "^{(.*)}$")
+    create_group(OBJECT new_group ${CMAKE_MATCH_1})
+  endif()
+endforeach()
+
+foreach(section ${SECTIONS})
+  if("${section}" MATCHES "^{(.*)}$")
+    create_section(${CMAKE_MATCH_1} SYSTEM ${new_system})
+  endif()
+endforeach()
+
+foreach(symbol ${SYMBOLS})
+  if("${symbol}" MATCHES "^{(.*)}$")
+    create_symbol(OBJECT ${new_system} ${CMAKE_MATCH_1})
+  endif()
+endforeach()
+
+get_property(regions GLOBAL PROPERTY ${new_system}_REGIONS)
+foreach(region ${regions})
+  process_region(OBJECT ${region})
+endforeach()
+
+set(OUT)
+to_string(OBJECT ${new_system} STRING OUT)
+
+if(OUT_FILE)
+  file(WRITE ${OUT_FILE} "${OUT}")
+endif()

From 9cda5a5cfb03af53a68bbf34ca97f26f46f79f9d Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 10 Jun 2021 14:12:38 +0200
Subject: [PATCH 10/20] cmake: ld: adding ld linker script generator

Adding intial version of ld_script.cmake.

This script can generate ld linker script from the Zephyr CMake linker
functions.

This script is called by the build system and all linker settings, such
as memory regions, groups, output sections, linker symbols defined with
Zephyr CMake linker functions are passed to this script in order to
generate an ld linker script.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/linker/ld/ld_script.cmake | 328 ++++++++++++++++++++++++++++++++
 1 file changed, 328 insertions(+)
 create mode 100644 cmake/linker/ld/ld_script.cmake

diff --git a/cmake/linker/ld/ld_script.cmake b/cmake/linker/ld/ld_script.cmake
new file mode 100644
index 00000000000000..c2586e43ab2c33
--- /dev/null
+++ b/cmake/linker/ld/ld_script.cmake
@@ -0,0 +1,328 @@
+# ToDo:
+# - Ensure LMA / VMA sections are correctly grouped similar to scatter file creation.
+cmake_minimum_required(VERSION 3.18)
+
+set(SORT_TYPE_NAME SORT_BY_NAME)
+
+function(system_to_string)
+  cmake_parse_arguments(STRING "" "OBJECT;STRING" "" ${ARGN})
+
+  get_property(name    GLOBAL PROPERTY ${STRING_OBJECT}_NAME)
+  get_property(regions GLOBAL PROPERTY ${STRING_OBJECT}_REGIONS)
+  get_property(format  GLOBAL PROPERTY ${STRING_OBJECT}_FORMAT)
+  get_property(entry   GLOBAL PROPERTY ${STRING_OBJECT}_ENTRY)
+  get_property(symbols GLOBAL PROPERTY ${STRING_OBJECT}_SYMBOLS)
+
+  set(${STRING_STRING} "OUTPUT_FORMAT(\"${format}\")\n\n")
+
+  set(${STRING_STRING} "${${STRING_STRING}}MEMORY\n{\n")
+  foreach(region ${regions})
+    get_property(name    GLOBAL PROPERTY ${region}_NAME)
+    get_property(address GLOBAL PROPERTY ${region}_ADDRESS)
+    get_property(flags   GLOBAL PROPERTY ${region}_FLAGS)
+    get_property(size    GLOBAL PROPERTY ${region}_SIZE)
+
+    if(DEFINED flags)
+      set(flags "(${flags})")
+    endif()
+
+    if(DEFINED address)
+      set(start ": ORIGIN = (${address})")
+    endif()
+
+    if(DEFINED size)
+      set(size ", LENGTH = (${size})")
+    endif()
+    set(memory_region "  ${name} ${flags} ${start}${size}")
+
+    set(${STRING_STRING} "${${STRING_STRING}}${memory_region}\n")
+  endforeach()
+
+  set(${STRING_STRING} "${${STRING_STRING}}}\n\n")
+
+  set(${STRING_STRING} "${${STRING_STRING}}ENTRY(\"${entry}\")\n\n")
+
+  set(${STRING_STRING} "${${STRING_STRING}}SECTIONS\n{")
+  foreach(region ${regions})
+    to_string(OBJECT ${region} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS_FIXED)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  foreach(symbol ${symbols})
+    to_string(OBJECT ${symbol} STRING ${STRING_STRING})
+  endforeach()
+
+  set(${STRING_STRING} "${${STRING_STRING}}\n}\n" PARENT_SCOPE)
+endfunction()
+
+function(symbol_to_string)
+  cmake_parse_arguments(STRING "" "SYMBOL;STRING" "" ${ARGN})
+
+  get_property(name     GLOBAL PROPERTY ${STRING_SYMBOL}_NAME)
+  get_property(expr     GLOBAL PROPERTY ${STRING_SYMBOL}_EXPR)
+  get_property(size     GLOBAL PROPERTY ${STRING_SYMBOL}_SIZE)
+  get_property(symbol   GLOBAL PROPERTY ${STRING_SYMBOL}_SYMBOL)
+  get_property(subalign GLOBAL PROPERTY ${STRING_SYMBOL}_SUBALIGN)
+
+  string(REPLACE "\\" "" expr "${expr}")
+  string(REGEX MATCHALL "%([^%]*)%" match_res ${expr})
+
+  foreach(match ${match_res})
+    string(REPLACE "%" "" match ${match})
+    string(REPLACE "%${match}%" "${match}" expr ${expr})
+  endforeach()
+
+  set(${STRING_STRING} "${${STRING_STRING}}\n${symbol} = ${expr};\n" PARENT_SCOPE)
+endfunction()
+
+function(group_to_string)
+  cmake_parse_arguments(STRING "" "OBJECT;STRING" "" ${ARGN})
+
+  get_property(type GLOBAL PROPERTY ${STRING_OBJECT}_OBJ_TYPE)
+  if(${type} STREQUAL REGION)
+    get_property(empty GLOBAL PROPERTY ${STRING_OBJECT}_EMPTY)
+    if(empty)
+      return()
+    endif()
+
+    get_property(address GLOBAL PROPERTY ${STRING_OBJECT}_ADDRESS)
+    set(${STRING_STRING} "${${STRING_STRING}}\n  . = ${address};\n\n")
+  else()
+    get_property(name GLOBAL PROPERTY ${STRING_OBJECT}_NAME)
+    string(TOLOWER ${name} name)
+    set(${STRING_STRING} "${${STRING_STRING}}\n  __${name}_start = .;\n")
+
+    get_objects(LIST sections OBJECT ${STRING_OBJECT} TYPE SECTION)
+    list(GET sections 0 section)
+    get_property(first_section_name GLOBAL PROPERTY ${section}_NAME)
+
+    set(${STRING_STRING} "${${STRING_STRING}}\n  __${name}_size = __${name}_end - __${name}_start;\n")
+    set(${STRING_STRING} "${${STRING_STRING}}\n  __${name}_load_start = LOADADDR(${first_section_name});\n")
+  endif()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS_FIXED)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(groups GLOBAL PROPERTY ${STRING_OBJECT}_GROUPS)
+  foreach(group ${groups})
+    to_string(OBJECT ${group} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  get_parent(OBJECT ${STRING_OBJECT} PARENT parent TYPE SYSTEM)
+  get_property(regions GLOBAL PROPERTY ${parent}_REGIONS)
+  list(REMOVE_ITEM regions ${STRING_OBJECT})
+  foreach(region ${regions})
+    if(${type} STREQUAL REGION)
+      get_property(address GLOBAL PROPERTY ${region}_ADDRESS)
+      set(${STRING_STRING} "${${STRING_STRING}}\n  . = ${address};\n\n")
+    endif()
+
+    get_property(vma GLOBAL PROPERTY ${region}_NAME)
+    get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_SECTIONS_FIXED)
+    foreach(section ${sections})
+      to_string(OBJECT ${section} STRING ${STRING_STRING})
+    endforeach()
+
+    get_property(groups GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_GROUPS)
+    foreach(group ${groups})
+      to_string(OBJECT ${group} STRING ${STRING_STRING})
+    endforeach()
+
+    get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_SECTIONS)
+    foreach(section ${sections})
+      to_string(OBJECT ${section} STRING ${STRING_STRING})
+    endforeach()
+  endforeach()
+
+  if(NOT ${type} STREQUAL REGION)
+    set(${STRING_STRING} "${${STRING_STRING}}\n  __${name}_end = .;\n")
+  endif()
+
+  get_property(symbols GLOBAL PROPERTY ${STRING_OBJECT}_SYMBOLS)
+  foreach(symbol ${symbols})
+    to_string(OBJECT ${symbol} STRING ${STRING_STRING})
+  endforeach()
+
+  set(${STRING_STRING} ${${STRING_STRING}} PARENT_SCOPE)
+endfunction()
+
+function(section_to_string)
+  cmake_parse_arguments(STRING "" "SECTION;STRING" "" ${ARGN})
+
+  get_property(name       GLOBAL PROPERTY ${STRING_SECTION}_NAME)
+  get_property(name_clean GLOBAL PROPERTY ${STRING_SECTION}_NAME_CLEAN)
+  get_property(address    GLOBAL PROPERTY ${STRING_SECTION}_ADDRESS)
+  get_property(type       GLOBAL PROPERTY ${STRING_SECTION}_TYPE)
+  get_property(align_in   GLOBAL PROPERTY ${STRING_SECTION}_ALIGN_WITH_INPUT)
+  get_property(align      GLOBAL PROPERTY ${STRING_SECTION}_ALIGN)
+  get_property(subalign   GLOBAL PROPERTY ${STRING_SECTION}_SUBALIGN)
+  get_property(vma        GLOBAL PROPERTY ${STRING_SECTION}_VMA)
+  get_property(lma        GLOBAL PROPERTY ${STRING_SECTION}_LMA)
+  get_property(noinput    GLOBAL PROPERTY ${STRING_SECTION}_NOINPUT)
+  get_property(noinit     GLOBAL PROPERTY ${STRING_SECTION}_NOINIT)
+  get_property(nosymbols  GLOBAL PROPERTY ${STRING_SECTION}_NOSYMBOLS)
+  get_property(parent     GLOBAL PROPERTY ${STRING_SECTION}_PARENT)
+
+  string(REGEX REPLACE "^[\.]" "" name_clean "${name}")
+  string(REPLACE "." "_" name_clean "${name_clean}")
+
+  set(SECTION_TYPE_NOLOAD NOLOAD)
+  set(SECTION_TYPE_BSS    NOLOAD)
+  if(DEFINED type)
+    set(type " (${SECTION_TYPE_${type}})")
+  endif()
+
+  set(TEMP "${TEMP} :")
+  set(secalign "")
+
+  if(align_in)
+    set(secalign " ALIGN_WITH_INPUT")
+  endif()
+
+  if(DEFINED align)
+    set(secalign "${secalign} ALIGN(${align})")
+  endif()
+
+  if(DEFINED subalign)
+    set(secalign "${secalign} SUBALIGN(${subalign})")
+  endif()
+
+  set(TEMP "${name} ${address}${type} :${secalign}\n{")
+  if(NOT nosymbols)
+    set(TEMP "${TEMP}\n  __${name_clean}_start = .;")
+  endif()
+
+  if(NOT noinput)
+    set(TEMP "${TEMP}\n  *(${name})")
+    set(TEMP "${TEMP}\n  *(\"${name}.*\")")
+  endif()
+
+  get_property(indicies GLOBAL PROPERTY ${STRING_SECTION}_SETTINGS_INDICIES)
+  foreach(idx ${indicies})
+    get_property(align    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_ALIGN)
+    get_property(any      GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_ANY)
+    get_property(first    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_FIRST)
+    get_property(keep     GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_KEEP)
+    get_property(sort     GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_SORT)
+    get_property(flags    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_FLAGS)
+    get_property(input    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_INPUT)
+    get_property(symbols  GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_SYMBOLS)
+    get_property(offset   GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_OFFSET)
+
+    if(DEFINED SETTINGS_ALIGN)
+      set(TEMP "${TEMP}\n  . = ALIGN(${align});")
+    endif()
+
+    if(DEFINED symbols)
+      list(LENGTH symbols symbols_count)
+      if(${symbols_count} GREATER 0)
+        list(GET symbols 0 symbol_start)
+      endif()
+      if(${symbols_count} GREATER 1)
+        list(GET symbols 1 symbol_end)
+      endif()
+    endif()
+
+    if(DEFINED symbol_start)
+      set(TEMP "${TEMP}\n  ${symbol_start} = .;")
+    endif()
+
+    foreach(setting ${input})
+      if(DEFINED offset AND NOT ("${offset}" STREQUAL "${current_offset}"))
+        set(TEMP "${TEMP}\n  . = ${offset};")
+        set(current_offset ${offset})
+      endif()
+
+      if(keep AND sort)
+        set(TEMP "${TEMP}\n  KEEP(*(${SORT_TYPE_${sort}}(${setting})));")
+      elseif(SETTINGS_SORT)
+        message(WARNING "Not tested")
+        set(TEMP "${TEMP}\n  *(${SORT_TYPE_${sort}}(${setting}));")
+      elseif(keep)
+        set(TEMP "${TEMP}\n  KEEP(*(${setting}));")
+      else()
+        set(TEMP "${TEMP}\n  *(${setting})")
+      endif()
+    endforeach()
+
+    if(DEFINED symbol_end)
+      set(TEMP "${TEMP}\n  ${symbol_end} = .;")
+    endif()
+
+    set(symbol_start)
+    set(symbol_end)
+  endforeach()
+
+  if(NOT nosymbols)
+    set(TEMP "${TEMP}\n  __${name_clean}_end = .;")
+  endif()
+
+  set(TEMP "${TEMP}\n}")
+
+  get_property(parent_type GLOBAL PROPERTY ${parent}_OBJ_TYPE)
+  if(${parent_type} STREQUAL GROUP)
+    get_property(vma GLOBAL PROPERTY ${parent}_VMA)
+    get_property(lma GLOBAL PROPERTY ${parent}_LMA)
+  endif()
+
+  if(DEFINED vma)
+    set(TEMP "${TEMP} > ${vma}")
+  endif()
+
+  if(DEFINED vma AND DEFINED lma)
+    set(TEMP "${TEMP} AT")
+  endif()
+
+  if(DEFINED lma)
+    set(TEMP "${TEMP} > ${lma}")
+  endif()
+
+  if(NOT nosymbols)
+    set(TEMP "${TEMP}\n__${name_clean}_size = __${name_clean}_end - __${name_clean}_start;")
+    set(TEMP "${TEMP}\n__${name_clean}_load_start = LOADADDR(${name});")
+  endif()
+
+  set(${STRING_STRING} "${${STRING_STRING}}\n${TEMP}\n" PARENT_SCOPE)
+endfunction()
+
+# /DISCARD/ is an ld specific section, so let's append it here before processing.
+list(APPEND SECTIONS "{NAME\;/DISCARD/\;NOINPUT\;TRUE\;NOSYMBOLS\;TRUE}")
+
+function(process_region)
+  cmake_parse_arguments(REGION "" "OBJECT" "" ${ARGN})
+
+  process_region_common(${ARGN})
+
+  set(groups)
+  get_objects(LIST groups OBJECT ${REGION_OBJECT} TYPE GROUP)
+  foreach(group ${groups})
+    get_property(parent GLOBAL PROPERTY ${group}_PARENT)
+    get_property(parent_type GLOBAL PROPERTY ${parent}_OBJ_TYPE)
+
+    if(${parent_type} STREQUAL GROUP)
+      get_property(vma GLOBAL PROPERTY ${parent}_VMA)
+      get_property(lma GLOBAL PROPERTY ${parent}_LMA)
+
+      set_property(GLOBAL PROPERTY ${group}_VMA ${vma})
+      set_property(GLOBAL PROPERTY ${group}_LMA ${lma})
+    endif()
+  endforeach()
+endfunction()
+
+include(${CMAKE_CURRENT_LIST_DIR}/../linker_script_common.cmake)

From 703ede088041b13eb8d989a6c9bac51df10ea2d4 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Wed, 9 Jun 2021 11:22:07 +0200
Subject: [PATCH 11/20] kconfig: cmake: CMake linker script generator symbol
 added

A "Linker script" choice group has been added to the linker options
menu.

The existing HAVE_CUSTOM_LINKER_SCRIPT config has been relocated inside
the linker script menu.

Two new entries has been created:
- LD template, for using the old ld template files together with the C
  pre-processor to create the final linker script.
- CMake linker generator, used for ARMClang / armlink toolchain.
  The CMake linker generator is also supported for LD linker scripts
  for the ARM architecture.

In CMake, the file cmake/linker/ld/target.cmake has been updated to
support the CMake LD linker generator.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 Kconfig.zephyr               |  30 +++++++++-
 cmake/linker/ld/target.cmake | 109 +++++++++++++++++++++--------------
 2 files changed, 95 insertions(+), 44 deletions(-)

diff --git a/Kconfig.zephyr b/Kconfig.zephyr
index 383e91c10efe3a..4f92cd07c568c6 100644
--- a/Kconfig.zephyr
+++ b/Kconfig.zephyr
@@ -132,8 +132,36 @@ config ROM_START_OFFSET
 	  alignment requirements on most ARM targets, although some targets
 	  may require smaller or larger values.
 
+config LD_LINKER_SCRIPT_SUPPORTED
+	bool
+	default y
+
+choice LINKER_SCRIPT
+	prompt "Linker script"
+	default LD_LINKER_TEMPLATE if LD_LINKER_SCRIPT_SUPPORTED
+
+config LD_LINKER_TEMPLATE
+	bool "LD template"
+	depends on LD_LINKER_SCRIPT_SUPPORTED
+	help
+	  Select this option to use the LD linker script templates.
+	  The templates are pre-processed by the C pre-processor to create the
+	  final LD linker script.
+
+config CMAKE_LINKER_GENERATOR
+	bool "CMake generator"
+	depends on ARM
+	help
+	  Select this option to use the Zephyr CMake linker script generator.
+	  The linker configuration is written in CMake and the final linker
+	  script will be generated by the toolchain specific linker generator.
+	  For LD based linkers, this will be the ld generator, for ARMClang /
+	  armlink based linkers it will be the scatter generator.
+
+endchoice
+
 config HAVE_CUSTOM_LINKER_SCRIPT
-	bool "Custom linker scripts provided"
+	bool "Custom linker script provided"
 	help
 	  Set this option if you have a custom linker script which needed to
 	  be define in CUSTOM_LINKER_SCRIPT.
diff --git a/cmake/linker/ld/target.cmake b/cmake/linker/ld/target.cmake
index 2bef796673f01c..b83dc5bb041518 100644
--- a/cmake/linker/ld/target.cmake
+++ b/cmake/linker/ld/target.cmake
@@ -31,51 +31,74 @@ endif()
 macro(configure_linker_script linker_script_gen linker_pass_define)
   set(extra_dependencies ${ARGN})
 
-  # Different generators deal with depfiles differently.
-  if(CMAKE_GENERATOR STREQUAL "Unix Makefiles")
-    # Note that the IMPLICIT_DEPENDS option is currently supported only
-    # for Makefile generators and will be ignored by other generators.
-    set(linker_script_dep IMPLICIT_DEPENDS C ${LINKER_SCRIPT})
-  elseif(CMAKE_GENERATOR STREQUAL "Ninja")
-    # Using DEPFILE with other generators than Ninja is an error.
-    set(linker_script_dep DEPFILE ${PROJECT_BINARY_DIR}/${linker_script_gen}.dep)
+  if(CONFIG_CMAKE_LINKER_GENERATOR)
+    if("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_PREBUILT")
+      set(PASS 1)
+    elseif("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_FINAL;-DLINKER_PASS2")
+      set(PASS 2)
+    endif()
+
+    add_custom_command(
+      OUTPUT ${linker_script_gen}
+      COMMAND ${CMAKE_COMMAND}
+        -DPASS=${PASS}
+        -DFORMAT="$<TARGET_PROPERTY:linker,FORMAT>"
+        -DENTRY="$<TARGET_PROPERTY:linker,ENTRY>"
+        -DMEMORY_REGIONS="$<TARGET_PROPERTY:linker,MEMORY_REGIONS>"
+        -DGROUPS="$<TARGET_PROPERTY:linker,GROUPS>"
+        -DSECTIONS="$<TARGET_PROPERTY:linker,SECTIONS>"
+        -DSECTION_SETTINGS="$<TARGET_PROPERTY:linker,SECTION_SETTINGS>"
+        -DSYMBOLS="$<TARGET_PROPERTY:linker,SYMBOLS>"
+        -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/${linker_script_gen}
+        -P ${ZEPHYR_BASE}/cmake/linker/ld/ld_script.cmake
+      )
   else()
-    # TODO: How would the linker script dependencies work for non-linker
-    # script generators.
-    message(STATUS "Warning; this generator is not well supported. The
-  Linker script may not be regenerated when it should.")
-    set(linker_script_dep "")
-  endif()
+    # Different generators deal with depfiles differently.
+    if(CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+      # Note that the IMPLICIT_DEPENDS option is currently supported only
+      # for Makefile generators and will be ignored by other generators.
+      set(linker_script_dep IMPLICIT_DEPENDS C ${LINKER_SCRIPT})
+    elseif(CMAKE_GENERATOR STREQUAL "Ninja")
+      # Using DEPFILE with other generators than Ninja is an error.
+      set(linker_script_dep DEPFILE ${PROJECT_BINARY_DIR}/${linker_script_gen}.dep)
+    else()
+      # TODO: How would the linker script dependencies work for non-linker
+      # script generators.
+      message(STATUS "Warning; this generator is not well supported. The
+    Linker script may not be regenerated when it should.")
+      set(linker_script_dep "")
+    endif()
 
-  zephyr_get_include_directories_for_lang(C current_includes)
-  get_filename_component(base_name ${CMAKE_CURRENT_BINARY_DIR} NAME)
-  get_property(current_defines GLOBAL PROPERTY PROPERTY_LINKER_SCRIPT_DEFINES)
-
-  add_custom_command(
-    OUTPUT ${linker_script_gen}
-    DEPENDS
-    ${LINKER_SCRIPT}
-    ${AUTOCONF_H}
-    ${extra_dependencies}
-    # NB: 'linker_script_dep' will use a keyword that ends 'DEPENDS'
-    ${linker_script_dep}
-    COMMAND ${CMAKE_C_COMPILER}
-    -x assembler-with-cpp
-    ${NOSYSDEF_CFLAG}
-    -MD -MF ${linker_script_gen}.dep -MT ${base_name}/${linker_script_gen}
-    -D_LINKER
-    -D_ASMLANGUAGE
-    -imacros ${AUTOCONF_H}
-    ${current_includes}
-    ${current_defines}
-    ${linker_pass_define}
-    -E ${LINKER_SCRIPT}
-    -P # Prevent generation of debug `#line' directives.
-    -o ${linker_script_gen}
-    VERBATIM
-    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-    COMMAND_EXPAND_LISTS
-  )
+    zephyr_get_include_directories_for_lang(C current_includes)
+    get_filename_component(base_name ${CMAKE_CURRENT_BINARY_DIR} NAME)
+    get_property(current_defines GLOBAL PROPERTY PROPERTY_LINKER_SCRIPT_DEFINES)
+
+    add_custom_command(
+      OUTPUT ${linker_script_gen}
+      DEPENDS
+      ${LINKER_SCRIPT}
+      ${AUTOCONF_H}
+      ${extra_dependencies}
+      # NB: 'linker_script_dep' will use a keyword that ends 'DEPENDS'
+      ${linker_script_dep}
+      COMMAND ${CMAKE_C_COMPILER}
+      -x assembler-with-cpp
+      ${NOSYSDEF_CFLAG}
+      -MD -MF ${linker_script_gen}.dep -MT ${base_name}/${linker_script_gen}
+      -D_LINKER
+      -D_ASMLANGUAGE
+      -imacros ${AUTOCONF_H}
+      ${current_includes}
+      ${current_defines}
+      ${linker_pass_define}
+      -E ${LINKER_SCRIPT}
+      -P # Prevent generation of debug `#line' directives.
+      -o ${linker_script_gen}
+      VERBATIM
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+      COMMAND_EXPAND_LISTS
+    )
+  endif()
 endmacro()
 
 # Force symbols to be entered in the output file as undefined symbols

From 1e11c737618c2e80f9dbf262d1d2d50feb65fd34 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Tue, 20 Apr 2021 13:55:43 +0200
Subject: [PATCH 12/20] armclang: adding toolchain/armclang.h header

The armclang.h includes the toolchain/llvm.h header.

Also it redifines the __GENERIC_SECTION and Z_GENERIC_SECTION so that
they includes the `used` attribute which is needed by armlink.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 include/toolchain.h          |  2 ++
 include/toolchain/armclang.h | 23 +++++++++++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 include/toolchain/armclang.h

diff --git a/include/toolchain.h b/include/toolchain.h
index efdb28ee7c50a5..f5f907a75f8f4b 100644
--- a/include/toolchain.h
+++ b/include/toolchain.h
@@ -42,6 +42,8 @@
 #include <toolchain/xcc.h>
 #elif defined(__CCAC__)
 #include <toolchain/mwdt.h>
+#elif defined(__ARMCOMPILER_VERSION)
+#include <toolchain/armclang.h>
 #elif defined(__llvm__)
 #include <toolchain/llvm.h>
 #elif defined(__GNUC__) || (defined(_LINKER) && defined(__GCC_LINKER_CMD__))
diff --git a/include/toolchain/armclang.h b/include/toolchain/armclang.h
new file mode 100644
index 00000000000000..92e7a8de7461cb
--- /dev/null
+++ b/include/toolchain/armclang.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZEPHYR_INCLUDE_TOOLCHAIN_ARMCLANG_H_
+#define ZEPHYR_INCLUDE_TOOLCHAIN_ARMCLANG_H_
+
+
+#include <toolchain/llvm.h>
+
+/*
+ * To reuse as much as possible from the llvm.h header we only redefine the
+ * __GENERIC_SECTION and Z_GENERIC_SECTION macros here to include the `used` keyword.
+ */
+#undef __GENERIC_SECTION
+#undef Z_GENERIC_SECTION
+
+#define __GENERIC_SECTION(segment) __attribute__((section(STRINGIFY(segment)), used))
+#define Z_GENERIC_SECTION(segment) __GENERIC_SECTION(segment)
+
+#endif /* ZEPHYR_INCLUDE_TOOLCHAIN_ARMCLANG_H_ */

From cd22ec015dceab56cb19cdc181db4edd891752ee Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Wed, 19 May 2021 22:36:55 +0200
Subject: [PATCH 13/20] armclang: bintools support for armclang (arm-ds/Keil)

Initial bintools support for elfconvert
- hex, srec, bin conversion
- strip
- gap fill

Initial bintools support for readelf
Initial bintools support for disaasembly

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 .../armclang/elfconvert_command.cmake         | 54 ++++++++++++++
 cmake/bintools/armclang/target.cmake          | 16 +++++
 cmake/bintools/armclang/target_bintools.cmake | 71 +++++++++++++++++++
 3 files changed, 141 insertions(+)
 create mode 100644 cmake/bintools/armclang/elfconvert_command.cmake
 create mode 100644 cmake/bintools/armclang/target.cmake
 create mode 100644 cmake/bintools/armclang/target_bintools.cmake

diff --git a/cmake/bintools/armclang/elfconvert_command.cmake b/cmake/bintools/armclang/elfconvert_command.cmake
new file mode 100644
index 00000000000000..6a5549b96fceb3
--- /dev/null
+++ b/cmake/bintools/armclang/elfconvert_command.cmake
@@ -0,0 +1,54 @@
+# For armclang the elfconvert command is made into a script.
+# Reason for that is because not a single command covers all use cases,
+# and it must therefore be possible to call individual commands, depending
+# on the arguments used.
+cmake_minimum_required(VERSION 3.13)
+
+# Handle stripping
+if (STRIP_DEBUG OR STRIP_ALL)
+  set(obj_copy_target_output "--elf")
+  if(STRIP_ALL)
+    set(obj_copy_strip "--strip=all")
+  elseif(STRIP_DEBUG)
+    set(obj_copy_strip "--strip=debug")
+  endif()
+endif()
+
+# Unknown support of --srec-len in arm-ds
+
+# Handle Input and Output target types
+if(DEFINED OUTTARGET)
+  if(${OUTTARGET} STREQUAL "srec")
+    set(obj_copy_target_output "--m32")
+  elseif(${OUTTARGET} STREQUAL "ihex")
+    set(obj_copy_target_output "--i32combined")
+  elseif(${OUTTARGET} STREQUAL "binary")
+    set(obj_copy_target_output "--bincombined")
+    if(GAP_FILL)
+      set(obj_copy_gap_fill "--bincombined_padding=1,${GAP_FILL}")
+    endif()
+  endif()
+endif()
+
+if(DEFINED ONLY_SECTION AND "${OUTTARGET}" STREQUAL "binary")
+  set(obj_copy_target_output "--bin")
+  set(outfile_dir .dir)
+  string(REGEX REPLACE "^[\.]" "" only_section_clean "${ONLY_SECTION}")
+endif()
+
+# Note: fromelf is a little special regarding bin output, as each section gets
+#       its own file. This means that when only a specific section is required
+#       then that section must be moved to correct location.
+execute_process(
+  COMMAND ${FROMELF}
+    ${obj_copy_strip}
+    ${obj_copy_gap_fill} ${obj_copy_target_output}
+    --output ${OUTFILE}${outfile_dir} ${INFILE}
+)
+
+if(DEFINED ONLY_SECTION AND "${OUTTARGET}" STREQUAL "binary")
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} -E copy
+      ${OUTFILE}${outfile_dir}/${only_section_clean} ${OUTFILE}
+  )
+endif()
diff --git a/cmake/bintools/armclang/target.cmake b/cmake/bintools/armclang/target.cmake
new file mode 100644
index 00000000000000..529028f736723e
--- /dev/null
+++ b/cmake/bintools/armclang/target.cmake
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Configures binary tools as mwdt binutils
+
+find_program(CMAKE_FROMELF fromelf  PATH ${TOOLCHAIN_HOME}/bin NO_DEFAULT_PATH)
+find_program(CMAKE_AS      armasm    PATH ${TOOLCHAIN_HOME}/bin NO_DEFAULT_PATH)
+find_program(CMAKE_AR      armar     PATH ${TOOLCHAIN_HOME}/bin NO_DEFAULT_PATH)
+
+SET(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -rq <TARGET> <LINK_FLAGS> <OBJECTS>")
+SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> -rq <TARGET> <LINK_FLAGS> <OBJECTS>")
+SET(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_AR> -sq <TARGET>")
+SET(CMAKE_C_ARCHIVE_FINISH "<CMAKE_AR> -sq <TARGET>")
+
+find_program(CMAKE_GDB     ${CROSS_COMPILE}mdb     PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
+
+include(${CMAKE_CURRENT_LIST_DIR}/target_bintools.cmake)
diff --git a/cmake/bintools/armclang/target_bintools.cmake b/cmake/bintools/armclang/target_bintools.cmake
new file mode 100644
index 00000000000000..677d702c636e3e
--- /dev/null
+++ b/cmake/bintools/armclang/target_bintools.cmake
@@ -0,0 +1,71 @@
+# List of format the tool supports for converting, for example,
+# GNU tools uses objectcopyy, which supports the following: ihex, srec, binary
+set_property(TARGET bintools PROPERTY elfconvert_formats ihex binary)
+
+# armclang toolchain does not support all options in a single command
+# Therefore a CMake script is used, so that multiple commands can be executed
+# successively.
+set_property(TARGET bintools PROPERTY elfconvert_command ${CMAKE_COMMAND})
+
+set_property(TARGET bintools PROPERTY elfconvert_flag
+                                      -DFROMELF=${CMAKE_FROMELF}
+)
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_final
+                                      -P ${CMAKE_CURRENT_LIST_DIR}/elfconvert_command.cmake)
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_strip_all "-DSTRIP_ALL=True")
+set_property(TARGET bintools PROPERTY elfconvert_flag_strip_debug "-DSTRIP_DEBUG=True")
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_intarget "-DINTARGET=")
+set_property(TARGET bintools PROPERTY elfconvert_flag_outtarget "-DOUTTARGET=")
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_section_remove "-DREMOVE_SECTION=")
+set_property(TARGET bintools PROPERTY elfconvert_flag_section_only "-DONLY_SECTION=")
+
+# mwdt doesn't handle rename, consider adjusting abstraction.
+set_property(TARGET bintools PROPERTY elfconvert_flag_section_rename "-DRENAME_SECTION=")
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_gapfill "-DGAP_FILL=")
+set_property(TARGET bintools PROPERTY elfconvert_flag_srec_len "-DSREC_LEN=")
+
+set_property(TARGET bintools PROPERTY elfconvert_flag_infile "-DINFILE=")
+set_property(TARGET bintools PROPERTY elfconvert_flag_outfile "-DOUTFILE=")
+
+#
+# - disassembly : Name of command for disassembly of files
+#                 In this implementation `fromelf` is used
+#   disassembly_flag               : --disassemble
+#   disassembly_flag_final         : empty
+#   disassembly_flag_inline_source : --interleave=source
+#   disassembly_flag_all           : empty, fromelf does not differentiate on this.
+#   disassembly_flag_infile        : empty, fromelf doesn't take arguments for filenames
+#   disassembly_flag_outfile       : --output
+
+set_property(TARGET bintools PROPERTY disassembly_command ${CMAKE_FROMELF})
+set_property(TARGET bintools PROPERTY disassembly_flag --disassemble)
+set_property(TARGET bintools PROPERTY disassembly_flag_final "")
+set_property(TARGET bintools PROPERTY disassembly_flag_inline_source --interleave=source)
+set_property(TARGET bintools PROPERTY disassembly_flag_all "")
+
+set_property(TARGET bintools PROPERTY disassembly_flag_infile "")
+set_property(TARGET bintools PROPERTY disassembly_flag_outfile "--output=" )
+
+#
+# - readelf : Name of command for reading elf files.
+#             In this implementation `fromelf` is used
+#   readelf_flag          : empty
+#   readelf_flag_final    : empty
+#   readelf_flag_headers  : --text
+#   readelf_flag_infile   : empty, fromelf doesn't take arguments for filenames
+#   readelf_flag_outfile  : --output
+
+# This is using fromelf from arm-ds / Keil.
+set_property(TARGET bintools PROPERTY readelf_command ${CMAKE_FROMELF})
+
+set_property(TARGET bintools PROPERTY readelf_flag "")
+set_property(TARGET bintools PROPERTY readelf_flag_final "")
+set_property(TARGET bintools PROPERTY readelf_flag_headers --text)
+
+set_property(TARGET bintools PROPERTY readelf_flag_infile "")
+set_property(TARGET bintools PROPERTY readelf_flag_outfile "--output=")

From 5d8b1b6674816bdbca5a100f6030aafe3136528a Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Mon, 30 Nov 2020 08:59:18 +0100
Subject: [PATCH 14/20] armclang: support for armclang compiler and armlink
 linker

This is the initial support for the armclang compiler together with the
armlink linker.

Introduced in this commit:
- armclang compiler support
- armlink linker support
- armlink scatter file generator for scatter loading
- dual pass linker script generation

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/compiler/armclang/compiler_flags.cmake |   6 +
 cmake/compiler/armclang/generic.cmake        |  38 +++
 cmake/compiler/armclang/target.cmake         |  79 ++++++
 cmake/linker/armlink/scatter_script.cmake    | 270 +++++++++++++++++++
 cmake/linker/armlink/target.cmake            | 108 ++++++++
 cmake/toolchain/armclang/generic.cmake       |  21 ++
 cmake/toolchain/armclang/target.cmake        |   3 +
 7 files changed, 525 insertions(+)
 create mode 100644 cmake/compiler/armclang/compiler_flags.cmake
 create mode 100644 cmake/compiler/armclang/generic.cmake
 create mode 100644 cmake/compiler/armclang/target.cmake
 create mode 100644 cmake/linker/armlink/scatter_script.cmake
 create mode 100644 cmake/linker/armlink/target.cmake
 create mode 100644 cmake/toolchain/armclang/generic.cmake
 create mode 100644 cmake/toolchain/armclang/target.cmake

diff --git a/cmake/compiler/armclang/compiler_flags.cmake b/cmake/compiler/armclang/compiler_flags.cmake
new file mode 100644
index 00000000000000..48c0e0c798c5ad
--- /dev/null
+++ b/cmake/compiler/armclang/compiler_flags.cmake
@@ -0,0 +1,6 @@
+# First step is to inherit all properties from gcc, as clang is compatible with most flags.
+include(${ZEPHYR_BASE}/cmake/compiler/clang/compiler_flags.cmake)
+
+# Required ASM flags when using armclang, this should be handled by CMake, but
+# fails because of: https://gitlab.kitware.com/cmake/cmake/-/issues/19963
+set_property(TARGET asm APPEND PROPERTY required "--target=${triple}")
diff --git a/cmake/compiler/armclang/generic.cmake b/cmake/compiler/armclang/generic.cmake
new file mode 100644
index 00000000000000..44d34ddcdbe5f3
--- /dev/null
+++ b/cmake/compiler/armclang/generic.cmake
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Configures CMake for using ccac
+
+find_program(CMAKE_C_COMPILER ${CROSS_COMPILE}armclang PATH ${TOOLCHAIN_HOME}/bin NO_DEFAULT_PATH)
+
+set(triple arm-arm-none-eabi)
+
+set(CMAKE_DTS_PREPROCESSOR
+      ${CMAKE_C_COMPILER}
+      "--target=${triple}"
+      # -march=armv6-m is added to silence the warnings:
+      # 'armv4t' and 'arm7tdmi' is unsupported.
+      # We only do preprocessing so the actual arch is not important.
+      "-march=armv6-m"
+)
+
+set(CMAKE_C_COMPILER_TARGET   ${triple})
+set(CMAKE_ASM_COMPILER_TARGET ${triple})
+set(CMAKE_CXX_COMPILER_TARGET ${triple})
+
+if(CMAKE_C_COMPILER STREQUAL CMAKE_C_COMPILER-NOTFOUND)
+  message(FATAL_ERROR "Zephyr was unable to find the armclang compiler")
+endif()
+
+execute_process(
+  COMMAND ${CMAKE_C_COMPILER} --version
+  RESULT_VARIABLE ret
+  OUTPUT_QUIET
+  ERROR_QUIET
+  )
+
+if(ret)
+  message(FATAL_ERROR "Executing the below command failed. "
+  "Are permissions set correctly? '${CMAKE_C_COMPILER} --version' "
+  "And is the license setup correctly ?"
+  )
+endif()
diff --git a/cmake/compiler/armclang/target.cmake b/cmake/compiler/armclang/target.cmake
new file mode 100644
index 00000000000000..2a88bc294e7308
--- /dev/null
+++ b/cmake/compiler/armclang/target.cmake
@@ -0,0 +1,79 @@
+# find the compilers for C, CPP, assembly
+find_program(CMAKE_C_COMPILER ${CROSS_COMPILE}armclang PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
+find_program(CMAKE_CXX_COMPILER ${CROSS_COMPILE}armclang PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
+find_program(CMAKE_ASM_COMPILER ${CROSS_COMPILE}armclang PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
+
+# The CMAKE_REQUIRED_FLAGS variable is used by check_c_compiler_flag()
+# (and other commands which end up calling check_c_source_compiles())
+# to add additional compiler flags used during checking. These flags
+# are unused during "real" builds of Zephyr source files linked into
+# the final executable.
+#
+include(${ZEPHYR_BASE}/cmake/gcc-m-cpu.cmake)
+set(CMAKE_SYSTEM_PROCESSOR ${GCC_M_CPU})
+
+list(APPEND TOOLCHAIN_C_FLAGS
+  -fshort-enums
+  )
+
+if(CONFIG_ARM64)
+  list(APPEND TOOLCHAIN_C_FLAGS   -mcpu=${GCC_M_CPU})
+
+  list(APPEND TOOLCHAIN_C_FLAGS   -mabi=lp64)
+  list(APPEND TOOLCHAIN_LD_FLAGS  -mabi=lp64)
+else()
+  list(APPEND TOOLCHAIN_C_FLAGS   -mcpu=${GCC_M_CPU})
+
+  if(CONFIG_COMPILER_ISA_THUMB2)
+    list(APPEND TOOLCHAIN_C_FLAGS   -mthumb)
+  endif()
+
+  list(APPEND TOOLCHAIN_C_FLAGS -mabi=aapcs)
+
+  # Defines a mapping from GCC_M_CPU to FPU
+
+  if(CONFIG_CPU_HAS_FPU_DOUBLE_PRECISION)
+    set(PRECISION_TOKEN)
+  else()
+    set(PRECISION_TOKEN sp-)
+  endif()
+
+  set(FPU_FOR_cortex-m4      fpv4-${PRECISION_TOKEN}d16)
+  set(FPU_FOR_cortex-m7      fpv5-${PRECISION_TOKEN}d16)
+  set(FPU_FOR_cortex-m33     fpv5-${PRECISION_TOKEN}d16)
+
+  if(CONFIG_FPU)
+    list(APPEND TOOLCHAIN_C_FLAGS   -mfpu=${FPU_FOR_${GCC_M_CPU}})
+    if    (CONFIG_FP_SOFTABI)
+      list(APPEND TOOLCHAIN_C_FLAGS   -mfloat-abi=softfp)
+    elseif(CONFIG_FP_HARDABI)
+      list(APPEND TOOLCHAIN_C_FLAGS   -mfloat-abi=hard)
+    endif()
+  endif()
+endif()
+
+foreach(file_name include/stddef.h)
+  execute_process(
+    COMMAND ${CMAKE_C_COMPILER} --print-file-name=${file_name}
+    OUTPUT_VARIABLE _OUTPUT
+    )
+  get_filename_component(_OUTPUT "${_OUTPUT}" DIRECTORY)
+  string(REGEX REPLACE "\n" "" _OUTPUT ${_OUTPUT})
+
+  list(APPEND NOSTDINC ${_OUTPUT})
+endforeach()
+
+foreach(isystem_include_dir ${NOSTDINC})
+  list(APPEND isystem_include_flags -isystem ${isystem_include_dir})
+endforeach()
+
+set(CMAKE_REQUIRED_FLAGS -nostartfiles -nostdlib ${isystem_include_flags})
+string(REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+
+# Load toolchain_cc-family macros
+
+macro(toolchain_cc_nostdinc)
+  if(NOT "${ARCH}" STREQUAL "posix")
+    zephyr_compile_options( -nostdinc)
+  endif()
+endmacro()
diff --git a/cmake/linker/armlink/scatter_script.cmake b/cmake/linker/armlink/scatter_script.cmake
new file mode 100644
index 00000000000000..779c4cac862808
--- /dev/null
+++ b/cmake/linker/armlink/scatter_script.cmake
@@ -0,0 +1,270 @@
+cmake_minimum_required(VERSION 3.17)
+
+set(SORT_TYPE_NAME Lexical)
+
+#
+# String functions - start
+#
+
+function(system_to_string)
+  cmake_parse_arguments(STRING "" "OBJECT;STRING" "" ${ARGN})
+
+  get_property(name    GLOBAL PROPERTY ${STRING_OBJECT}_NAME)
+  get_property(regions GLOBAL PROPERTY ${STRING_OBJECT}_REGIONS)
+  get_property(format  GLOBAL PROPERTY ${STRING_OBJECT}_FORMAT)
+
+  foreach(region ${regions})
+    get_property(empty GLOBAL PROPERTY ${region}_EMPTY)
+    if(NOT empty)
+      to_string(OBJECT ${region} STRING ${STRING_STRING})
+    endif()
+  endforeach()
+
+  set(${STRING_STRING} ${${STRING_STRING}} PARENT_SCOPE)
+endfunction()
+
+function(group_to_string)
+  cmake_parse_arguments(STRING "" "OBJECT;STRING" "" ${ARGN})
+
+  get_property(type GLOBAL PROPERTY ${STRING_OBJECT}_OBJ_TYPE)
+  if(${type} STREQUAL REGION)
+    get_property(name GLOBAL PROPERTY ${STRING_OBJECT}_NAME)
+    get_property(address GLOBAL PROPERTY ${STRING_OBJECT}_ADDRESS)
+    get_property(size GLOBAL PROPERTY ${STRING_OBJECT}_SIZE)
+    set(${STRING_STRING} "${${STRING_STRING}}\n${name} ${address} NOCOMPRESS ${size}\n{\n")
+  endif()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS_FIXED)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(groups GLOBAL PROPERTY ${STRING_OBJECT}_GROUPS)
+  foreach(group ${groups})
+    to_string(OBJECT ${group} STRING ${STRING_STRING})
+  endforeach()
+
+  get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_SECTIONS)
+  foreach(section ${sections})
+    to_string(OBJECT ${section} STRING ${STRING_STRING})
+  endforeach()
+
+  get_parent(OBJECT ${STRING_OBJECT} PARENT parent TYPE SYSTEM)
+  get_property(regions GLOBAL PROPERTY ${parent}_REGIONS)
+  list(REMOVE_ITEM regions ${STRING_OBJECT})
+  foreach(region ${regions})
+    get_property(vma GLOBAL PROPERTY ${region}_NAME)
+    get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_SECTIONS_FIXED)
+    foreach(section ${sections})
+      to_string(OBJECT ${section} STRING ${STRING_STRING})
+    endforeach()
+
+    get_property(groups GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_GROUPS)
+    foreach(group ${groups})
+      to_string(OBJECT ${group} STRING ${STRING_STRING})
+    endforeach()
+
+    get_property(sections GLOBAL PROPERTY ${STRING_OBJECT}_${vma}_SECTIONS)
+    foreach(section ${sections})
+      to_string(OBJECT ${section} STRING ${STRING_STRING})
+    endforeach()
+  endforeach()
+
+  get_property(symbols GLOBAL PROPERTY ${STRING_OBJECT}_SYMBOLS)
+  foreach(symbol ${symbols})
+    to_string(OBJECT ${symbol} STRING ${STRING_STRING})
+  endforeach()
+
+  if(${type} STREQUAL REGION)
+    set(${STRING_STRING} "${${STRING_STRING}}\n}\n")
+  endif()
+  set(${STRING_STRING} ${${STRING_STRING}} PARENT_SCOPE)
+endfunction()
+
+
+function(section_to_string)
+  cmake_parse_arguments(STRING "" "SECTION;STRING" "" ${ARGN})
+
+  get_property(name     GLOBAL PROPERTY ${STRING_SECTION}_NAME)
+  get_property(address  GLOBAL PROPERTY ${STRING_SECTION}_ADDRESS)
+  get_property(type     GLOBAL PROPERTY ${STRING_SECTION}_TYPE)
+  get_property(align    GLOBAL PROPERTY ${STRING_SECTION}_ALIGN)
+  get_property(subalign GLOBAL PROPERTY ${STRING_SECTION}_SUBALIGN)
+  get_property(endalign GLOBAL PROPERTY ${STRING_SECTION}_ENDALIGN)
+  get_property(vma      GLOBAL PROPERTY ${STRING_SECTION}_VMA)
+  get_property(lma      GLOBAL PROPERTY ${STRING_SECTION}_LMA)
+  get_property(noinput  GLOBAL PROPERTY ${STRING_SECTION}_NOINPUT)
+  get_property(noinit   GLOBAL PROPERTY ${STRING_SECTION}_NOINIT)
+
+  string(REGEX REPLACE "^[\.]" "" name_clean "${name}")
+  string(REPLACE "." "_" name_clean "${name_clean}")
+
+  set(TEMP "  ${name_clean}")
+  if(DEFINED address)
+    set(TEMP "${TEMP} ${address}")
+  else()
+    set(TEMP "${TEMP} +0")
+  endif()
+
+  if(noinit)
+    # Currently we simply uses offset +0, but we must support offset defined
+    # externally.
+    set(TEMP "${TEMP} UNINIT")
+  endif()
+
+  if(subalign)
+    # Currently we simply uses offset +0, but we must support offset defined
+    # externally.
+    set(TEMP "${TEMP} ALIGN ${subalign}")
+  endif()
+
+  if(NOT noinput)
+    set(TEMP "${TEMP}\n  {")
+
+    if("${type}" STREQUAL NOLOAD)
+      set(TEMP "${TEMP}\n    *.o(${name}*)")
+      set(TEMP "${TEMP}\n    *.o(${name}*.*)")
+    elseif(VMA_FLAGS)
+      # ToDo: Proper names as provided by armclang
+#      set(TEMP "${TEMP}\n    *.o(${SEC_NAME}*, +${VMA_FLAGS})")
+#      set(TEMP "${TEMP}\n    *.o(${SEC_NAME}*.*, +${VMA_FLAGS})")
+      set(TEMP "${TEMP}\n    *.o(${name}*)")
+      set(TEMP "${TEMP}\n    *.o(${name}*.*)")
+    else()
+      set(TEMP "${TEMP}\n    *.o(${name}*)")
+      set(TEMP "${TEMP}\n    *.o(${name}*.*)")
+    endif()
+  else()
+    set(empty TRUE)
+  endif()
+
+  get_property(indicies GLOBAL PROPERTY ${STRING_SECTION}_SETTINGS_INDICIES)
+  foreach(idx ${indicies})
+    get_property(align    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_ALIGN)
+    get_property(any      GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_ANY)
+    get_property(first    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_FIRST)
+    get_property(keep     GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_KEEP)
+    get_property(sort     GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_SORT)
+    get_property(flags    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_FLAGS)
+    get_property(input    GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_INPUT)
+    get_property(offset   GLOBAL PROPERTY ${STRING_SECTION}_SETTING_${idx}_OFFSET)
+    if(DEFINED offset)
+      set(section_close TRUE)
+      math(EXPR offset_dec "${offset} + 0")
+      if(empty)
+        set(TEMP "${TEMP} EMPTY 0x0\n  {")
+        set(empty FALSE)
+      endif()
+      set(last_index ${offset_dec})
+      if(sort)
+        set(sorttype "SORTTYPE ${SORT_TYPE_${sort}}")
+      endif()
+      set(TEMP "${TEMP}\n  }")
+      set(TEMP "${TEMP}\n  ${name_clean}_${offset_dec} (ImageBase(${name_clean}) + ${offset}) ${sorttype}\n {")
+    elseif(sort)
+      set(section_close TRUE)
+      if(empty)
+        set(TEMP "${TEMP} EMPTY 0x0\n  {")
+        set(empty FALSE)
+      endif()
+      set(last_index ${idx})
+      set(TEMP "${TEMP}\n  }")
+      set(TEMP "${TEMP}\n  ${name_clean}_${idx} +0 SORTTYPE ${SORT_TYPE_${sort}}\n  {")
+    endif()
+
+    if(empty)
+      set(TEMP "${TEMP}\n  {")
+      set(empty FALSE)
+    endif()
+
+    foreach(setting ${input})
+      #set(SETTINGS ${SETTINGS_INPUT})
+
+#      # ToDo: The code below had en error in original implementation, causing
+#      #       settings not to be applied
+#      #       Verify behaviour and activate if working as intended.
+#      if(align)
+#        set(setting "${setting}, OVERALIGN ${align}")
+#      endif()
+
+      #if(SETTINGS_KEEP)
+      # armlink has --keep=<section_id>, but is there an scatter equivalant ?
+      #endif()
+
+      if(first)
+        set(setting "${setting}, +First")
+        set(first "")
+      endif()
+
+      set(TEMP "${TEMP}\n    *.o(${setting})")
+    endforeach()
+
+    if(any)
+      if(NOT flags)
+        message(FATAL_ERROR ".ANY requires flags to be set.")
+      endif()
+      string(REPLACE ";" " " flags "${flags}")
+
+      set(TEMP "${TEMP}\n    .ANY (${flags})")
+    endif()
+  endforeach()
+
+  if(section_close OR DEFINED endalign)
+    set(section_close)
+    set(TEMP "${TEMP}\n  }")
+
+    if(DEFINED endalign)
+      if(DEFINED last_index)
+        set(align_expr "AlignExpr(ImageLimit(${name_clean}_${last_index}), ${endalign}) FIXED")
+      else()
+        set(align_expr "AlignExpr(ImageLimit(${name_clean}), ${endalign}) FIXED")
+      endif()
+    else()
+      set(align_expr "+0")
+    endif()
+
+    set(TEMP "${TEMP}\n  ${name_clean}_end ${align_expr} EMPTY 0x0\n  {")
+    set(last_index)
+  endif()
+
+  set(TEMP "${TEMP}")
+  # ToDo: add patterns here.
+
+  set(TEMP "${TEMP}\n  }")
+
+  set(${STRING_STRING} "${${STRING_STRING}}\n${TEMP}\n" PARENT_SCOPE)
+endfunction()
+
+function(symbol_to_string)
+  cmake_parse_arguments(STRING "" "SYMBOL;STRING" "" ${ARGN})
+
+  get_property(name     GLOBAL PROPERTY ${STRING_SYMBOL}_NAME)
+  get_property(expr     GLOBAL PROPERTY ${STRING_SYMBOL}_EXPR)
+  get_property(size     GLOBAL PROPERTY ${STRING_SYMBOL}_SIZE)
+  get_property(symbol   GLOBAL PROPERTY ${STRING_SYMBOL}_SYMBOL)
+  get_property(subalign GLOBAL PROPERTY ${STRING_SYMBOL}_SUBALIGN)
+
+  string(REPLACE "\\" "" expr "${expr}")
+  string(REGEX MATCHALL "%([^%]*)%" match_res ${expr})
+
+  foreach(match ${match_res})
+    string(REPLACE "%" "" match ${match})
+    get_property(symbol_val GLOBAL PROPERTY SYMBOL_TABLE_${match})
+    string(REPLACE "%${match}%" "ImageBase(${symbol_val})" expr ${expr})
+  endforeach()
+
+  if(DEFINED subalign)
+    set(subalign "ALIGN ${subalign}")
+  endif()
+
+  if(NOT DEFINED size)
+    set(size "0x0")
+  endif()
+
+  set(${STRING_STRING}
+    "${${STRING_STRING}}\n  ${symbol} ${expr} ${subalign} ${size} { }\n"
+    PARENT_SCOPE
+  )
+endfunction()
+
+include(${CMAKE_CURRENT_LIST_DIR}/../linker_script_common.cmake)
diff --git a/cmake/linker/armlink/target.cmake b/cmake/linker/armlink/target.cmake
new file mode 100644
index 00000000000000..615a1b7cd25f07
--- /dev/null
+++ b/cmake/linker/armlink/target.cmake
@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# In order to ensure that the armlink symbol name is correctly passed to
+# gen_handles.py, we must first ensure that it is properly escaped.
+# For Python to work, the `$` must be passed as `\$` on command line.
+# In order to pass a single `\` to command line it must first be escaped, that is `\\`.
+# In ninja build files, a `$` is not accepted but must be passed as `$$`.
+# CMake, Python and Ninja combined results in `\\$$` in order to pass a sing `\$` to Python,
+# so `$$` thus becomes: `\\$$\\$$`.
+set_property(TARGET linker PROPERTY devices_start_symbol "Image\\$$\\$$device\\$$\\$$Base")
+
+find_program(CMAKE_LINKER ${CROSS_COMPILE}armlink PATH ${TOOLCHAIN_HOME} NO_DEFAULT_PATH)
+
+add_custom_target(armlink)
+
+macro(toolchain_ld_base)
+endmacro()
+
+function(toolchain_ld_force_undefined_symbols)
+  foreach(symbol ${ARGN})
+    zephyr_link_libraries(--undefined=${symbol})
+  endforeach()
+endfunction()
+
+macro(toolchain_ld_baremetal)
+endmacro()
+
+macro(configure_linker_script linker_script_gen linker_pass_define)
+  if("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_PREBUILT")
+    set(PASS 1)
+  elseif("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_FINAL;-DLINKER_PASS2")
+    set(PASS 2)
+  endif()
+
+  add_custom_command(
+    OUTPUT ${linker_script_gen}
+    COMMAND ${CMAKE_COMMAND}
+      -DPASS=${PASS}
+      -DMEMORY_REGIONS="$<TARGET_PROPERTY:linker,MEMORY_REGIONS>"
+      -DGROUPS="$<TARGET_PROPERTY:linker,GROUPS>"
+      -DSECTIONS="$<TARGET_PROPERTY:linker,SECTIONS>"
+      -DSECTION_SETTINGS="$<TARGET_PROPERTY:linker,SECTION_SETTINGS>"
+      -DSYMBOLS="$<TARGET_PROPERTY:linker,SYMBOLS>"
+      ${STEERING_FILE_ARG}
+      ${STEERING_C_ARG}
+      -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/${linker_script_gen}
+      -P ${ZEPHYR_BASE}/cmake/linker/armlink/scatter_script.cmake
+  )
+endmacro()
+
+function(toolchain_ld_link_elf)
+  cmake_parse_arguments(
+    TOOLCHAIN_LD_LINK_ELF                                     # prefix of output variables
+    ""                                                        # list of names of the boolean arguments
+    "TARGET_ELF;OUTPUT_MAP;LINKER_SCRIPT"                     # list of names of scalar arguments
+    "LIBRARIES_PRE_SCRIPT;LIBRARIES_POST_SCRIPT;DEPENDENCIES" # list of names of list arguments
+    ${ARGN}                                                   # input args to parse
+  )
+
+  foreach(lib ${ZEPHYR_LIBS_PROPERTY})
+    if(NOT ${lib} STREQUAL arch__arm__core__aarch32__cortex_m)
+      list(APPEND ZEPHYR_LIBS_OBJECTS $<TARGET_OBJECTS:${lib}>)
+      list(APPEND ZEPHYR_LIBS_OBJECTS $<TARGET_PROPERTY:${lib},LINK_LIBRARIES>)
+    endif()
+  endforeach()
+
+  target_link_libraries(
+    ${TOOLCHAIN_LD_LINK_ELF_TARGET_ELF}
+    ${TOOLCHAIN_LD_LINK_ELF_LIBRARIES_PRE_SCRIPT}
+    --scatter=${TOOLCHAIN_LD_LINK_ELF_LINKER_SCRIPT}
+    ${TOOLCHAIN_LD_LINK_ELF_LIBRARIES_POST_SCRIPT}
+    $<TARGET_OBJECTS:arch__arm__core__aarch32__cortex_m>
+    --map --list=${TOOLCHAIN_LD_LINK_ELF_OUTPUT_MAP}
+    ${ZEPHYR_LIBS_OBJECTS}
+    kernel
+    $<TARGET_OBJECTS:${OFFSETS_LIB}>
+    --library_type=microlib
+    --entry=$<TARGET_PROPERTY:linker,ENTRY>
+    "--keep=\"*.o(.init_*)\""
+    "--keep=\"*.o(.device_*)\""
+    # The scatter file is generated, and thus sometimes input sections are specified
+    # even though there will be no such sections found in the libraries linked.
+    --diag_suppress=6314
+    # We use empty excution sections in order to define custom symbols, such as
+    # __kernel_ram_x symbols, but nothing will go in those section, so silnence
+    # the warning. Note, marking the section EMPTY causes armlink to reserve the
+    # address which in some cases leads to overlapping section errors.
+    --diag_suppress=6312
+    # Use of '.gnu.linkonce' sections. Those are used by ld, and # supported by armlink, albeit
+    # deprecated there. For current ARMClang support phase, we accept this warning, but we should
+    # look into changing to COMDAT groups.
+    --diag_suppress=6092
+    # Wildcard matching of keep sections, Those are needed for gnu ld, and thus we inherit the same
+    # keep flags and apply them to armlink. Consider adjusting keep flags per linker in future.
+    --diag_suppress=6319
+    # Match pattern for an unused section that is being removed.
+    --diag_suppress=6329
+    ${TOOLCHAIN_LIBS_OBJECTS}
+
+    ${TOOLCHAIN_LD_LINK_ELF_DEPENDENCIES}
+  )
+endfunction(toolchain_ld_link_elf)
+
+include(${ZEPHYR_BASE}/cmake/linker/ld/target_base.cmake)
+#include(${ZEPHYR_BASE}/cmake/linker/ld/target_baremetal.cmake)
+include(${ZEPHYR_BASE}/cmake/linker/ld/target_cpp.cmake)
+include(${ZEPHYR_BASE}/cmake/linker/ld/target_relocation.cmake)
+include(${ZEPHYR_BASE}/cmake/linker/ld/target_configure.cmake)
diff --git a/cmake/toolchain/armclang/generic.cmake b/cmake/toolchain/armclang/generic.cmake
new file mode 100644
index 00000000000000..8a94102dd15f51
--- /dev/null
+++ b/cmake/toolchain/armclang/generic.cmake
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+
+set_ifndef(ARMCLANG_TOOLCHAIN_PATH "$ENV{ARMCLANG_TOOLCHAIN_PATH}")
+set(ARMCLANG_TOOLCHAIN_PATH ${ARMCLANG_TOOLCHAIN_PATH} CACHE PATH "armclang tools install directory")
+assert(ARMCLANG_TOOLCHAIN_PATH "ARMCLANG_TOOLCHAIN_PATH is not set")
+
+if(NOT EXISTS ${ARMCLANG_TOOLCHAIN_PATH})
+  message(FATAL_ERROR "Nothing found at ARMCLANG_TOOLCHAIN_PATH: '${ARMCLANG_TOOLCHAIN_PATH}'")
+endif()
+
+set(TOOLCHAIN_HOME ${ARMCLANG_TOOLCHAIN_PATH})
+
+set(COMPILER armclang)
+set(LINKER armlink)
+set(BINTOOLS armclang)
+
+set(SYSROOT_TARGET arm)
+
+set(CROSS_COMPILE ${TOOLCHAIN_HOME}/bin/)
+
+set(TOOLCHAIN_HAS_NEWLIB OFF CACHE BOOL "True if toolchain supports newlib")
diff --git a/cmake/toolchain/armclang/target.cmake b/cmake/toolchain/armclang/target.cmake
new file mode 100644
index 00000000000000..5a1a0e51313ac3
--- /dev/null
+++ b/cmake/toolchain/armclang/target.cmake
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# This file intentionally left blank.

From b3764ed0e1dc8d40f8dbb808435297b669658a5d Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Fri, 13 Aug 2021 23:24:11 +0200
Subject: [PATCH 15/20] armclang: warn on non-Ninja generator for CMake 3.20.

When using ARMClang linker and scatter files (armlink) then all
libraries are linked as object libraries using `$<TARGET_OBJECTS:lib>`.

CMake version 3.20 only has limited support for such linking:
> Referencing $<TARGET_OBJECTS> in target_link_libraries calls worked
> in versions of CMake prior to 3.21 for some cases, but was not fully
> supported.

One of those cases that do not work is Unix Makefiles generators.

As only Ninja is currently verified to work, this commit will check the
CMake version in use and the generator, and if CMake version <=3.21 is
used with non-Ninja generator then an error is raised informing user
to either use Ninja generator or update CMake.

As the Ninja generator has been confirmed to work as expected, then that
generator is accepted with CMake 3.20 and older.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/toolchain/armclang/generic.cmake | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/cmake/toolchain/armclang/generic.cmake b/cmake/toolchain/armclang/generic.cmake
index 8a94102dd15f51..769ba2c2ff02b3 100644
--- a/cmake/toolchain/armclang/generic.cmake
+++ b/cmake/toolchain/armclang/generic.cmake
@@ -4,6 +4,15 @@ set_ifndef(ARMCLANG_TOOLCHAIN_PATH "$ENV{ARMCLANG_TOOLCHAIN_PATH}")
 set(ARMCLANG_TOOLCHAIN_PATH ${ARMCLANG_TOOLCHAIN_PATH} CACHE PATH "armclang tools install directory")
 assert(ARMCLANG_TOOLCHAIN_PATH "ARMCLANG_TOOLCHAIN_PATH is not set")
 
+if(${CMAKE_VERSION} VERSION_LESS 3.21
+   AND NOT ${CMAKE_GENERATOR} STREQUAL Ninja
+)
+  message(FATAL_ERROR "ARMClang Toolchain and '${CMAKE_GENERATOR}' generator "
+    "doesn't work properly for target object files on CMake version: "
+    "${CMAKE_VERSION}. Use the 'Ninja' generator or update to CMake >= 3.21."
+  )
+endif()
+
 if(NOT EXISTS ${ARMCLANG_TOOLCHAIN_PATH})
   message(FATAL_ERROR "Nothing found at ARMCLANG_TOOLCHAIN_PATH: '${ARMCLANG_TOOLCHAIN_PATH}'")
 endif()

From 9e3041d07b0153bc7a992200e733f04fdf5571d0 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 20 May 2021 17:42:53 +0200
Subject: [PATCH 16/20] armclang: specify armlink link executable signature

The default armlink signature uses `--list=<TARGET_BASE>.map`, but in
Zephyr we uses a different name for the map file, therefore we need to
specify a custom link executable signature.

This is done in the linker specific flags file:
cmake/linker/armlink/linker_flags.cmake

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/linker/armlink/linker_flags.cmake | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 cmake/linker/armlink/linker_flags.cmake

diff --git a/cmake/linker/armlink/linker_flags.cmake b/cmake/linker/armlink/linker_flags.cmake
new file mode 100644
index 00000000000000..b0f93a7b9e7dcb
--- /dev/null
+++ b/cmake/linker/armlink/linker_flags.cmake
@@ -0,0 +1,6 @@
+# The ARMClang linker, armlink, requires a dedicated linking signature in
+# order for Zephyr to control the map file.
+
+set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> <OBJECTS> -o <TARGET>")
+set(CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> <OBJECTS> -o <TARGET>")
+set(CMAKE_ASM_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_ASM_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> <OBJECTS> -o <TARGET>")

From aee627b11afd01c9d270562389e9bf271b9017a7 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Tue, 1 Jun 2021 11:42:21 +0200
Subject: [PATCH 17/20] armclang: armlinker: armlink symbol steering file

This commit introduces armlink steering file.

A steering file in armlink allows Zephyr to keep using existing linker
symbols defined in ld scripts and used throughout the code tree.

The steering file is generated at build time in order to resolve Zephyr
linker symbols to their corresponding armlink symbols.

As example, Zephyr defines __ramfunc_start which corresponds to the
armlink auto defined Image$$ramfunc$$Base symbol.

Or __init_PRE_KERNEL_1_start which corresponds to Image$$init_0$$Base.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 cmake/linker/armlink/scatter_script.cmake | 174 ++++++++++++++++++++++
 cmake/linker/armlink/target.cmake         |  22 +++
 2 files changed, 196 insertions(+)

diff --git a/cmake/linker/armlink/scatter_script.cmake b/cmake/linker/armlink/scatter_script.cmake
index 779c4cac862808..f0ebe86741db2d 100644
--- a/cmake/linker/armlink/scatter_script.cmake
+++ b/cmake/linker/armlink/scatter_script.cmake
@@ -2,6 +2,151 @@ cmake_minimum_required(VERSION 3.17)
 
 set(SORT_TYPE_NAME Lexical)
 
+# This function post process the region for easier use.
+#
+# Tasks:
+# - Symbol translation using a steering file is configured.
+function(process_region)
+  cmake_parse_arguments(REGION "" "OBJECT" "" ${ARGN})
+
+  process_region_common(${ARGN})
+
+  get_property(empty GLOBAL PROPERTY ${REGION_OBJECT}_EMPTY)
+  if(NOT empty)
+    # For scatter files we move any system symbols into first non-empty load section.
+    get_parent(OBJECT ${REGION_OBJECT} PARENT parent TYPE SYSTEM)
+    get_property(symbols GLOBAL PROPERTY ${parent}_SYMBOLS)
+    set_property(GLOBAL APPEND PROPERTY ${REGION_OBJECT}_SYMBOLS ${symbols})
+    set_property(GLOBAL PROPERTY ${parent}_SYMBOLS)
+  endif()
+
+  get_property(sections GLOBAL PROPERTY ${REGION_OBJECT}_SECTION_LIST_ORDERED)
+  foreach(section ${sections})
+
+    get_property(name_clean GLOBAL PROPERTY ${section}_NAME_CLEAN)
+    get_property(noinput    GLOBAL PROPERTY ${section}_NOINPUT)
+    get_property(type       GLOBAL PROPERTY ${section}_TYPE)
+
+    get_property(indicies GLOBAL PROPERTY ${section}_SETTINGS_INDICIES)
+    list(LENGTH indicies length)
+    foreach(idx ${indicies})
+      set(steering_postfixes Base Limit)
+      get_property(symbols GLOBAL PROPERTY ${section}_SETTING_${idx}_SYMBOLS)
+      get_property(sort    GLOBAL PROPERTY ${section}_SETTING_${idx}_SORT)
+      get_property(offset  GLOBAL PROPERTY ${section}_SETTING_${idx}_OFFSET)
+      if(DEFINED offset)
+        foreach(symbol ${symbols})
+          list(POP_FRONT steering_postfixes postfix)
+          math(EXPR offset_dec "${offset}")
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C
+            "Image$$${name_clean}_${offset_dec}$$${postfix}"
+          )
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+            "RESOLVE ${symbol} AS Image$$${name_clean}_${offset_dec}$$${postfix}\n"
+          )
+        endforeach()
+      elseif(sort)
+        foreach(symbol ${symbols})
+          list(POP_FRONT steering_postfixes postfix)
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C
+            "Image$$${name_clean}_${idx}$$${postfix}"
+          )
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+            "RESOLVE ${symbol} AS Image$$${name_clean}_${idx}$$${postfix}\n"
+          )
+        endforeach()
+      elseif(DEFINED symbols AND ${length} EQUAL 1 AND noinput)
+        set(steering_postfixes Base Limit)
+        foreach(symbol ${symbols})
+          list(POP_FRONT steering_postfixes postfix)
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C
+            "Image$$${name_clean}$$${postfix}"
+          )
+          set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+            "RESOLVE ${symbol} AS Image$$${name_clean}$$${postfix}\n"
+          )
+        endforeach()
+      endif()
+    endforeach()
+
+    if("${type}" STREQUAL BSS)
+      set(ZI "$$ZI")
+    endif()
+
+    # Symbols translation here.
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${name_clean}${ZI}$$Base")
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${name_clean}${ZI}$$Length")
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Load$$${name_clean}${ZI}$$Base")
+
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+      "RESOLVE __${name_clean}_start AS Image$$${name_clean}${ZI}$$Base\n"
+      "RESOLVE __${name_clean}_load_start AS Load$$${name_clean}${ZI}$$Base\n"
+      "EXPORT  __${name_clean}_start AS __${name_clean}_start\n"
+    )
+
+    get_property(symbol_val GLOBAL PROPERTY SYMBOL_TABLE___${name_clean}_end)
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${symbol_val}${ZI}$$Limit")
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+        "RESOLVE __${name_clean}_end AS Image$$${symbol_val}${ZI}$$Limit\n"
+      )
+
+    if("${symbol_val}" STREQUAL "${name_clean}")
+      set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+        "RESOLVE __${name_clean}_size AS Image$$${name_clean}${ZI}$$Length\n"
+      )
+    else()
+      create_symbol(OBJECT ${REGION_OBJECT} SYMBOL __${name_clean}_size
+        EXPR "(ImageLimit(${symbol_val}${ZI}) - ImageBase(${name_clean}${ZI}))"
+      )
+    endif()
+    set(ZI)
+
+  endforeach()
+
+  get_property(groups GLOBAL PROPERTY ${REGION_OBJECT}_GROUP_LIST_ORDERED)
+  foreach(group ${groups})
+    get_property(name GLOBAL PROPERTY ${group}_NAME)
+    string(TOLOWER ${name} name)
+
+    get_objects(LIST sections OBJECT ${group} TYPE SECTION)
+    list(GET sections 0 section)
+    get_property(first_section_name GLOBAL PROPERTY ${section}_NAME_CLEAN)
+    list(POP_BACK sections section)
+    get_property(last_section_name GLOBAL PROPERTY ${section}_NAME_CLEAN)
+
+    # Symbols translation here.
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${first_section_name}$$Base")
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Load$$${first_section_name}$$Base")
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${last_section_name}$$Limit")
+
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+      "RESOLVE __${name}_start AS Image$$${first_section_name}$$Base\n"
+      "EXPORT  __${name}_start AS __${name}_start\n"
+      "RESOLVE __${name}_load_start AS Load$$${first_section_name}$$Base\n"
+      "EXPORT  __${name}_load_start AS __${name}_load_start\n"
+    )
+
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+        "RESOLVE __${name}_end AS Image$$${last_section_name}$$Limit\n"
+      )
+
+    create_symbol(OBJECT ${REGION_OBJECT} SYMBOL __${name}_size
+      EXPR "(ImageLimit(${last_section_name}) - ImageBase(${first_section_name}))"
+    )
+  endforeach()
+
+  get_property(symbols GLOBAL PROPERTY ${REGION_OBJECT}_SYMBOLS)
+  foreach(symbol ${symbols})
+    get_property(name GLOBAL PROPERTY ${symbol}_NAME)
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_C "Image$$${name}$$Base")
+
+    set_property(GLOBAL APPEND PROPERTY SYMBOL_STEERING_FILE
+      "RESOLVE ${name} AS Image$$${name}$$Base\n"
+    )
+  endforeach()
+
+endfunction()
+
 #
 # String functions - start
 #
@@ -230,6 +375,10 @@ function(section_to_string)
   set(TEMP "${TEMP}")
   # ToDo: add patterns here.
 
+  if("${type}" STREQUAL BSS)
+    set(ZI "$$ZI")
+  endif()
+
   set(TEMP "${TEMP}\n  }")
 
   set(${STRING_STRING} "${${STRING_STRING}}\n${TEMP}\n" PARENT_SCOPE)
@@ -268,3 +417,28 @@ function(symbol_to_string)
 endfunction()
 
 include(${CMAKE_CURRENT_LIST_DIR}/../linker_script_common.cmake)
+
+if(DEFINED STEERING_C)
+  get_property(symbols_c GLOBAL PROPERTY SYMBOL_STEERING_C)
+  file(WRITE ${STEERING_C}  "/* AUTO-GENERATED - Do not modify\n")
+  file(APPEND ${STEERING_C} " * AUTO-GENERATED - All changes will be lost\n")
+  file(APPEND ${STEERING_C} " */\n")
+  foreach(symbol ${symbols_c})
+    file(APPEND ${STEERING_C} "extern char ${symbol}[];\n")
+  endforeach()
+
+  file(APPEND ${STEERING_C} "\nint __armlink_symbol_steering(void) {\n")
+  file(APPEND ${STEERING_C} "\treturn\n")
+  foreach(symbol ${symbols_c})
+    file(APPEND ${STEERING_C} "\t\t${OPERAND} (int)${symbol}\n")
+    set(OPERAND "&")
+  endforeach()
+  file(APPEND ${STEERING_C} "\t;\n}\n")
+endif()
+
+if(DEFINED STEERING_FILE)
+  get_property(steering_content GLOBAL PROPERTY SYMBOL_STEERING_FILE)
+  file(WRITE ${STEERING_FILE}  "; AUTO-GENERATED - Do not modify\n")
+  file(APPEND ${STEERING_FILE} "; AUTO-GENERATED - All changes will be lost\n")
+  file(APPEND ${STEERING_FILE} ${steering_content})
+endif()
diff --git a/cmake/linker/armlink/target.cmake b/cmake/linker/armlink/target.cmake
index 615a1b7cd25f07..390b43b97eb813 100644
--- a/cmake/linker/armlink/target.cmake
+++ b/cmake/linker/armlink/target.cmake
@@ -26,14 +26,25 @@ macro(toolchain_ld_baremetal)
 endmacro()
 
 macro(configure_linker_script linker_script_gen linker_pass_define)
+  set(STEERING_FILE)
+  set(STEERING_C)
+  set(STEERING_FILE_ARG)
+  set(STEERING_C_ARG)
+
   if("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_PREBUILT")
     set(PASS 1)
   elseif("${linker_pass_define}" STREQUAL "-DLINKER_ZEPHYR_FINAL;-DLINKER_PASS2")
     set(PASS 2)
+    set(STEERING_FILE ${CMAKE_CURRENT_BINARY_DIR}/armlink_symbol_steering.steer)
+    set(STEERING_C ${CMAKE_CURRENT_BINARY_DIR}/armlink_symbol_steering.c)
+    set(STEERING_FILE_ARG "-DSTEERING_FILE=${STEERING_FILE}")
+    set(STEERING_C_ARG "-DSTEERING_C=${STEERING_C}")
   endif()
 
   add_custom_command(
     OUTPUT ${linker_script_gen}
+           ${STEERING_FILE}
+           ${STEERING_C}
     COMMAND ${CMAKE_COMMAND}
       -DPASS=${PASS}
       -DMEMORY_REGIONS="$<TARGET_PROPERTY:linker,MEMORY_REGIONS>"
@@ -46,6 +57,11 @@ macro(configure_linker_script linker_script_gen linker_pass_define)
       -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/${linker_script_gen}
       -P ${ZEPHYR_BASE}/cmake/linker/armlink/scatter_script.cmake
   )
+
+  if("${PASS}" EQUAL 2)
+    add_library(armlink_steering OBJECT ${STEERING_C})
+    target_link_libraries(armlink_steering PRIVATE zephyr_interface)
+  endif()
 endmacro()
 
 function(toolchain_ld_link_elf)
@@ -78,6 +94,12 @@ function(toolchain_ld_link_elf)
     --entry=$<TARGET_PROPERTY:linker,ENTRY>
     "--keep=\"*.o(.init_*)\""
     "--keep=\"*.o(.device_*)\""
+    $<TARGET_OBJECTS:armlink_steering>
+    --edit=${CMAKE_CURRENT_BINARY_DIR}/armlink_symbol_steering.steer
+    # Resolving symbols using generated steering files will emit the warnings 6331 and 6332.
+    # Steering files are used because we want to be able to use `__device_end` instead of `Image$$device$$Limit`.
+    # Thus silence those two warnings.
+    --diag_suppress=6331,6332
     # The scatter file is generated, and thus sometimes input sections are specified
     # even though there will be no such sections found in the libraries linked.
     --diag_suppress=6314

From e7a7df6244b4a25ecebddf4c2980fd891366672f Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Sun, 15 Aug 2021 23:14:21 +0200
Subject: [PATCH 18/20] armclang: ARM Compiler C library support

Support for ARM Compiler C library.

This commit add support for the ARM Compiler C libary in:
- Kconfig
- libc/armstdc

A new Kconfig symbol is added to allow a toolchain to specify if they
support linking with the minimal C library.
Also the CMake variable `TOOLCHAIN_HAS_NEWLIB` is exported to Kconfig
so that CONFIG_NEWLIB_LIBS can only be enabled if the toolchain has
newlib.

The armclang toolchain selects the CMake scatter file generator and
disables support for the LD linker template which is not supported by
armlink.

For the ARM Compiler C library, a corresponding lib/libc/armstc/ folder
with a minimal implementation to work with the ARM Compiler C library
is added.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 Kconfig.zephyr                               |   2 +
 cmake/compiler/armclang/compiler_flags.cmake |   3 +
 cmake/compiler/armclang/target.cmake         |  14 +-
 cmake/kconfig.cmake                          |   1 +
 cmake/toolchain/armclang/Kconfig             |  23 +++
 cmake/toolchain/armclang/Kconfig.defconfig   |   6 +
 doc/CMakeLists.txt                           |   1 +
 lib/libc/CMakeLists.txt                      |   4 +-
 lib/libc/Kconfig                             |   5 +
 lib/libc/armstdc/CMakeLists.txt              |   8 ++
 lib/libc/armstdc/include/errno.h             | 141 +++++++++++++++++++
 lib/libc/armstdc/include/fcntl.h             |  21 +++
 lib/libc/armstdc/include/sys/timespec.h      |  23 +++
 lib/libc/armstdc/include/sys/types.h         |  45 ++++++
 lib/libc/armstdc/src/errno.c                 |  27 ++++
 lib/libc/armstdc/src/libc-hooks.c            |  27 ++++
 lib/libc/armstdc/src/string.c                |  31 ++++
 scripts/ci/check_compliance.py               |   4 +
 18 files changed, 377 insertions(+), 9 deletions(-)
 create mode 100644 cmake/toolchain/armclang/Kconfig
 create mode 100644 cmake/toolchain/armclang/Kconfig.defconfig
 create mode 100644 lib/libc/armstdc/CMakeLists.txt
 create mode 100644 lib/libc/armstdc/include/errno.h
 create mode 100644 lib/libc/armstdc/include/fcntl.h
 create mode 100644 lib/libc/armstdc/include/sys/timespec.h
 create mode 100644 lib/libc/armstdc/include/sys/types.h
 create mode 100644 lib/libc/armstdc/src/errno.c
 create mode 100644 lib/libc/armstdc/src/libc-hooks.c
 create mode 100644 lib/libc/armstdc/src/string.c

diff --git a/Kconfig.zephyr b/Kconfig.zephyr
index 4f92cd07c568c6..0141bfde6490e0 100644
--- a/Kconfig.zephyr
+++ b/Kconfig.zephyr
@@ -25,6 +25,8 @@ source "$(BOARD_DIR)/Kconfig.defconfig"
 osource "$(KCONFIG_BINARY_DIR)/Kconfig.soc.defconfig"
 # This loads Zephyr base SoC root defconfigs
 osource "soc/$(ARCH)/*/Kconfig.defconfig"
+# This loads the toolchain defconfigs
+osource "$(TOOLCHAIN_KCONFIG_DIR)/Kconfig.defconfig"
 
 menu "Modules"
 
diff --git a/cmake/compiler/armclang/compiler_flags.cmake b/cmake/compiler/armclang/compiler_flags.cmake
index 48c0e0c798c5ad..3d0f713da4f40a 100644
--- a/cmake/compiler/armclang/compiler_flags.cmake
+++ b/cmake/compiler/armclang/compiler_flags.cmake
@@ -4,3 +4,6 @@ include(${ZEPHYR_BASE}/cmake/compiler/clang/compiler_flags.cmake)
 # Required ASM flags when using armclang, this should be handled by CMake, but
 # fails because of: https://gitlab.kitware.com/cmake/cmake/-/issues/19963
 set_property(TARGET asm APPEND PROPERTY required "--target=${triple}")
+
+# Only the ARM Compiler C library is currently supported.
+set_compiler_property(PROPERTY nostdinc)
diff --git a/cmake/compiler/armclang/target.cmake b/cmake/compiler/armclang/target.cmake
index 2a88bc294e7308..c84089fa1ae79f 100644
--- a/cmake/compiler/armclang/target.cmake
+++ b/cmake/compiler/armclang/target.cmake
@@ -67,13 +67,11 @@ foreach(isystem_include_dir ${NOSTDINC})
   list(APPEND isystem_include_flags -isystem ${isystem_include_dir})
 endforeach()
 
-set(CMAKE_REQUIRED_FLAGS -nostartfiles -nostdlib ${isystem_include_flags})
+set(CMAKE_REQUIRED_FLAGS ${isystem_include_flags})
 string(REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
 
-# Load toolchain_cc-family macros
-
-macro(toolchain_cc_nostdinc)
-  if(NOT "${ARCH}" STREQUAL "posix")
-    zephyr_compile_options( -nostdinc)
-  endif()
-endmacro()
+if(CONFIG_ARMCLANG_STD_LIBC)
+  # Zephyr requires AEABI portability to ensure correct functioning of the C
+  # library, for example error numbers, errno.h.
+  list(APPEND TOOLCHAIN_C_FLAGS -D_AEABI_PORTABILITY_LEVEL=1)
+endif()
diff --git a/cmake/kconfig.cmake b/cmake/kconfig.cmake
index 979aa164fe1848..71668d0fe8aa10 100644
--- a/cmake/kconfig.cmake
+++ b/cmake/kconfig.cmake
@@ -103,6 +103,7 @@ set(COMMON_KCONFIG_ENV_SETTINGS
   BOARD_DIR=${BOARD_DIR}
   KCONFIG_BINARY_DIR=${KCONFIG_BINARY_DIR}
   TOOLCHAIN_KCONFIG_DIR=${TOOLCHAIN_KCONFIG_DIR}
+  TOOLCHAIN_HAS_NEWLIB=$<IF:$<BOOL:${TOOLCHAIN_HAS_NEWLIB}>,y,n>
   EDT_PICKLE=${EDT_PICKLE}
   # Export all Zephyr modules to Kconfig
   ${ZEPHYR_KCONFIG_MODULES_DIR}
diff --git a/cmake/toolchain/armclang/Kconfig b/cmake/toolchain/armclang/Kconfig
new file mode 100644
index 00000000000000..c2df1e1024aa4c
--- /dev/null
+++ b/cmake/toolchain/armclang/Kconfig
@@ -0,0 +1,23 @@
+# Copyright (c) 2021 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+config LD_LINKER_SCRIPT_SUPPORTED
+	bool
+	default n
+
+choice LINKER_SCRIPT
+	default CMAKE_LINKER_GENERATOR
+endchoice
+
+choice LIBC_IMPLEMENTATION
+	prompt "C Library Implementation"
+	default ARMCLANG_STD_LIBC
+
+config ARMCLANG_STD_LIBC
+	bool "ARM Compiler C library"
+	help
+	  Use the full Arm Compiler runtime libraries.
+	  A reduced Zephyr minimal libc will be used for library functionality
+	  not provided by ARM Compiler standard libraries.
+
+endchoice
diff --git a/cmake/toolchain/armclang/Kconfig.defconfig b/cmake/toolchain/armclang/Kconfig.defconfig
new file mode 100644
index 00000000000000..a154f3035098db
--- /dev/null
+++ b/cmake/toolchain/armclang/Kconfig.defconfig
@@ -0,0 +1,6 @@
+# Copyright (c) 2021 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+config SUPPORT_MINIMAL_LIBC
+	bool
+	default n
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index a3386fa0fb2070..00d453de56bd14 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -142,6 +142,7 @@ add_custom_target(
   ARCH=*
   ARCH_DIR=arch
   SOC_DIR=soc
+  TOOLCHAIN_HAS_NEWLIB=y
   KCONFIG_BINARY_DIR=${KCONFIG_BINARY_DIR}
   KCONFIG_WARN_UNDEF=y
   KCONFIG_TURBO_MODE=${KCONFIG_TURBO_MODE}
diff --git a/lib/libc/CMakeLists.txt b/lib/libc/CMakeLists.txt
index 6eea0313b4f543..fe72c26f7aa7dc 100644
--- a/lib/libc/CMakeLists.txt
+++ b/lib/libc/CMakeLists.txt
@@ -4,6 +4,8 @@ if(CONFIG_NEWLIB_LIBC)
   add_subdirectory(newlib)
 elseif(CONFIG_ARCMWDT_LIBC)
   add_subdirectory(arcmwdt)
-else()
+elseif(CONFIG_MINIMAL_LIBC)
   add_subdirectory(minimal)
+elseif(CONFIG_ARMCLANG_STD_LIBC)
+  add_subdirectory(armstdc)
 endif()
diff --git a/lib/libc/Kconfig b/lib/libc/Kconfig
index 74b742e0cbcd28..11945961da1c73 100644
--- a/lib/libc/Kconfig
+++ b/lib/libc/Kconfig
@@ -11,6 +11,10 @@ config REQUIRES_FULL_LIBC
 	  Helper symbol to indicate some feature requires a C library implementation
 	  with more functionality than what MINIMAL_LIBC provides
 
+config SUPPORT_MINIMAL_LIBC
+	bool
+	default y
+
 choice LIBC_IMPLEMENTATION
 	prompt "C Library Implementation"
 	default EXTERNAL_LIBC if NATIVE_APPLICATION
@@ -21,6 +25,7 @@ config MINIMAL_LIBC
 	bool "Minimal C library"
 	depends on !NATIVE_APPLICATION
 	depends on !REQUIRES_FULL_LIBC
+	depends on SUPPORT_MINIMAL_LIBC
 	help
 	  Build with minimal C library.
 
diff --git a/lib/libc/armstdc/CMakeLists.txt b/lib/libc/armstdc/CMakeLists.txt
new file mode 100644
index 00000000000000..b92f061b411614
--- /dev/null
+++ b/lib/libc/armstdc/CMakeLists.txt
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+zephyr_library()
+zephyr_library_sources(src/errno.c)
+zephyr_library_sources(src/string.c)
+zephyr_library_sources(src/libc-hooks.c)
+
+zephyr_system_include_directories(include)
diff --git a/lib/libc/armstdc/include/errno.h b/lib/libc/armstdc/include/errno.h
new file mode 100644
index 00000000000000..58e1aee0aec437
--- /dev/null
+++ b/lib/libc/armstdc/include/errno.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 1984-1999, 2012 Wind River Systems, Inc.
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *	@(#)errno.h	7.1 (Berkeley) 6/4/86
+ */
+
+/**
+ * @file
+ * @brief System error numbers
+ */
+
+#ifndef ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_ERRNO_H_
+#define ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_ERRNO_H_
+
+/**
+ * @brief System error numbers
+ *        Error codes returned by functions.
+ *        Includes a list of those defined by IEEE Std 1003.1-2017.
+ *
+ *        This file is supposed to be used together with ARMClang and
+ *        #define _AEABI_PORTABILITY_LEVEL 1
+ *        or
+ *        -D_AEABI_PORTABILITY_LEVEL=1
+ *
+ *        For details, please refer to the document:
+ *        'C Library ABI for the Arm® Architecture, 2021Q1'
+ *
+ * @defgroup system_errno Error numbers
+ * @ingroup c_std_lib
+ * @{
+ */
+
+#include <sys/errno_private.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define errno (*z_errno())
+
+#define EPERM 1         /**< Not owner */
+#define ENOENT 2        /**< No such file or directory */
+#define ESRCH 3         /**< No such context */
+#define EINTR 4         /**< Interrupted system call */
+#define EIO 5           /**< I/O error */
+#define ENXIO 6         /**< No such device or address */
+#define E2BIG 7         /**< Arg list too long */
+#define ENOEXEC 8       /**< Exec format error */
+#define EBADF 9         /**< Bad file number */
+#define ECHILD 10       /**< No children */
+#define EAGAIN 11       /**< No more contexts */
+#define ENOMEM 12       /**< Not enough core */
+#define EACCES 13       /**< Permission denied */
+#define EFAULT 14       /**< Bad address */
+#define ENOTBLK 15      /**< Block device required */
+#define EBUSY 16        /**< Mount device busy */
+#define EEXIST 17       /**< File exists */
+#define EXDEV 18        /**< Cross-device link */
+#define ENODEV 19       /**< No such device */
+#define ENOTDIR 20      /**< Not a directory */
+#define EISDIR 21       /**< Is a directory */
+#define EINVAL 22       /**< Invalid argument */
+#define ENFILE 23       /**< File table overflow */
+#define EMFILE 24       /**< Too many open files */
+#define ENOTTY 25       /**< Not a typewriter */
+#define ETXTBSY 26      /**< Text file busy */
+#define EFBIG 27        /**< File too large */
+#define ENOSPC 28       /**< No space left on device */
+#define ESPIPE 29       /**< Illegal seek */
+#define EROFS 30        /**< Read-only file system */
+#define EMLINK 31       /**< Too many links */
+#define EPIPE 32        /**< Broken pipe */
+/* Implemented in errno.c    Argument too large */
+/* Implemented in errno.c    Result too large */
+#define ENOMSG 35       /**< Unexpected message type */
+#define EDEADLK 45      /**< Resource deadlock avoided */
+#define ENOLCK 46       /**< No locks available */
+#define ENOSTR 60       /**< STREAMS device required */
+#define ENODATA 61      /**< Missing expected message data */
+#define ETIME 62        /**< STREAMS timeout occurred */
+#define ENOSR 63        /**< Insufficient memory */
+#define EPROTO 71       /**< Generic STREAMS error */
+#define EBADMSG 77      /**< Invalid STREAMS message */
+#define ENOSYS 88       /**< Function not implemented */
+#define ENOTEMPTY 90    /**< Directory not empty */
+#define ENAMETOOLONG 91 /**< File name too long */
+#define ELOOP 92        /**< Too many levels of symbolic links */
+#define EOPNOTSUPP 95   /**< Operation not supported on socket */
+#define EPFNOSUPPORT 96 /**< Protocol family not supported */
+#define ECONNRESET 104   /**< Connection reset by peer */
+#define ENOBUFS 105      /**< No buffer space available */
+#define EAFNOSUPPORT 106 /**< Addr family not supported */
+#define EPROTOTYPE 107   /**< Protocol wrong type for socket */
+#define ENOTSOCK 108     /**< Socket operation on non-socket */
+#define ENOPROTOOPT 109  /**< Protocol not available */
+#define ESHUTDOWN 110    /**< Can't send after socket shutdown */
+#define ECONNREFUSED 111 /**< Connection refused */
+#define EADDRINUSE 112   /**< Address already in use */
+#define ECONNABORTED 113 /**< Software caused connection abort */
+#define ENETUNREACH 114  /**< Network is unreachable */
+#define ENETDOWN 115     /**< Network is down */
+#define ETIMEDOUT 116    /**< Connection timed out */
+#define EHOSTDOWN 117    /**< Host is down */
+#define EHOSTUNREACH 118 /**< No route to host */
+#define EINPROGRESS 119  /**< Operation now in progress */
+#define EALREADY 120     /**< Operation already in progress */
+#define EDESTADDRREQ 121 /**< Destination address required */
+#define EMSGSIZE 122        /**< Message size */
+#define EPROTONOSUPPORT 123 /**< Protocol not supported */
+#define ESOCKTNOSUPPORT 124 /**< Socket type not supported */
+#define EADDRNOTAVAIL 125   /**< Can't assign requested address */
+#define ENETRESET 126       /**< Network dropped connection on reset */
+#define EISCONN 127         /**< Socket is already connected */
+#define ENOTCONN 128        /**< Socket is not connected */
+#define ETOOMANYREFS 129    /**< Too many references: can't splice */
+#define ENOTSUP 134         /**< Unsupported value */
+/* Implemented in errno.c   Illegal byte sequence */
+#define EOVERFLOW 139       /**< Value overflow */
+#define ECANCELED 140       /**< Operation canceled */
+
+#define EWOULDBLOCK EAGAIN /**< Operation would block */
+
+/**
+ * @}
+ */
+#include_next <errno.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_ERRNO_H_ */
diff --git a/lib/libc/armstdc/include/fcntl.h b/lib/libc/armstdc/include/fcntl.h
new file mode 100644
index 00000000000000..2341803e37a82e
--- /dev/null
+++ b/lib/libc/armstdc/include/fcntl.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2018 Linaro Limited
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_FCNTL_H_
+#define ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_FCNTL_H_
+
+#define O_CREAT    0x0200
+#define O_APPEND   0x0400
+#define O_EXCL     0x0800
+#define O_NONBLOCK 0x4000
+
+#define F_DUPFD 0
+#define F_GETFL 3
+#define F_SETFL 4
+
+int open(const char *name, int flags, ...);
+
+#endif /* ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_FCNTL_H_ */
diff --git a/lib/libc/armstdc/include/sys/timespec.h b/lib/libc/armstdc/include/sys/timespec.h
new file mode 100644
index 00000000000000..55cb6b57d892f8
--- /dev/null
+++ b/lib/libc/armstdc/include/sys/timespec.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2019 Linaro Limited
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TIMESPEC_H_
+#define ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TIMESPEC_H_
+
+#include <sys/types.h>
+
+struct timespec {
+	time_t tv_sec;
+	long tv_nsec;
+};
+
+struct itimerspec {
+	struct timespec it_interval;  /* Timer interval */
+	struct timespec it_value;     /* Timer expiration */
+};
+
+#endif /* ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TIMESPEC_H_ */
diff --git a/lib/libc/armstdc/include/sys/types.h b/lib/libc/armstdc/include/sys/types.h
new file mode 100644
index 00000000000000..7a46008b12fc7c
--- /dev/null
+++ b/lib/libc/armstdc/include/sys/types.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * This defines the required types for the ARMClang compiler when comiling with
+ * _AEABI_PORTABILITY_LEVEL = 1
+ *
+ * The types defined are according to:
+ * C Library ABI for the Arm® Architecture, 2021Q1
+ *
+ */
+#ifndef ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TYPES_H_
+#define ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TYPES_H_
+
+#if !defined(__ssize_t_defined)
+#define __ssize_t_defined
+
+/* parasoft suppress item MISRAC2012-RULE_20_4-a item MISRAC2012-RULE_20_4-b
+ * "Trick compiler to make sure the type of ssize_t won't be
+ * unsigned long. View details in commit b889120"
+ */
+#define unsigned signed
+typedef __SIZE_TYPE__ ssize_t;
+#undef unsigned
+#endif
+
+#if !defined(__off_t_defined)
+#define __off_t_defined
+typedef int off_t;
+#endif
+
+#if !defined(__time_t_defined)
+#define __time_t_defined
+typedef unsigned int time_t;
+#endif
+
+#if !defined(__clock_t_defined)
+#define __clock_t_defined
+typedef unsigned int clock_t;
+#endif
+
+#endif /* ZEPHYR_LIB_LIBC_ARMSTDC_INCLUDE_SYS_TYPES_H_ */
diff --git a/lib/libc/armstdc/src/errno.c b/lib/libc/armstdc/src/errno.c
new file mode 100644
index 00000000000000..923be5acc61156
--- /dev/null
+++ b/lib/libc/armstdc/src/errno.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @brief System error numbers
+ *        Error codes returned by functions.
+ *        Includes a list of those defined by IEEE Std 1003.1-2017.
+ *
+ *        This file is supposed to be used together with ARMClang and
+ *        #define _AEABI_PORTABILITY_LEVEL 1
+ *        or
+ *        -D_AEABI_PORTABILITY_LEVEL=1
+ *
+ *        For details, please refer to the document:
+ *        'C Library ABI for the Arm® Architecture, 2021Q1'
+ *
+ * @defgroup system_errno Error numbers
+ * @ingroup c_std_lib
+ * @{
+ */
+
+const int __aeabi_EDOM = 33;    /**< Argument too large */
+const int __aeabi_ERANGE = 34;  /**< Result too large */
+const int __aeabi_EILSEQ = 138; /**< Illegal byte sequence */
diff --git a/lib/libc/armstdc/src/libc-hooks.c b/lib/libc/armstdc/src/libc-hooks.c
new file mode 100644
index 00000000000000..be7aef884cba6c
--- /dev/null
+++ b/lib/libc/armstdc/src/libc-hooks.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <kernel.h>
+#include <stdio.h>
+
+static int _stdout_hook_default(int c)
+{
+	(void)(c);  /* Prevent warning about unused argument */
+
+	return EOF;
+}
+
+static int (*_stdout_hook)(int) = _stdout_hook_default;
+
+void __stdout_hook_install(int (*hook)(int))
+{
+	_stdout_hook = hook;
+}
+
+volatile int *__aeabi_errno_addr(void)
+{
+	return &_current->errno_var;
+}
diff --git a/lib/libc/armstdc/src/string.c b/lib/libc/armstdc/src/string.c
new file mode 100644
index 00000000000000..45f05155b18957
--- /dev/null
+++ b/lib/libc/armstdc/src/string.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2014 Wind River Systems, Inc.
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+/**
+ *
+ * @brief Get fixed-size string length
+ *
+ *        This function is not available in ARM C Standard library.
+ *
+ * @return number of bytes in fixed-size string <s>
+ */
+
+size_t strnlen(const char *s, size_t maxlen)
+{
+	size_t n = 0;
+
+	while (*s != '\0' && n < maxlen) {
+		s++;
+		n++;
+	}
+
+	return n;
+}
diff --git a/scripts/ci/check_compliance.py b/scripts/ci/check_compliance.py
index 86545756db3556..550f29a29890ef 100755
--- a/scripts/ci/check_compliance.py
+++ b/scripts/ci/check_compliance.py
@@ -328,6 +328,7 @@ def parse_kconfig(self):
         os.environ["ARCH"] = "*"
         os.environ["KCONFIG_BINARY_DIR"] = tempfile.gettempdir()
         os.environ['DEVICETREE_CONF'] = "dummy"
+        os.environ['TOOLCHAIN_HAS_NEWLIB'] = "y"
 
         # Older name for DEVICETREE_CONF, for compatibility with older Zephyr
         # versions that don't have the renaming
@@ -522,6 +523,9 @@ def get_defined_syms(kconf):
 UNDEF_KCONFIG_WHITELIST = {
     "ALSO_MISSING",
     "APP_LINK_WITH_",
+    "ARMCLANG_STD_LIBC",  # The ARMCLANG_STD_LIBC is defined in the toolchain
+                          # Kconfig which is sourced based on Zephyr toolchain
+			  # variant and therefore not visible to compliance.
     "CDC_ACM_PORT_NAME_",
     "CLOCK_STM32_SYSCLK_SRC_",
     "CMU",

From 7eb670cd40c5e452fe40faaac6377b9c8fd10a68 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Tue, 24 Aug 2021 15:32:14 +0200
Subject: [PATCH 19/20] armclang: threading_weak.c source file added for
 armclang

The stub file threading_weak.c has been added containing weak stub
implementation of threading related kernel functions.

The file is needed for armlink.

When linking with armlink the linker will resolve undefined symbols for
all undefined functions even if those functions the reference the
undefined symbol is never actually called.

This file provides weak stub implementations that are compiled when
CONFIG_MULTITHREADING=n to ensure proper linking.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 lib/libc/armstdc/CMakeLists.txt       |  1 +
 lib/libc/armstdc/src/threading_weak.c | 72 +++++++++++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 lib/libc/armstdc/src/threading_weak.c

diff --git a/lib/libc/armstdc/CMakeLists.txt b/lib/libc/armstdc/CMakeLists.txt
index b92f061b411614..8a15fdf4ae44d2 100644
--- a/lib/libc/armstdc/CMakeLists.txt
+++ b/lib/libc/armstdc/CMakeLists.txt
@@ -4,5 +4,6 @@ zephyr_library()
 zephyr_library_sources(src/errno.c)
 zephyr_library_sources(src/string.c)
 zephyr_library_sources(src/libc-hooks.c)
+zephyr_library_sources_ifndef(CONFIG_MULTITHREADING src/threading_weak.c)
 
 zephyr_system_include_directories(include)
diff --git a/lib/libc/armstdc/src/threading_weak.c b/lib/libc/armstdc/src/threading_weak.c
new file mode 100644
index 00000000000000..0b01600255bbe8
--- /dev/null
+++ b/lib/libc/armstdc/src/threading_weak.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Weak stub implementation of threading related kernel functions.
+ *
+ * This file is needed for armlink.
+ *
+ * When linking with armlink the linker will resolve undefined symbols for all
+ * undefined functions even if those functions the reference the undefined
+ * symbol is never actually called.
+ *
+ * This file provides weak stub implementations that are compiled when
+ * CONFIG_MULTITHREADING=n to ensure proper linking.
+ */
+
+#include <kernel.h>
+
+int __weak z_impl_k_mutex_init(struct k_mutex *mutex)
+{
+	return 0;
+}
+
+int __weak z_impl_k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout)
+{
+	return 0;
+}
+
+int __weak z_impl_k_mutex_unlock(struct k_mutex *mutex)
+{
+	return 0;
+}
+
+void __weak z_impl_k_sem_give(struct k_sem *sem)
+{
+}
+
+int __weak z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
+		      unsigned int limit)
+{
+	return 0;
+}
+
+int __weak z_impl_k_sem_take(struct k_sem *sem, k_timeout_t timeout)
+{
+	return 0;
+}
+
+k_tid_t __weak z_impl_z_current_get(void)
+{
+	return 0;
+}
+
+int32_t __weak z_impl_k_usleep(int us)
+{
+	return 0;
+}
+
+void __weak z_thread_abort(struct k_thread *thread)
+{
+}
+
+void __weak k_sched_lock(void)
+{
+}
+
+void __weak k_sched_unlock(void)
+{
+}

From 14b6ea718126c2290f0eaec87d1a0ee5bd145378 Mon Sep 17 00:00:00 2001
From: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
Date: Thu, 26 Aug 2021 14:03:00 +0200
Subject: [PATCH 20/20] tests: added kernel tests for arm arch with linker
 script generator

This commit adds an additional test case for several kernel test suites
to ensure that the linker script generator is working correctly for a
subset of the Zephyr test suites.

The ensures that the basic functionality of the linker script generator
is working while still keep the performance impact on CI at a minimal
level.

Using the kernel tests is a trade-off between testing coverage of the
linker script generator and the time it takes to complete CI.

The kernel tests is considered to have the broadest coverage of various
features important for the generated linker script.

Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
---
 tests/kernel/context/testcase.yaml                 |  5 +++++
 tests/kernel/early_sleep/testcase.yaml             |  5 +++++
 tests/kernel/fifo/fifo_api/testcase.yaml           |  5 +++++
 tests/kernel/fifo/fifo_timeout/testcase.yaml       |  5 +++++
 tests/kernel/fifo/fifo_usage/testcase.yaml         |  5 +++++
 tests/kernel/gen_isr_table/testcase.yaml           | 14 +++++++++++---
 tests/kernel/interrupt/testcase.yaml               |  7 +++++++
 tests/kernel/lifo/lifo_api/testcase.yaml           |  5 +++++
 tests/kernel/lifo/lifo_usage/testcase.yaml         |  7 +++++++
 tests/kernel/mbox/mbox_api/testcase.yaml           |  5 +++++
 tests/kernel/mbox/mbox_usage/testcase.yaml         |  5 +++++
 tests/kernel/mem_heap/k_heap_api/testcase.yaml     |  5 +++++
 .../mem_heap/mheap_api_concept/testcase.yaml       |  6 ++++++
 tests/kernel/mem_slab/mslab/testcase.yaml          |  5 +++++
 tests/kernel/mem_slab/mslab_api/testcase.yaml      |  6 +++++-
 tests/kernel/mem_slab/mslab_concept/testcase.yaml  |  5 +++++
 .../kernel/mem_slab/mslab_threadsafe/testcase.yaml |  5 +++++
 tests/kernel/mp/testcase.yaml                      |  6 ++++++
 tests/kernel/msgq/msgq_usage/testcase.yaml         |  5 +++++
 tests/kernel/sched/deadline/testcase.yaml          |  5 +++++
 tests/kernel/sched/metairq/testcase.yaml           |  7 +++++++
 tests/kernel/sched/preempt/testcase.yaml           |  7 +++++++
 tests/kernel/sched/schedule_api/testcase.yaml      |  7 +++++++
 tests/kernel/smp/testcase.yaml                     |  7 +++++++
 tests/kernel/timer/starve/testcase.yaml            |  6 ++++++
 tests/kernel/timer/timer_monotonic/testcase.yaml   |  5 +++++
 tests/kernel/workq/critical/testcase.yaml          |  6 ++++++
 tests/kernel/workq/work/testcase.yaml              |  6 ++++++
 tests/kernel/workq/work_queue/testcase.yaml        |  6 ++++++
 tests/kernel/xip/testcase.yaml                     |  6 ++++++
 30 files changed, 175 insertions(+), 4 deletions(-)

diff --git a/tests/kernel/context/testcase.yaml b/tests/kernel/context/testcase.yaml
index d3854ccfa8fc59..cec3f1ad91a52f 100644
--- a/tests/kernel/context/testcase.yaml
+++ b/tests/kernel/context/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.common:
     tags: kernel
+  kernel.common.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/early_sleep/testcase.yaml b/tests/kernel/early_sleep/testcase.yaml
index 25d36c9bd9062e..6b446cfe7db067 100644
--- a/tests/kernel/early_sleep/testcase.yaml
+++ b/tests/kernel/early_sleep/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.common.sleep:
     tags: kernel sleep
+  kernel.common.sleep.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel sleep linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/fifo/fifo_api/testcase.yaml b/tests/kernel/fifo/fifo_api/testcase.yaml
index 3ed52a92a1ddfa..2e123c57abc497 100644
--- a/tests/kernel/fifo/fifo_api/testcase.yaml
+++ b/tests/kernel/fifo/fifo_api/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.fifo:
     tags: kernel
+  kernel.fifo.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/fifo/fifo_timeout/testcase.yaml b/tests/kernel/fifo/fifo_timeout/testcase.yaml
index b1b146854a87cd..a7d66d31af2289 100644
--- a/tests/kernel/fifo/fifo_timeout/testcase.yaml
+++ b/tests/kernel/fifo/fifo_timeout/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.fifo.timeout:
     tags: kernel
+  kernel.fifo.timeout.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/fifo/fifo_usage/testcase.yaml b/tests/kernel/fifo/fifo_usage/testcase.yaml
index 0f790c8198f775..6d70a284716fd4 100644
--- a/tests/kernel/fifo/fifo_usage/testcase.yaml
+++ b/tests/kernel/fifo/fifo_usage/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.fifo.usage:
     tags: kernel
+  kernel.fifo.usage.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/gen_isr_table/testcase.yaml b/tests/kernel/gen_isr_table/testcase.yaml
index d1ebaee95f7d77..201ce711e937e2 100644
--- a/tests/kernel/gen_isr_table/testcase.yaml
+++ b/tests/kernel/gen_isr_table/testcase.yaml
@@ -1,13 +1,21 @@
 tests:
   arch.interrupt.gen_isr_table.arm_baseline:
-    arch_allow: arm
+    platform_allow: qemu_cortex_m3
     platform_allow: bbc_microbit atsamr21_xpro nrf51dk_nrf51422 nucleo_g071rb qemu_cortex_m0
     filter: CONFIG_GEN_ISR_TABLES and CONFIG_ARMV6_M_ARMV8_M_BASELINE
     tags: kernel interrupt isr_table
     extra_configs:
       - CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE=y
+  arch.interrupt.gen_isr_table.arm_baseline.linker_generator:
+    platform_allow: qemu_cortex_m3
+    platform_allow: bbc_microbit atsamr21_xpro nrf51dk_nrf51422 nucleo_g071rb qemu_cortex_m0
+    filter: CONFIG_GEN_ISR_TABLES and CONFIG_ARMV6_M_ARMV8_M_BASELINE
+    tags: kernel interrupt isr_table linker_generator
+    extra_configs:
+      - CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE=y
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
   arch.interrupt.gen_isr_table.arm_mainline:
-    arch_allow: arm
+    platform_allow: qemu_cortex_m3
     platform_exclude: stmf103_mini nucleo_f103rb olimexino_stm32 stm32_min_dev_black
         stm32_min_dev_blue usb_kw24d512 v2m_beetle cc1352r1_launchxl
         cc26x2r1_launchxl olimex_stm32_h103 cc1352r_sensortag
@@ -16,7 +24,7 @@ tests:
     extra_configs:
       - CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE=y
   arch.interrupt.gen_isr_table.disabled:
-    arch_allow: arm
+    platform_allow: qemu_cortex_m3
     extra_configs:
       - CONFIG_GEN_ISR_TABLES=n
       - CONFIG_NULL_POINTER_EXCEPTION_DETECTION_NONE=y
diff --git a/tests/kernel/interrupt/testcase.yaml b/tests/kernel/interrupt/testcase.yaml
index 1dcf177af4390a..8263936b1e695c 100644
--- a/tests/kernel/interrupt/testcase.yaml
+++ b/tests/kernel/interrupt/testcase.yaml
@@ -16,3 +16,10 @@ tests:
     filter: not CONFIG_X86_64
     extra_configs:
     - CONFIG_COMPILER_OPT="-mgeneral-regs-only"
+
+  arch.interrupt.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel interrupt linker_generator
+    filter: not CONFIG_TRUSTED_EXECUTION_NONSECURE
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/lifo/lifo_api/testcase.yaml b/tests/kernel/lifo/lifo_api/testcase.yaml
index f48d90e00a22b9..f4a9a6f8ae947c 100644
--- a/tests/kernel/lifo/lifo_api/testcase.yaml
+++ b/tests/kernel/lifo/lifo_api/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.lifo:
     tags: kernel
+  kernel.lifo.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/lifo/lifo_usage/testcase.yaml b/tests/kernel/lifo/lifo_usage/testcase.yaml
index 96eb7c357124a7..0d2ba91bbe919a 100644
--- a/tests/kernel/lifo/lifo_usage/testcase.yaml
+++ b/tests/kernel/lifo/lifo_usage/testcase.yaml
@@ -4,3 +4,10 @@ tests:
     platform_exclude: m2gl025_miv
     tags: kernel
     min_ram: 20
+  kernel.lifo.usage.linker_generator:
+    platform_exclude: m2gl025_miv
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    min_ram: 20
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mbox/mbox_api/testcase.yaml b/tests/kernel/mbox/mbox_api/testcase.yaml
index c64c5f8793fbba..db6a8c1609fcd7 100644
--- a/tests/kernel/mbox/mbox_api/testcase.yaml
+++ b/tests/kernel/mbox/mbox_api/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.mailbox.api:
     tags: kernel
+  kernel.mailbox.api.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mbox/mbox_usage/testcase.yaml b/tests/kernel/mbox/mbox_usage/testcase.yaml
index 7c81da0400dd27..2d1d5b5572b964 100644
--- a/tests/kernel/mbox/mbox_usage/testcase.yaml
+++ b/tests/kernel/mbox/mbox_usage/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.mailbox.usage:
     tags: kernel
+  kernel.mailbox.usage.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_heap/k_heap_api/testcase.yaml b/tests/kernel/mem_heap/k_heap_api/testcase.yaml
index bcb7a71b77efb0..2b612e04ccecd1 100644
--- a/tests/kernel/mem_heap/k_heap_api/testcase.yaml
+++ b/tests/kernel/mem_heap/k_heap_api/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.k_heap_api:
     tags: k_heap_api kernel
+  kernel.k_heap_api.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: k_heap_api kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_heap/mheap_api_concept/testcase.yaml b/tests/kernel/mem_heap/mheap_api_concept/testcase.yaml
index f3bdaebb5f56fb..2405c369526dd9 100644
--- a/tests/kernel/mem_heap/mheap_api_concept/testcase.yaml
+++ b/tests/kernel/mem_heap/mheap_api_concept/testcase.yaml
@@ -8,3 +8,9 @@ tests:
     platform_allow: qemu_cortex_m3 qemu_cortex_m0
     extra_configs:
       - CONFIG_MULTITHREADING=n
+  kernel.memory_heap.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_IRQ_OFFLOAD=y
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_slab/mslab/testcase.yaml b/tests/kernel/mem_slab/mslab/testcase.yaml
index 75bedd798247a3..aa4bdb4197f567 100644
--- a/tests/kernel/mem_slab/mslab/testcase.yaml
+++ b/tests/kernel/mem_slab/mslab/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.memory_slabs.api:
     tags: kernel
+  kernel.memory_slabs.api.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_slab/mslab_api/testcase.yaml b/tests/kernel/mem_slab/mslab_api/testcase.yaml
index 7bf5ba43d3e2c7..459178b47b54fd 100644
--- a/tests/kernel/mem_slab/mslab_api/testcase.yaml
+++ b/tests/kernel/mem_slab/mslab_api/testcase.yaml
@@ -6,4 +6,8 @@ tests:
     platform_allow: qemu_cortex_m3 qemu_cortex_m0
     extra_configs:
       - CONFIG_MULTITHREADING=n
-
+  kernel.memory_slabs.api.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_slab/mslab_concept/testcase.yaml b/tests/kernel/mem_slab/mslab_concept/testcase.yaml
index 9471ef6bb308dc..c3cdc92c9b3c44 100644
--- a/tests/kernel/mem_slab/mslab_concept/testcase.yaml
+++ b/tests/kernel/mem_slab/mslab_concept/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.memory_slabs.concept:
     tags: kernel
+  kernel.memory_slabs.concept.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mem_slab/mslab_threadsafe/testcase.yaml b/tests/kernel/mem_slab/mslab_threadsafe/testcase.yaml
index b744ef8c0af460..7a0161cdc0adcd 100644
--- a/tests/kernel/mem_slab/mslab_threadsafe/testcase.yaml
+++ b/tests/kernel/mem_slab/mslab_threadsafe/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.memory_slabs.threadsafe:
     tags: kernel
+  kernel.memory_slabs.threadsafe.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/mp/testcase.yaml b/tests/kernel/mp/testcase.yaml
index 618fe07fe38da3..b5288695430e62 100644
--- a/tests/kernel/mp/testcase.yaml
+++ b/tests/kernel/mp/testcase.yaml
@@ -2,3 +2,9 @@ tests:
   kernel.multiprocessing:
     tags: kernel smp
     filter: CONFIG_MP_NUM_CPUS > 1
+  kernel.multiprocessing.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel smp linker_generator
+    filter: CONFIG_MP_NUM_CPUS > 1
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/msgq/msgq_usage/testcase.yaml b/tests/kernel/msgq/msgq_usage/testcase.yaml
index a991899a6f1500..dbdbd44c2d3c75 100644
--- a/tests/kernel/msgq/msgq_usage/testcase.yaml
+++ b/tests/kernel/msgq/msgq_usage/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.message_queue_usage:
     tags: kernel
+  kernel.message_queue_usage.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/sched/deadline/testcase.yaml b/tests/kernel/sched/deadline/testcase.yaml
index b77bb0ee93022d..53b366c5af3730 100644
--- a/tests/kernel/sched/deadline/testcase.yaml
+++ b/tests/kernel/sched/deadline/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.scheduler.deadline:
     tags: kernel
+  kernel.scheduler.deadline.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/sched/metairq/testcase.yaml b/tests/kernel/sched/metairq/testcase.yaml
index cdb98863af8648..267d8a5a3a2481 100644
--- a/tests/kernel/sched/metairq/testcase.yaml
+++ b/tests/kernel/sched/metairq/testcase.yaml
@@ -3,3 +3,10 @@ tests:
     tags: kernel
     filter: not CONFIG_SMP
     platform_exclude: nrf52dk_nrf52810
+  kernel.scheduler.metairq.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    filter: not CONFIG_SMP
+    platform_exclude: nrf52dk_nrf52810
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/sched/preempt/testcase.yaml b/tests/kernel/sched/preempt/testcase.yaml
index 35a1cf7d830aa2..2dc429e028f95d 100644
--- a/tests/kernel/sched/preempt/testcase.yaml
+++ b/tests/kernel/sched/preempt/testcase.yaml
@@ -3,3 +3,10 @@ tests:
     tags: kernel
     filter: not CONFIG_SMP
     platform_exclude: nrf52dk_nrf52810
+  kernel.scheduler.preempt.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel linker_generator
+    filter: not CONFIG_SMP
+    platform_exclude: nrf52dk_nrf52810
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/sched/schedule_api/testcase.yaml b/tests/kernel/sched/schedule_api/testcase.yaml
index a30ea631d1df87..42d28d353b8d57 100644
--- a/tests/kernel/sched/schedule_api/testcase.yaml
+++ b/tests/kernel/sched/schedule_api/testcase.yaml
@@ -32,3 +32,10 @@ tests:
     extra_configs:
       - CONFIG_TIMESLICING=n
     tags: kernel threads sched userspace ignore_faults
+  kernel.scheduler.linker_generator:
+    platform_allow: qemu_cortex_m3
+    filter: not CONFIG_SCHED_MULTIQ
+    extra_configs:
+      - CONFIG_TIMESLICING=y
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
+    tags: kernel threads sched userspace ignore_faults linker_generator
diff --git a/tests/kernel/smp/testcase.yaml b/tests/kernel/smp/testcase.yaml
index c2dd9b075abc0c..f4afb10d15ca03 100644
--- a/tests/kernel/smp/testcase.yaml
+++ b/tests/kernel/smp/testcase.yaml
@@ -2,3 +2,10 @@ tests:
   kernel.multiprocessing.smp:
     tags: kernel smp ignore_faults
     filter: (CONFIG_MP_NUM_CPUS > 1)
+  kernel.multiprocessing.smp.linker_generator:
+    platform_allow: qemu_cortex_m3
+    extra_configs:
+      - CONFIG_TIMESLICING=y
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
+    tags: kernel smp ignore_faults linker_generator
+    filter: (CONFIG_MP_NUM_CPUS > 1)
diff --git a/tests/kernel/timer/starve/testcase.yaml b/tests/kernel/timer/starve/testcase.yaml
index 57e9e34a9c7635..15b0fe6ae7fd52 100644
--- a/tests/kernel/timer/starve/testcase.yaml
+++ b/tests/kernel/timer/starve/testcase.yaml
@@ -2,3 +2,9 @@ tests:
   kernel.timer.starve:
     build_only: true
     tags: kernel timer
+  kernel.timer.starve.linker_generator:
+    platform_allow: qemu_cortex_m3
+    build_only: true
+    tags: kernel timer linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/timer/timer_monotonic/testcase.yaml b/tests/kernel/timer/timer_monotonic/testcase.yaml
index 877de8d8eaf871..bf44b25b450d11 100644
--- a/tests/kernel/timer/timer_monotonic/testcase.yaml
+++ b/tests/kernel/timer/timer_monotonic/testcase.yaml
@@ -1,3 +1,8 @@
 tests:
   kernel.timer.monotonic:
     tags: kernel timer
+  kernel.timer.monotonic.linker_generator:
+    platform_allow: qemu_cortex_m3
+    tags: kernel timer linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/workq/critical/testcase.yaml b/tests/kernel/workq/critical/testcase.yaml
index e2b7279af77edf..bbcb241bd55022 100644
--- a/tests/kernel/workq/critical/testcase.yaml
+++ b/tests/kernel/workq/critical/testcase.yaml
@@ -13,3 +13,9 @@ tests:
     platform_allow: nsim_sem_mpu_stack_guard nsim_em_mpu_stack_guard
     extra_configs:
       - CONFIG_TEST_HW_STACK_PROTECTION=n
+  kernel.workqueue.linker_generator:
+    platform_allow: qemu_cortex_m3
+    filter: not CONFIG_WDT_SAM
+    tags:  linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/workq/work/testcase.yaml b/tests/kernel/workq/work/testcase.yaml
index 0aa7c143c898c3..a1dbac9fb0c9be 100644
--- a/tests/kernel/workq/work/testcase.yaml
+++ b/tests/kernel/workq/work/testcase.yaml
@@ -2,3 +2,9 @@ tests:
   kernel.work.api:
     min_flash: 34
     tags: kernel
+  kernel.work.api.linker_generator:
+    platform_allow: qemu_cortex_m3
+    min_flash: 34
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/workq/work_queue/testcase.yaml b/tests/kernel/workq/work_queue/testcase.yaml
index 096b3b8c15602a..2e88b82e21221f 100644
--- a/tests/kernel/workq/work_queue/testcase.yaml
+++ b/tests/kernel/workq/work_queue/testcase.yaml
@@ -2,3 +2,9 @@ tests:
   kernel.workqueue:
     min_flash: 34
     tags: kernel
+  kernel.workqueue.linker_generator:
+    platform_allow: qemu_cortex_m3
+    min_flash: 34
+    tags: kernel linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y
diff --git a/tests/kernel/xip/testcase.yaml b/tests/kernel/xip/testcase.yaml
index 91a345460d3ced..467855577d38be 100644
--- a/tests/kernel/xip/testcase.yaml
+++ b/tests/kernel/xip/testcase.yaml
@@ -2,3 +2,9 @@ tests:
   arch.common.xip:
     filter: CONFIG_XIP
     tags: kernel xip
+  arch.common.xip.linker_generator:
+    platform_allow: qemu_cortex_m3
+    filter: CONFIG_XIP
+    tags: kernel xip linker_generator
+    extra_configs:
+      - CONFIG_CMAKE_LINKER_GENERATOR=y