diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59f861039eb22c..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
@@ -795,6 +797,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/Kconfig.zephyr b/Kconfig.zephyr
index 383e91c10efe3a..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"
 
@@ -132,8 +134,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/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>
diff --git a/arch/common/CMakeLists.txt b/arch/common/CMakeLists.txt
index 3f6e5984c26bf5..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
@@ -38,6 +47,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/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=")
diff --git a/cmake/compiler/armclang/compiler_flags.cmake b/cmake/compiler/armclang/compiler_flags.cmake
new file mode 100644
index 00000000000000..3d0f713da4f40a
--- /dev/null
+++ b/cmake/compiler/armclang/compiler_flags.cmake
@@ -0,0 +1,9 @@
+# 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}")
+
+# Only the ARM Compiler C library is currently supported.
+set_compiler_property(PROPERTY nostdinc)
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..c84089fa1ae79f
--- /dev/null
+++ b/cmake/compiler/armclang/target.cmake
@@ -0,0 +1,77 @@
+# 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 ${isystem_include_flags})
+string(REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+
+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/extensions.cmake b/cmake/extensions.cmake
index 9fe246f31ee47c..b5fe2898be1fd4 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,689 @@ 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_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>)
+#
+# 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()
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/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/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>")
diff --git a/cmake/linker/armlink/scatter_script.cmake b/cmake/linker/armlink/scatter_script.cmake
new file mode 100644
index 00000000000000..f0ebe86741db2d
--- /dev/null
+++ b/cmake/linker/armlink/scatter_script.cmake
@@ -0,0 +1,444 @@
+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
+#
+
+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.
+
+  if("${type}" STREQUAL BSS)
+    set(ZI "$$ZI")
+  endif()
+
+  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)
+
+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
new file mode 100644
index 00000000000000..390b43b97eb813
--- /dev/null
+++ b/cmake/linker/armlink/target.cmake
@@ -0,0 +1,130 @@
+# 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)
+  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>"
+      -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
+  )
+
+  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)
+  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_*)\""
+    $<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
+    # 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/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)
diff --git a/cmake/linker/ld/target.cmake b/cmake/linker/ld/target.cmake
index 571964fcbe9345..b83dc5bb041518 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
@@ -30,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
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()
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/linker_script/arm/linker.cmake b/cmake/linker_script/arm/linker.cmake
new file mode 100644
index 00000000000000..86b1b424e185ff
--- /dev/null
+++ b/cmake/linker_script/arm/linker.cmake
@@ -0,0 +1,206 @@
+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)
+
+# 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})
+  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
+)
+
+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)
+
+# 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/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()
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/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/cmake/toolchain/armclang/generic.cmake b/cmake/toolchain/armclang/generic.cmake
new file mode 100644
index 00000000000000..769ba2c2ff02b3
--- /dev/null
+++ b/cmake/toolchain/armclang/generic.cmake
@@ -0,0 +1,30 @@
+# 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(${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()
+
+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.
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/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_ */
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..8a15fdf4ae44d2
--- /dev/null
+++ b/lib/libc/armstdc/CMakeLists.txt
@@ -0,0 +1,9 @@
+# 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_library_sources_ifndef(CONFIG_MULTITHREADING src/threading_weak.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/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)
+{
+}
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",
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'
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
+)
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