CMakeLists.txt

## @file
 # Copyright (c) 2023-2026, Arm Limited or its affiliates. All rights reserved.
 # SPDX-License-Identifier : Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #  http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ##

# Set the minimum required version of CMake for the project
cmake_minimum_required(VERSION 3.21)

project(sysarch-acs LANGUAGES)

# cmake_policy
cmake_policy(SET CMP0001 NEW)

### Tool dependency check - end ###

get_filename_component(ROOT_DIR . ABSOLUTE)

# Set internal build directory variable
set(BUILD ${CMAKE_CURRENT_BINARY_DIR} CACHE INTERNAL "Setting build directory to ${BUILD}" FORCE)

# Set global compile list variable
set(COMPILE_LIST "")

if(NOT DEFINED ACS_CREATE_WRAPPER_TARGETS)
    set(ACS_CREATE_WRAPPER_TARGETS OFF CACHE BOOL
        "Generate wrapper targets (bsa/sbsa/pc_bsa/acs_all) that configure child build trees.")
endif()

#### Include cmake support module ###
include(${ROOT_DIR}/tools/cmake/toolchain/utils.cmake)
include(${ROOT_DIR}/tools/cmake/toolchain/default.cmake)
####


### Valid value range for command line argument ###

list(APPEND ARM_ARCH_MAJOR_LIST 8 9)
list(APPEND ACS_LIST "bsa" "sbsa" "pc_bsa")

###
# Prefer the toolchain file to validate and set `CROSS_COMPILE`.
# If no toolchain file is provided, require `CROSS_COMPILE` from the
# environment to support local cross-configures.
if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
    if(NOT DEFINED CROSS_COMPILE)
        set(CROSS_COMPILE $ENV{CROSS_COMPILE})
    endif()

    if(NOT DEFINED CROSS_COMPILE OR "${CROSS_COMPILE}" STREQUAL "")
        message(FATAL_ERROR "CROSS_COMPILE not defined. Please set CROSS_COMPILE or use -DCMAKE_TOOLCHAIN_FILE=<path>.")
    endif()
endif()

# NOTE: cross-toolchain selection is handled by an explicit toolchain file
# (`tools/cmake/toolchain/arm-none-elf-toolchain.cmake`). Users should
# configure with `-DCMAKE_TOOLCHAIN_FILE=...` to avoid host-specific flags.

# Check for valid targets
_get_sub_dir_list(TARGET_LIST ${ROOT_DIR}/pal/baremetal/target/)
if(NOT DEFINED TARGET)
    set(TARGET ${TARGET_DFLT} CACHE INTERNAL "Defaulting target to ${TARGET}" FORCE)
else()
    set(TARGET ${TARGET} CACHE INTERNAL "TARGET is set to ${TARGET}" FORCE)
endif()

if(NOT ${TARGET} IN_LIST TARGET_LIST)
    message(FATAL_ERROR "[ACS] : Error: Unspported value for -DTARGET=, supported targets are : ${TARGET_LIST}")
endif()

if(NOT DEFINED ACS)
    set(ACS "${ACS_DFLT}" CACHE INTERNAL "Defaulting ACS to ${ACS}" FORCE)
else()
    set(ACS "${ACS}" CACHE INTERNAL "ACS is set to ${ACS}" FORCE)
endif()

if(NOT ${ACS} IN_LIST ACS_LIST)
    message(FATAL_ERROR "[ACS] : Error: Unspported value for -DACS=, supported acs are : ${ACS_LIST}")
endif()

# Check for ARM_ARCH_MAJOR
if(NOT DEFINED ARM_ARCH_MAJOR)
    set(ARM_ARCH_MAJOR "${ARM_ARCH_MAJOR_DFLT}" CACHE INTERNAL "Default ARM_ARCH_MAJOR value" FORCE)
        message(STATUS "[ACS] : Defaulting ARM_ARCH_MAJOR to ${ARM_ARCH_MAJOR}")
else()
    if(NOT ${ARM_ARCH_MAJOR} IN_LIST ARM_ARCH_MAJOR_LIST)
        message(FATAL_ERROR "[ACS] : Error: Unspported value for -DARM_ARCH_MAJOR=, supported values are : ${ARM_ARCH_MAJOR_LIST}")
    endif()
    message(STATUS "[ACS] : ARM_ARCH_MAJOR is set to ${ARM_ARCH_MAJOR}")
endif()

# Check for ARM_ARCH_MINOR
if(NOT DEFINED ARM_ARCH_MINOR)
    set(ARM_ARCH_MINOR "${ARM_ARCH_MINOR_DFLT}" CACHE INTERNAL "Default ARM_ARCH_MINOR value" FORCE)
        message(STATUS "[ACS] : Defaulting ARM_ARCH_MINOR to ${ARM_ARCH_MINOR}")
else()
    message(STATUS "[ACS] : ARM_ARCH_MINOR is set to ${ARM_ARCH_MINOR}")
endif()

# Setup toolchain parameters for compilation and link
include(${ROOT_DIR}/tools/cmake/toolchain/common.cmake)

# Propagate ACS_ENABLED_MODULE_LIST into compiler definitions for all sources
if(DEFINED ACS_ENABLED_MODULE_LIST)
    message(STATUS "[ACS] : ACS_ENABLED_MODULE_LIST (compile defs) = ${ACS_ENABLED_MODULE_LIST}")
    add_compile_definitions(ACS_ENABLED_MODULE_LIST=${ACS_ENABLED_MODULE_LIST})
endif()

if(DEFINED ACS_ENABLE_MMU)
    message(STATUS "[ACS] : ACS_ENABLE_MMU (compile defs) = ${ACS_ENABLE_MMU}")
    add_compile_definitions(ACS_ENABLE_MMU=${ACS_ENABLE_MMU})
endif()

if(NOT DEFINED CHIP_ID)
    set(CHIP_ID 0 CACHE STRING "Default CHIP_ID value" FORCE)
    message(STATUS "[ACS] : Defaulting CHIP_ID to ${CHIP_ID}")
else()
    set(CHIP_ID "${CHIP_ID}" CACHE STRING "CHIP_ID is set to ${CHIP_ID}" FORCE)
    message(STATUS "[ACS] : CHIP_ID is set to ${CHIP_ID}")
endif()
add_compile_definitions(CHIP_ID=${CHIP_ID})

# Propagate ACS_VERBOSE_LEVEL into compiler definitions for all sources
if(DEFINED ACS_VERBOSE_LEVEL)
    message(STATUS "[ACS] : ACS_VERBOSE_LEVEL (compile defs) = ${ACS_VERBOSE_LEVEL}")
    add_compile_definitions(ACS_VERBOSE_LEVEL=${ACS_VERBOSE_LEVEL})
    if("${ACS_VERBOSE_LEVEL}" MATCHES "^[0-9]+$")
        if(${ACS_VERBOSE_LEVEL} GREATER 6)
            message(WARNING "[ACS] : ACS_VERBOSE_LEVEL=${ACS_VERBOSE_LEVEL} is above the expected range; would be ceiled to 6")
        elseif(${ACS_VERBOSE_LEVEL} LESS 1)
            message(WARNING "[ACS] : ACS_VERBOSE_LEVEL=${ACS_VERBOSE_LEVEL} is below the expected range; would be floored to 1")
        endif()
    endif()
endif()

# Propagate ACS_LEVEL into compiler definitions for all sources.
# This selects the compliance level for the active ACS suite at compile
# time, overriding the PLATFORM_OVERRIDE_<ACS>_LEVEL value supplied by
# the platform header. Valid values:
#   - A positive integer: sets ctx->level_value = <n> and selects
#     LVL_FILTER_MAX (run all rules with level <= n).
#   - "fr" / "FR": selects LVL_FILTER_FR (future-requirements mode);
#     ctx->level_value is left at the platform default.
# Per-ACS valid numeric ranges:
#   bsa    : 1
#   sbsa   : 3..7
#   pc_bsa : 1
# Usage:
#   cmake -DACS_LEVEL=7 ...
#   cmake -DACS_LEVEL=fr ...
if(DEFINED ACS_LEVEL)
    string(TOUPPER "${ACS_LEVEL}" _ACS_LEVEL_UC)
    if("${_ACS_LEVEL_UC}" STREQUAL "FR")
        message(STATUS "[ACS] : ACS_LEVEL=fr -> selecting LVL_FILTER_FR (compile defs: ACS_LEVEL_FR)")
        add_compile_definitions(ACS_LEVEL_FR)
    elseif("${ACS_LEVEL}" MATCHES "^[0-9]+$")
        message(STATUS "[ACS] : ACS_LEVEL (compile defs) = ${ACS_LEVEL}")
        if("${ACS}" STREQUAL "sbsa")
            if(${ACS_LEVEL} LESS 3 OR ${ACS_LEVEL} GREATER 7)
                message(WARNING "[ACS] : ACS_LEVEL=${ACS_LEVEL} is outside the supported SBSA range (3..7); runtime will clamp it")
            endif()
        elseif("${ACS}" STREQUAL "bsa" OR "${ACS}" STREQUAL "pc_bsa")
            if(NOT ${ACS_LEVEL} EQUAL 1)
                message(WARNING "[ACS] : ACS_LEVEL=${ACS_LEVEL} is not the only supported level for ${ACS} (1); runtime will clamp it")
            endif()
        endif()
        add_compile_definitions(ACS_LEVEL=${ACS_LEVEL})
    else()
        message(FATAL_ERROR "[ACS] : ACS_LEVEL must be a positive integer or 'fr' (got '${ACS_LEVEL}')")
    endif()
endif()

### Cmake clean target ###
list(APPEND CLEAN_LIST
        ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_HEADER}
        ${CMAKE_CURRENT_BINARY_DIR}/output
)

# Optional forwarding of ACS_ENABLED_MODULE_LIST to inner configure
set(DEFAULT_OVERRIDE_ARGS "")
if(DEFINED CROSS_COMPILE AND NOT "${CROSS_COMPILE}" STREQUAL "")
    message(STATUS "[ACS] : CROSS_COMPILE (top-level) = ${CROSS_COMPILE}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DCROSS_COMPILE=${CROSS_COMPILE})
endif()

if(DEFINED CC AND NOT "${CC}" STREQUAL "")
    message(STATUS "[ACS] : CC (top-level) = ${CC}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DCC=${CC})
endif()

if(DEFINED ARM_ARCH_MAJOR)
    message(STATUS "[ACS] : ARM_ARCH_MAJOR (top-level) = ${ARM_ARCH_MAJOR}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DARM_ARCH_MAJOR=${ARM_ARCH_MAJOR})
endif()

if(DEFINED ARM_ARCH_MINOR)
    message(STATUS "[ACS] : ARM_ARCH_MINOR (top-level) = ${ARM_ARCH_MINOR}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DARM_ARCH_MINOR=${ARM_ARCH_MINOR})
endif()

if(DEFINED ACS_ENABLED_MODULE_LIST)
    message(STATUS "[ACS] : ACS_ENABLED_MODULE_LIST (top-level) = ${ACS_ENABLED_MODULE_LIST}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DACS_ENABLED_MODULE_LIST=${ACS_ENABLED_MODULE_LIST})
endif()

if(DEFINED ACS_ENABLE_MMU)
    message(STATUS "[ACS] : ACS_ENABLE_MMU (compile defs) = ${ACS_ENABLE_MMU}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DACS_ENABLE_MMU=${ACS_ENABLE_MMU})
endif()

#   cmake -DCHIP_ID=0
list(APPEND DEFAULT_OVERRIDE_ARGS -DCHIP_ID=${CHIP_ID})

#   cmake -DACS_VERBOSE_LEVEL=1 ...
if(DEFINED ACS_VERBOSE_LEVEL)
    message(STATUS "[ACS] : ACS_VERBOSE_LEVEL (top-level) = ${ACS_VERBOSE_LEVEL}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DACS_VERBOSE_LEVEL=${ACS_VERBOSE_LEVEL})
endif()

#   cmake -DACS_LEVEL=7 ...
if(DEFINED ACS_LEVEL)
    message(STATUS "[ACS] : ACS_LEVEL (top-level) = ${ACS_LEVEL}")
    list(APPEND DEFAULT_OVERRIDE_ARGS -DACS_LEVEL=${ACS_LEVEL})
endif()

# Enable fast-path optimizations for simulation/emulation builds.
# Use:
#   cmake -DTARGET_SIMULATION=ON ...
option(TARGET_SIMULATION "Enable simulation/emulation optimizations (defines TARGET_SIMULATION)" OFF)
if(TARGET_SIMULATION)
    message(STATUS "[ACS] : TARGET_SIMULATION is enabled (defining TARGET_SIMULATION)")
    add_compile_definitions(TARGET_SIMULATION)
else()
    message(STATUS "[ACS] : TARGET_SIMULATION is disabled")
endif()

# Include the files for make clean
foreach(clean_item ${CLEAN_LIST})
        set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${clean_item})
endforeach()
###

# Reuse the caller-provided toolchain for nested configure steps, so
# convenience targets do not override user choices.
set(_acs_toolchain_arg "")
if(DEFINED CMAKE_TOOLCHAIN_FILE AND NOT "${CMAKE_TOOLCHAIN_FILE}" STREQUAL "")
    set(_acs_toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}")
else()
    set(_acs_toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${ROOT_DIR}/tools/cmake/toolchain/arm-none-elf-toolchain.cmake")
endif()

message(STATUS "[ACS] : ACS is set to ${ACS}, and TARGET to ${TARGET} based on configuration")
message(STATUS "[ACS] : You can change overide target using -DTARGET=<value>")
message(STATUS "[ACS] : Supported values for TARGET: ${TARGET_LIST}")
message(STATUS "[ACS] : Example - cmake --preset bsa -DTARGET=RDV3")
message(STATUS "[ACS] : Check available presets by - `cmake --list-presets`")
message(STATUS "[ACS] : To build using cmake - `cmake --build --preset bsa`")

if(ACS_CREATE_WRAPPER_TARGETS)
    # Wrapper builds exist only to drive child per-ACS build trees.
    # Force wrappers off in children to avoid recursive nested build dirs.
    foreach(_acs IN LISTS ACS_LIST)
        add_custom_target(${_acs}
            COMMAND ${CMAKE_COMMAND} -DACS=${_acs} -DTARGET=${TARGET} -DTARGET_SIMULATION=${TARGET_SIMULATION}
            -DACS_CREATE_WRAPPER_TARGETS=OFF ${DEFAULT_OVERRIDE_ARGS}
            -DCMAKE_OSX_ARCHITECTURES= ${_acs_toolchain_arg} -S ${CMAKE_SOURCE_DIR} -B ${CMAKE_BINARY_DIR}/${_acs}_build
            COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/${_acs}_build
        )
    endforeach()

    add_custom_target(acs_all ALL
        DEPENDS ${ACS_LIST}
    )

    message(STATUS "[ACS] : To build using make - `cmake --preset acs_all; cd build; make bsa` (to build all baremetal acs - `make acs_all`)")
else()
    add_subdirectory(${ROOT_DIR}/tools/cmake/infra)
endif()