diff --git a/tools/cmake/common/AddComponents.cmake b/tools/cmake/common/AddComponents.cmake
new file mode 100644
index 0000000..07978bb
--- /dev/null
+++ b/tools/cmake/common/AddComponents.cmake
@@ -0,0 +1,60 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2020, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+#-------------------------------------------------------------------------------
+
+#[===[.rst:
+Add build components to the current build.
+------------------------------------------
+
+#]===]
+
+
+#[===[.rst:
+.. cmake:command:: add_components
+
+	.. code:: cmake
+
+		add_components(TARGET <target name> COMPONENTS <list of component directories>)
+
+	INPUTS:
+
+	``BASE_DIR``
+	If defined components are include relative to this directory. If nor paths must be
+	relative to CMAKE_SOURCE_DIR or be absolute.
+
+	``TARGET``
+	The name of an already defined target to add components to.
+
+	``COMPONENTS``
+	List of components relative to :cmake:variable:`CMAKE_SOURCE_DIR`
+
+#]===]
+
+function(add_components)
+	set(options  )
+	set(oneValueArgs TARGET BASE_DIR)
+	set(multiValueArgs COMPONENTS)
+	cmake_parse_arguments(MY_PARAMS "${options}" "${oneValueArgs}"
+						"${multiValueArgs}" ${ARGN} )
+
+	if(NOT DEFINED MY_PARAMS_TARGET)
+		message(FATAL_ERROR "add_component: mandatory parameter TARGET not defined!")
+	endif()
+	if(NOT DEFINED MY_PARAMS_COMPONENTS)
+		message(FATAL_ERROR "add_component: mandatory parameter COMPONENTS not defined!")
+	endif()
+	if(DEFINED MY_PARAMS_BASE_DIR AND NOT MY_PARAMS_BASE_DIR MATCHES ".*/$")
+		set(MY_PARAMS_BASE_DIR "${MY_PARAMS_BASE_DIR}/")
+	endif()
+
+	set(TGT ${MY_PARAMS_TARGET} CACHE STRING "")
+	foreach(_comp IN ITEMS ${MY_PARAMS_COMPONENTS})
+		set(_file ${MY_PARAMS_BASE_DIR}${_comp}/component.cmake)
+		include(${_file})
+		set(CMAKE_CONFIGURE_DEPENDS ${_file})
+	endforeach()
+	unset(TGT CACHE)
+endfunction()
diff --git a/tools/cmake/common/ExportLibrary.cmake b/tools/cmake/common/ExportLibrary.cmake
new file mode 100644
index 0000000..670f318
--- /dev/null
+++ b/tools/cmake/common/ExportLibrary.cmake
@@ -0,0 +1,72 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2020, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+#-------------------------------------------------------------------------------
+
+#[===[.rst:
+.. cmake:command:: export_library
+
+	.. code:: cmake
+
+		export_library(TARGET LIB_NAME INTERFACE_FILES)
+
+	INPUTS:
+
+	``TARGET``
+	The name of an already defined target that corresponds to the library.
+
+	``LIB_NAME``
+	The name of the library.
+
+	``INTERFACE_FILES``
+	List of header files to declare the library's public interface.
+
+#]===]
+function(export_library)
+	set(options  )
+	set(oneValueArgs TARGET LIB_NAME)
+	set(multiValueArgs INTERFACE_FILES)
+	cmake_parse_arguments(MY_PARAMS "${options}" "${oneValueArgs}"
+						"${multiValueArgs}" ${ARGN} )
+
+	if(NOT DEFINED MY_PARAMS_TARGET)
+		message(FATAL_ERROR "export_library: mandatory parameter TARGET not defined!")
+	endif()
+	if(NOT DEFINED MY_PARAMS_LIB_NAME)
+		message(FATAL_ERROR "export_library: mandatory parameter LIB_NAME not defined!")
+	endif()
+
+	# Set default install location if none specified
+	if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+		set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/install CACHE PATH "location to install build output to." FORCE)
+	endif()
+
+	# Specify export name and destinations for install
+	install(
+		TARGETS ${MY_PARAMS_TARGET}
+		EXPORT ${MY_PARAMS_LIB_NAME}_targets
+		ARCHIVE
+			DESTINATION lib
+		LIBRARY
+			DESTINATION lib
+		PUBLIC_HEADER
+			DESTINATION include
+	)
+
+	# Install library header files files
+	install(
+		FILES ${MY_PARAMS_INTERFACE_FILES}
+		DESTINATION include
+	)
+
+	# Install the export details
+	install(
+		EXPORT ${MY_PARAMS_LIB_NAME}_targets
+		FILE ${MY_PARAMS_LIB_NAME}_targets.cmake
+		NAMESPACE ${MY_PARAMS_LIB_NAME}::
+		DESTINATION lib/cmake
+		COMPONENT ${MY_PARAMS_LIB_NAME}
+	)
+endfunction()
diff --git a/tools/cmake/common/Utils.cmake b/tools/cmake/common/Utils.cmake
new file mode 100644
index 0000000..c889320
--- /dev/null
+++ b/tools/cmake/common/Utils.cmake
@@ -0,0 +1,51 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2020, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+#-------------------------------------------------------------------------------
+
+#[===[.rst:
+Misc utilities
+--------------
+#]===]
+
+include_guard(DIRECTORY)
+
+#[===[.rst:
+.. cmake:command:: check_args
+
+  .. code-block:: cmake
+
+    check_args(func_name REQ_ARG1 REQ_ARG2)
+
+  Helper macro for argument checking in functions. First argument *func_name* is
+  the name of the function, other arguments are the names of the required
+  arguments to that function. The macro iterates through the list, and prints
+  and error message if not all arguments are defined.
+
+#]===]
+macro(check_args)
+	set(_argv "${ARGV}")
+	list(SUBLIST _argv 0 1 _func)
+	list(SUBLIST _argv 1 -1 _args)
+	foreach(_arg IN LISTS _args)
+		if (NOT DEFINED _MY_PARAMS_${_arg})
+			message(FATAL_ERROR "${_func}(): mandatory parameter '${_arg}' missing.")
+		endif()
+	endforeach()
+endmacro()
+
+# Verify MSYS environment.
+function(ts_verify_build_env)
+    if (WIN32)
+        #On MSYS2 64 bit builds do not work. Verify environment.
+        execute_process(COMMAND uname -s
+                        OUTPUT_VARIABLE _os_name)
+        #If uname is present we assume MSYS environment and the os name must
+        #contain MING32.
+        if(_os_name STREQUAL "" AND NOT _os_name MATCHES ".*MINGW32.*")
+            message(FATAL_ERROR "This seems to be a 64 bit MINGW shell, which has issues. Please run the 32bit version.")
+        endif()
+    endif()
+endFunction()
diff --git a/tools/cmake/compiler/GCC.cmake b/tools/cmake/compiler/GCC.cmake
new file mode 100644
index 0000000..d061d11
--- /dev/null
+++ b/tools/cmake/compiler/GCC.cmake
@@ -0,0 +1,240 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2019-2020, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+#-------------------------------------------------------------------------------
+
+#[===[.rst:
+Compiler abstraction for GCC
+----------------------------
+
+.. cmake:variable:: CROSS_COMPILE
+
+	A ';' separated GCC prefix triplets to use when searching for the cross-compiler.
+	(i.e. ``aarch64-none-elf;aarch64-elf``).
+	The variable can be set on the command line with ``-DCROSS_COMPILE=<value>`` or in the
+	environment. If both is specified, command line takes precedence.
+
+#]===]
+
+include_guard(DIRECTORY)
+
+if(NOT CROSS_COMPILE AND NOT DEFINED ENV{CROSS_COMPILE})
+	message(FATAL_ERROR "'CROSS_COMPILE' is not defined. Set if to the gcc pferix triplet, ie. cmake <..>-DCROSS_COMPILE=aarch64-elf-")
+endif()
+
+set(CROSS_COMPILE $ENV{CROSS_COMPILE} CACHE STRING "Prefix of the cross-compiler commands")
+
+#Generate a list of tool names to look for. Store the result in CMAKE_<lang>_COMPILER.
+function(gcc_find_tool NAME LANG)
+	string(REGEX REPLACE "([^;]+);" "\\1${NAME};\\1${NAME}.exe;" _gcc_names "${CROSS_COMPILE};")
+	find_program(_cross_compile_gcc NAMES ${_gcc_names} REQUIRED)
+	if (NOT _cross_compile_gcc)
+		string(REPLACE ";" " " _msg "${_gcc_names}")
+		message(FATAL_ERROR "Failed to find ${NAME} with the names: ${_msg}")
+	endif()
+	set(CMAKE_${LANG}_COMPILER ${_cross_compile_gcc} CACHE STRING "${LANG} compiler executable.")
+endfunction()
+
+gcc_find_tool(gcc C)
+gcc_find_tool(g++ CXX)
+
+#Official solution to disable compiler checks
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+#By default when INTERFACE_INCUDES of libraryes linked to an exe are treated
+#as system includes. gcc-arm-8.2-2019.01-i686-mingw32-aarch64-elf (gcc 8.2.1) will
+#set C linkage o these files, which will result in compilation errors for C++ projects.
+#This setting fixes that.
+set(CMAKE_NO_SYSTEM_FROM_IMPORTED True)
+
+#[===[.rst:
+.. cmake:command:: compiler_preprocess_file
+
+  .. code-block:: cmake
+
+    compiler_preprocess_file(SRC file.c DST file_pp.c)
+    compiler_preprocess_file(SRC file.c DST file_pp.c
+                             DEFINES USE_LIB INCLUDES include/lib)
+
+  Run the preprocessor on a file and save the output to another file. Optionally
+  provide defines and include paths to the preprocessor.
+
+  Inputs:
+
+  ``SRC``
+    Name of the source file to preprocess.
+
+  ``DST``
+    Where to write the preprocessed output.
+
+  ``DEFINES`` (multi, optional)
+    Definitions for the preprocessor.
+
+  ``INCLUDES`` (multi, optional)
+    Include paths for the preprocessor.
+
+#]===]
+function(compiler_preprocess_file)
+	set(_OPTIONS_ARGS)
+	set(_ONE_VALUE_ARGS SRC DST)
+	set(_MULTI_VALUE_ARGS DEFINES INCLUDES)
+	cmake_parse_arguments(_MY_PARAMS "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN})
+
+	check_args(compiler_preprocess_file SRC DST)
+
+	set(_flags "")
+	if(_MY_PARAMS_DEFINES)
+		list(TRANSFORM _MY_PARAMS_DEFINES PREPEND -D)
+		list(APPEND _flags ${_MY_PARAMS_DEFINES})
+	endif()
+	if(_MY_PARAMS_INCLUDES)
+		list(TRANSFORM _MY_PARAMS_INCLUDES PREPEND -I)
+		list(APPEND _flags ${_MY_PARAMS_INCLUDES})
+	endif()
+
+	add_custom_command(
+		DEPENDS ${_MY_PARAMS_SRC} OUTPUT ${_MY_PARAMS_DST}
+		COMMAND ${CMAKE_C_COMPILER} -E -P -x assembler-with-cpp ${_flags}
+				${_MY_PARAMS_SRC} -o ${_MY_PARAMS_DST}
+	)
+endfunction()
+
+#[===[.rst:
+.. cmake:command:: compiler_set_linker_script
+
+  .. code-block:: cmake
+
+    compiler_set_linker_script(TARGET foo FILE foo.ld.S)
+    compiler_set_linker_script(TARGET foo FILE foo.ld.S DEF USE_LIB INC include/lib)
+
+  Set linker script for a target. The function adds an LDFLAG using the
+  toolchain specific syntax to the TARGET_linker_script group, which is applied
+  onto the target by the caller function. FILE will be preprocessed, optionally
+  defines and/or includes can be provided using DEF/INC arguments.
+
+  Inputs:
+
+  ``TARGET``
+    Name of the target.
+
+  ``FILE``
+    Linker script file for the target.
+
+  ``DEF`` (multi, optional)
+    Defines for the linker script preprocessor.
+
+  ``INC`` (multi, optional)
+    Include paths for the linker script preprocessor.
+
+#]===]
+function(compiler_set_linker_script)
+	set(_OPTIONS_ARGS)
+	set(_ONE_VALUE_ARGS TARGET FILE)
+	set(_MULTI_VALUE_ARGS DEF INC)
+	cmake_parse_arguments(_MY_PARAMS "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN})
+
+	check_args(compiler_set_linker_script TARGET FILE)
+
+	get_filename_component(_src "${_MY_PARAMS_FILE}" ABSOLUTE)
+	get_filename_component(_src_ext "${_MY_PARAMS_FILE}" EXT)
+	set(_dst "${CMAKE_BINARY_DIR}/${_MY_PARAMS_TARGET}.ld")
+
+	if(NOT ("${_src_ext}" STREQUAL ".ld" OR "${_src_ext}" STREQUAL ".ld.S"))
+		message(WARNING "compiler_set_linker_script(): extension mismatch '${_src}'")
+	endif()
+
+	compiler_preprocess_file(
+		SRC ${_src}
+		DST ${_dst}
+		DEFINES ${_MY_PARAMS_DEF} __LINKER__
+		INCLUDES ${_MY_PARAMS_INC}
+	)
+
+	add_custom_target("${_MY_PARAMS_TARGET}_ld" DEPENDS "${_dst}")
+	add_dependencies("${_MY_PARAMS_TARGET}" "${_MY_PARAMS_TARGET}_ld")
+
+	group_add(NAME "${_MY_PARAMS_TARGET}_linker_script" TYPE CONFIG KEY "LINK_DEPENDS" VAL "${_dst}")
+	group_add(NAME "${_MY_PARAMS_TARGET}_linker_script" TYPE LDFLAG KEY "-Wl,--script" VAL "${_dst}")
+endfunction()
+
+#[===[.rst:
+.. cmake:command:: compiler_generate_binary_output
+
+  .. code-block:: cmake
+
+    compiler_generate_binary_output(TARGET <name> RES <var>)
+
+  Generate binary output for the target. The function converts the output
+  executable into bin file using toolchain specific syntax.
+
+  Inputs:
+
+  ``TARGET``
+    Name of the target.
+
+  Outputs:
+
+  ``RES``
+    Full patch to output file.
+
+#]===]
+function(compiler_generate_binary_output)
+	set(options)
+	set(oneValueArgs TARGET)
+	set(multiValueArgs)
+	cmake_parse_arguments(MY "${options}" "${oneValueArgs}"
+						"${multiValueArgs}" ${ARGN} )
+	add_custom_command(
+		TARGET ${MY_TARGET} POST_BUILD
+		COMMAND ${CMAKE_OBJCOPY} -O binary
+				$<TARGET_FILE:${MY_TARGET}>
+				$<TARGET_FILE_DIR:${MY_TARGET}>/${MY_TARGET}.bin)
+	if (MY_RES)
+		set(${MY_RES} $<TARGET_FILE_DIR:${MY_TARGET}>/${MY_TARGET}.bin PARENT_SCOPE)
+	endif()
+
+endfunction()
+
+#[===[.rst:
+.. cmake:command:: compiler_generate_stripped_elf
+
+  .. code-block:: cmake
+
+    compiler_generate_stripped_elf(TARGET foo NAME foo.stripped.elf RES var)
+
+  Strip all symbols that are not needed for relocation processing and return the location
+  of the result.
+
+  Inputs:
+
+  ``TARGET``
+    Name of the target.
+
+  ``NAME``
+    Name of output file
+
+  Outputs:
+
+  ``RES``
+    Name of variable to store the full path of the stripped executable.
+
+#]===]
+
+function(compiler_generate_stripped_elf)
+	set(options)
+	set(oneValueArgs TARGET NAME RES)
+	set(multiValueArgs)
+	cmake_parse_arguments(MY "${options}" "${oneValueArgs}"
+						"${multiValueArgs}" ${ARGN} )
+
+	add_custom_command(
+		TARGET ${MY_TARGET} POST_BUILD
+		COMMAND ${CMAKE_OBJCOPY} --strip-unneeded
+				$<TARGET_FILE:${MY_TARGET}>
+				$<TARGET_FILE_DIR:${MY_TARGET}>/${MY_NAME})
+	if (MY_RES)
+		set(${MY_RES} $<TARGET_FILE_DIR:${MY_TARGET}>/${MY_NAME} PARENT_SCOPE)
+	endif()
+endfunction()