#
# Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
#
# SPDX-License-Identifier: BSD-2-Clause
#

# This module provides `DeclareRootserver` for making an executable target a rootserver
# and bundling it with a kernel.elf and any required loaders into an `images` directory
# in the top level build directory.
include_guard(GLOBAL)

# Helper function for modifying the linker flags of a target to set the entry point as _sel4_start
function(SetSeL4Start target)
    set_property(
        TARGET ${target}
        APPEND_STRING
        PROPERTY LINK_FLAGS " -Wl,-u_sel4_start -Wl,-e_sel4_start "
    )
endfunction(SetSeL4Start)

# We need to the real non symlinked list path in order to find the linker script that is in
# the common-tool directory
find_file(
    TLS_ROOTSERVER tls_rootserver.lds
    PATHS "${CMAKE_CURRENT_LIST_DIR}"
    CMAKE_FIND_ROOT_PATH_BOTH
)
mark_as_advanced(TLS_ROOTSERVER)

find_file(UIMAGE_TOOL make-uimage PATHS "${CMAKE_CURRENT_LIST_DIR}" CMAKE_FIND_ROOT_PATH_BOTH)
mark_as_advanced(UIMAGE_TOOL)
include(CMakeDependentOption)
# NB: do not override kernel platform settings
#cmake_dependent_option(UseRiscVOpenSBI "Use OpenSBI." ON DEPENDS "KernelArchRiscV" OFF)

if(UseRiscVOpenSBI)
    set(OPENSBI_PATH "${CMAKE_SOURCE_DIR}/tools/opensbi" CACHE STRING "OpenSBI Folder location")
    mark_as_advanced(FORCE OPENSBI_PATH)
endif()

function(DeclareRootserver rootservername)
    SetSeL4Start(${rootservername})
    set_property(
        TARGET ${rootservername}
        APPEND_STRING
        PROPERTY LINK_FLAGS " -Wl,-T ${TLS_ROOTSERVER} "
    )
    if("${KernelArch}" STREQUAL "x86")
        set(
            IMAGE_NAME
            "${CMAKE_BINARY_DIR}/images/${rootservername}-image-${KernelSel4Arch}-${KernelPlatform}"
        )
        set(
            KERNEL_IMAGE_NAME
            "${CMAKE_BINARY_DIR}/images/kernel-${KernelSel4Arch}-${KernelPlatform}"
        )
        # Declare targets for building the final kernel image
        if(Kernel64)
            add_custom_command(
                OUTPUT "${KERNEL_IMAGE_NAME}"
                COMMAND
                    ${CMAKE_OBJCOPY} -O elf32-i386 $<TARGET_FILE:kernel.elf> "${KERNEL_IMAGE_NAME}"
                VERBATIM
                DEPENDS kernel.elf
                COMMENT "objcopy kernel into bootable elf"
            )
        else()
            add_custom_command(
                OUTPUT "${KERNEL_IMAGE_NAME}"
                COMMAND cp $<TARGET_FILE:kernel.elf> "${KERNEL_IMAGE_NAME}"
                VERBATIM
                DEPENDS kernel.elf
            )
        endif()
        add_custom_command(
            OUTPUT "${IMAGE_NAME}"
            COMMAND cp $<TARGET_FILE:${rootservername}> "${IMAGE_NAME}"
            DEPENDS ${rootservername}
        )
        add_custom_target(
            rootserver_image ALL
            DEPENDS
                "${IMAGE_NAME}"
                "${KERNEL_IMAGE_NAME}"
                kernel.elf
                $<TARGET_FILE:${rootservername}>
                ${rootservername}
        )
    elseif(KernelArchARM OR KernelArchRiscV)
        set(
            IMAGE_NAME
            "${CMAKE_BINARY_DIR}/images/${rootservername}-image-${KernelArch}-${KernelPlatform}"
        )
        set(elf_target_file $<TARGET_FILE:elfloader>)
        if(KernelArchRiscV)
            if(UseRiscVOpenSBI)
                # When using OpenSBI, the whole system image (usually consisting
                # of the ELF-Loader, a device tree, the kernel, and a userland)
                # is packaged as an OpenSBI payload.

                if("${CROSS_COMPILER_PREFIX}" STREQUAL "")
                    message(FATAL_ERROR "CROSS_COMPILER_PREFIX not set.")
                endif()

                if("${KernelOpenSBIPlatform}" STREQUAL "")
                    message(FATAL_ERROR "KernelOpenSBIPlatform not set.")
                endif()

                if(NOT OPENSBI_PLAT_XLEN)
                    set(OPENSBI_PLAT_XLEN "${KernelWordSize}")
                endif()

                if(NOT OPENSBI_PLAT_ISA)
                    set(OPENSBI_PLAT_ISA "rv${OPENSBI_PLAT_XLEN}imafdc")
                endif()

                if(NOT OPENSBI_PLAT_ABI)
                    if(Kernel32)
                        set(OPENSBI_PLAT_ABI "ilp32d")
                    else()
                        set(OPENSBI_PLAT_ABI "lp64d")
                    endif()
                endif()

                file(GLOB_RECURSE deps)
                set(OPENSBI_BINARY_DIR "${CMAKE_BINARY_DIR}/opensbi")
                # OPENSBI_PLAYLOAD is a binary dump of the system image ELF
                set(OPENSBI_PLAYLOAD "${OPENSBI_BINARY_DIR}/payload")
                # OPENSBI_SYSTEM_IMAGE_ELF is the OpenSBI EFL file that contains
                # our system image as firmware payload
                set(
                    OPENSBI_SYSTEM_IMAGE_ELF
                    "${OPENSBI_BINARY_DIR}/platform/${KernelOpenSBIPlatform}/firmware/fw_payload.elf"
                )

                add_custom_command(
                    OUTPUT "${OPENSBI_SYSTEM_IMAGE_ELF}"
                    COMMAND mkdir -p "${OPENSBI_BINARY_DIR}"
                    COMMAND
                        make -s -C "${OPENSBI_PATH}" O="${OPENSBI_BINARY_DIR}"
                        PLATFORM="${KernelOpenSBIPlatform}" clean
                    COMMAND
                        ${CMAKE_OBJCOPY} -O binary "${elf_target_file}" "${OPENSBI_PLAYLOAD}"
                    COMMAND
                        make -C "${OPENSBI_PATH}" O="${OPENSBI_BINARY_DIR}"
                        CROSS_COMPILE=${CROSS_COMPILER_PREFIX} PLATFORM="${KernelOpenSBIPlatform}"
                        PLATFORM_RISCV_XLEN=${OPENSBI_PLAT_XLEN}
                        PLATFORM_RISCV_ISA=${OPENSBI_PLAT_ISA}
                        PLATFORM_RISCV_ABI=${OPENSBI_PLAT_ABI} FW_PAYLOAD_PATH="${OPENSBI_PLAYLOAD}"
                    DEPENDS "${elf_target_file}" elfloader ${USES_TERMINAL_DEBUG}
                )
                # overwrite elf_target_file, it's no longer the ElfLoader but
                # the OpenSBI ELF (which contains the ElfLoader as payload)
                set(elf_target_file "${OPENSBI_SYSTEM_IMAGE_ELF}")
            endif()
        endif()
        set(binary_efi_list "binary;efi")
        if(${ElfloaderImage} IN_LIST binary_efi_list)
            # If not an elf we construct an intermediate rule to do an objcopy to binary
            add_custom_command(
                OUTPUT "${IMAGE_NAME}"
                COMMAND
                    ${CMAKE_OBJCOPY} -O binary ${elf_target_file} "${IMAGE_NAME}"
                DEPENDS ${elf_target_file} elfloader
            )
        elseif("${ElfloaderImage}" STREQUAL "uimage")
            # Construct payload for U-Boot.
            if(KernelSel4ArchAarch32)
                set(UIMAGE_ARCH "arm")
            elseif(KernelSel4ArchAarch64)
                set(UIMAGE_ARCH "arm64")
            else()
                message(
                    FATAL_ERROR "uimage: Unsupported architecture: ${KernelArch}/${KernelSel4Arch}"
                )
            endif()

            # Older versions of CMake don't look for readelf when initializing other binutils tools.
            if(NOT CMAKE_READELF)
                find_program(CMAKE_READELF NAMES ${CROSS_COMPILER_PREFIX}readelf)
                if(NOT CMAKE_READELF)
                    message(
                        FATAL_ERROR
                            "Could not find a valid readelf program: ${CROSS_COMPILER_PREFIX}readelf.
                        ElfloaderImage type 'uimage' cannot be built."
                    )
                endif()
            endif()

            add_custom_command(
                OUTPUT "${IMAGE_NAME}"
                COMMAND
                    ${UIMAGE_TOOL} ${CMAKE_OBJCOPY} ${CMAKE_READELF} ${elf_target_file}
                    ${UIMAGE_ARCH} ${IMAGE_NAME}
                DEPENDS ${elf_target_file} elfloader
            )
        else()
            add_custom_command(
                OUTPUT "${IMAGE_NAME}"
                COMMAND
                    ${CMAKE_COMMAND} -E copy ${elf_target_file} "${IMAGE_NAME}"
                DEPENDS ${elf_target_file} elfloader
            )
        endif()
        add_custom_target(rootserver_image ALL DEPENDS "${IMAGE_NAME}" elfloader ${rootservername})
        # Set the output name for the rootserver instead of leaving it to the generator. We need
        # to do this so that we can put the rootserver image name as a property and have the
        # elfloader pull it out using a generator expression, since generator expression cannot
        # nest (i.e. in the expansion of $<TARGET_FILE:tgt> 'tgt' cannot itself be a generator
        # expression. Nor can a generator expression expand to another generator expression and
        # get expanded again. As a result we just fix the output name and location of the rootserver
        set_property(TARGET "${rootservername}" PROPERTY OUTPUT_NAME "${rootservername}")
        get_property(rootimage TARGET "${rootservername}" PROPERTY OUTPUT_NAME)
        get_property(dir TARGET "${rootservername}" PROPERTY BINARY_DIR)
        set_property(TARGET rootserver_image PROPERTY ROOTSERVER_IMAGE "${dir}/${rootimage}")
    else()
        message(FATAL_ERROR "Unsupported architecture.")
    endif()
    # Store the image and kernel image as properties
    # We use relative paths to the build directory
    file(RELATIVE_PATH IMAGE_NAME_REL ${CMAKE_BINARY_DIR} ${IMAGE_NAME})
    if(NOT "${KERNEL_IMAGE_NAME}" STREQUAL "")
        file(RELATIVE_PATH KERNEL_IMAGE_NAME_REL ${CMAKE_BINARY_DIR} ${KERNEL_IMAGE_NAME})
    endif()
    set_property(TARGET rootserver_image PROPERTY IMAGE_NAME "${IMAGE_NAME_REL}")
    set_property(TARGET rootserver_image PROPERTY KERNEL_IMAGE_NAME "${KERNEL_IMAGE_NAME_REL}")
endfunction(DeclareRootserver)