helpers.cmake

################################################################################
# Add new userspace program function
################################################################################

# Define a global property to store all user program targets
define_property(GLOBAL
   PROPERTY USER_PROGRAM_TARGETS
   BRIEF_DOCS "List of all user program targets"
   FULL_DOCS "Global list of all targets created with add_user_program function"
)

# Define a new user program to add to the ramdisk
function(add_user_program target_path)
   # Extract the source files from the remaining arguments
   cmake_parse_arguments(ARG "SYSTEM_COMPONENT" "SERVICE_ABI" "FILES;DEFINES;EXTRA_LIBS" ${ARGN})
   # Replace '/' in the target_path with '_'
   string(REPLACE "/" "_" target_name ${target_path})
   get_filename_component(target_dir_component "${target_path}.x" DIRECTORY)
   get_filename_component(target_file_component "${target_path}.x" NAME_WLE)
   # Create an executable target with the given name and source files
   if(NOT DEFINED ARG_SERVICE_ABI)
      set(ARG_SERVICE_ABI "${CMAKE_SOURCE_DIR}/lib/user/_service_abi.cc")
   endif()
   if(ARG_SYSTEM_COMPONENT)
      list(APPEND ARG_DEFINES SYSTEM_COMPONENT)
   else()
      set(ARG_SERVICE_ABI "${CMAKE_SOURCE_DIR}/lib/user/_user_abi.cc")
   endif()
   add_executable(${target_name} ${ARG_FILES} ${ARG_SERVICE_ABI})
   # Add the current source directory as an include path
   target_include_directories(
      ${target_name} PRIVATE
      "${CMAKE_CURRENT_LIST_DIR}/"
   )
   # Set the user programs to output to ${SYSROOT_PATH}
   set_target_properties(
      ${target_name}
      PROPERTIES
      OUTPUT_NAME "${target_file_component}"
      RUNTIME_OUTPUT_DIRECTORY "${SYSROOT_PATH}/${target_dir_component}"
   )
   # Add the USERSPACE define to the compilation
   target_compile_definitions(
      ${target_name} PRIVATE
      USERSPACE
      ${ARG_DEFINES}
      ${USER_COMPILE_DEFINITIONS}
   )
   # Set compile and linker flags
   target_link_options(
      ${target_name} PRIVATE
      ${STANDARD_LINKER_FLAGS}
      LINKER:-T${CMAKE_CURRENT_SOURCE_DIR}/lib/user/linker.ld
   )
   target_compile_options(
      ${target_name} PRIVATE
      $<$<COMPILE_LANGUAGE:CXX>:${USER_CXX_FLAGS}>
      $<$<COMPILE_LANGUAGE:CXX>:${USER_EXTRA_COMPILE_FLAGS}>
      # FIXME(kevin): ... do something about this ...
      # -mgeneral-regs-only
   )
   # Link against the mimalloc library
   target_link_libraries(${target_name} user ${ARG_EXTRA_LIBS})
   # Add this target to our global list
   get_property(targets GLOBAL PROPERTY USER_PROGRAM_TARGETS)
   list(APPEND targets ${target_name})
   set_property(GLOBAL PROPERTY USER_PROGRAM_TARGETS ${targets})
endfunction()

# Helper function to get all user programs
function(get_all_user_programs output_var)
   get_property(targets
      GLOBAL
      PROPERTY USER_PROGRAM_TARGETS)
   set(${output_var} ${targets} PARENT_SCOPE)
endfunction()

################################################################################
# Colourized outputs and opt_message() function
# https://stackoverflow.com/questions/18968979/how-to-make-colorized-message-with-cmake
################################################################################

if(NOT WIN32)
   string(ASCII 27 Esc)
   set(ColourReset "${Esc}[m")
   set(ColourBold "${Esc}[1m")
   set(Red "${Esc}[31m")
   set(Green "${Esc}[32m")
   set(Yellow "${Esc}[33m")
   set(Blue "${Esc}[34m")
   set(Magenta "${Esc}[35m")
   set(Cyan "${Esc}[36m")
   set(White "${Esc}[37m")
   set(BoldRed "${Esc}[1;31m")
   set(BoldGreen "${Esc}[1;32m")
   set(BoldYellow "${Esc}[1;33m")
   set(BoldBlue "${Esc}[1;34m")
   set(BoldMagenta "${Esc}[1;35m")
   set(BoldCyan "${Esc}[1;36m")
   set(BoldWhite "${Esc}[1;37m")
endif()

function(opt_message)
   message(STATUS "${BoldMagenta}${ARGV}${ColourReset}")
endfunction()

function(info_message)
   message(STATUS "${Cyan}${ARGV}${ColourReset}")
endfunction()

function(lib_message)
   message(STATUS "${Green}${ARGV}${ColourReset}")
endfunction()

################################################################################
# Detect Clang/LLVM version
################################################################################

function(_check_clang_version validator_result_var item)
   execute_process(
      COMMAND ${item} --version
      OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
      RESULT_VARIABLE CLANG_VERSION_RESULT
      OUTPUT_STRIP_TRAILING_WHITESPACE
   )
   if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "clang version 17")
      set(${validator_result_var} TRUE PARENT_SCOPE)
   else()
      set(${validator_result_var} FALSE PARENT_SCOPE)
   endif()
endfunction()

function(_check_llvm_version validator_result_var item)
   execute_process(
      COMMAND ${item} --version
      OUTPUT_VARIABLE LLVM_VERSION_OUTPUT
      RESULT_VARIABLE LLVM_VERSION_RESULT
      OUTPUT_STRIP_TRAILING_WHITESPACE
   )
   if(LLVM_VERSION_RESULT EQUAL 0 AND LLVM_VERSION_OUTPUT MATCHES "LLVM version 17")
      set(${validator_result_var} TRUE PARENT_SCOPE)
   else()
      set(${validator_result_var} FALSE PARENT_SCOPE)
   endif()
endfunction()

function(validate_tool common_name compiler validator)
   set(result FALSE)
   cmake_language(CALL ${validator} result ${compiler})
   if(NOT result)
      message(FATAL_ERROR "Cannot find ${common_name} at ${compiler}.")
   else()
      message(STATUS "Found ${compiler}")
   endif()
endfunction()

function(try_detect_tools)
   # NOTE: Homebrew's llvm@17 is listed first so that on macOS we pick its
   # `clang++` over Apple's `/usr/bin/clang++`. Apple Clang also reports version
   # 17 (passing the validator) but emits LTO bitcode that Homebrew's llvm-ar
   # cannot read, producing a broken, mismatched toolchain.
   set(CLANG_HINT_PATHS
      /opt/homebrew/opt/llvm@17/bin/
      /usr/bin/
   )

   # Find clang only when we disable override
   if(NOT ENABLE_CLANG_OVERRIDE)
      # Find clang-17
      find_program(CLANG_17
         NAMES clang-17 clang
         HINTS ${CLANG_HINT_PATHS}
         VALIDATOR _check_clang_version
         NO_DEFAULT_PATH
      )
      if(CLANG_17)
         set(CMAKE_C_COMPILER ${CLANG_17} PARENT_SCOPE)
      endif()

      # Find clang++-17
      find_program(CLANGXX_17
         NAMES clang++-17 clang++
         HINTS ${CLANG_HINT_PATHS}
         VALIDATOR _check_clang_version
         NO_DEFAULT_PATH
      )
      if(CLANGXX_17)
         set(CMAKE_CXX_COMPILER ${CLANGXX_17} PARENT_SCOPE)
      endif()
   endif()

   # Find llvm-mc-17
   find_program(LLVM_MC_17
      NAMES llvm-mc-17 llvm-mc
      HINTS ${CLANG_HINT_PATHS}
      VALIDATOR _check_llvm_version
      NO_DEFAULT_PATH
   )
   if(LLVM_MC_17)
      set(CMAKE_ASM_COMPILER ${LLVM_MC_17} PARENT_SCOPE)
   endif()

   # Find llvm-objcopy-17
   find_program(LLVM_OBJCOPY_17
      NAMES llvm-objcopy-17 llvm-objcopy
      HINTS ${CLANG_HINT_PATHS}
      VALIDATOR _check_llvm_version
      NO_DEFAULT_PATH
   )
   if(LLVM_OBJCOPY_17)
      set(MY_OBJCOPY_EXEC_PATH ${LLVM_OBJCOPY_17} PARENT_SCOPE)
   endif()

   # Find llvm-ar-17
   find_program(LLVM_AR_17
      NAMES llvm-ar-17 llvm-ar
      HINTS ${CLANG_HINT_PATHS}
      VALIDATOR _check_llvm_version
      NO_DEFAULT_PATH
   )
   if(LLVM_AR_17)
      set(CMAKE_AR ${LLVM_AR_17} PARENT_SCOPE)
      set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qc --format=gnu <TARGET> <OBJECTS>")
      set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qc --format=gnu <TARGET> <OBJECTS>")
   endif()

   # Find llvm-ranlib-17
   find_program(LLVM_RANLIB_17
      NAMES llvm-ranlib-17 llvm-ranlib
      HINTS ${CLANG_HINT_PATHS}
      VALIDATOR _check_llvm_version
      NO_DEFAULT_PATH
   )
   if(LLVM_RANLIB_17)
      set(CMAKE_RANLIB ${LLVM_RANLIB_17} PARENT_SCOPE)
      set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
      set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
   endif()
endfunction()

function(check_tool_versions)
   if(NOT DEFINED CMAKE_ASM_COMPILER)
      message(FATAL_ERROR "Please set CMAKE_ASM_COMPILER to the path of llvm-mc.")
   endif()
   if(MY_OBJCOPY_EXEC_PATH STREQUAL "")
      message(FATAL_ERROR "Please set MY_OBJCOPY_EXEC_PATH to the path of llvm-objcopy.")
   endif()
   if(NOT ENABLE_CLANG_OVERRIDE)
      validate_tool("Clang 17" ${CMAKE_C_COMPILER} _check_clang_version)
      validate_tool("Clang++ 17" ${CMAKE_CXX_COMPILER} _check_clang_version)
   endif()
   validate_tool("LLVM MC 17" ${CMAKE_ASM_COMPILER} _check_llvm_version)
   validate_tool("LLVM Objcopy 17" ${MY_OBJCOPY_EXEC_PATH} _check_llvm_version)
   validate_tool("LLVM AR 17" ${CMAKE_AR} _check_llvm_version)
   validate_tool("LLVM Ranlib 17" ${CMAKE_RANLIB} _check_llvm_version)
endfunction()

################################################################################
# Apply patches to repository
# Parameters:
#  - SOURCE_DIR: The directory to apply the patch to
#  - PATCH_FILE: Path to the patch file
################################################################################

function(try_apply_patch)
   # Parse arguments
   set(oneValueArgs SOURCE_DIR PATCH_FILE)
   cmake_parse_arguments(PARSE_ARGV 0 ARG "" "${oneValueArgs}" "")

   # Check for required arguments and sanity
   if(NOT ARG_SOURCE_DIR)
      message(FATAL_ERROR "try_apply_patch: SOURCE_DIR argument is required")
   endif()
   if(NOT ARG_PATCH_FILE)
      message(FATAL_ERROR "try_apply_patch: PATCH_FILE argument is required")
   endif()
   if(NOT EXISTS "${ARG_SOURCE_DIR}")
      message(FATAL_ERROR "try_apply_patch: Source directory '${ARG_SOURCE_DIR}' does not exist")
   endif()
   if(NOT EXISTS "${ARG_PATCH_FILE}")
      message(FATAL_ERROR "try_apply_patch: Patch file '${ARG_PATCH_FILE}' does not exist")
   endif()

   # Create patch marker filename (based on patch file hash to ensure uniqueness)
   file(MD5 "${ARG_PATCH_FILE}" patch_hash)
   get_filename_component(patch_name "${ARG_PATCH_FILE}" NAME)
   set(patch_marker "${ARG_SOURCE_DIR}/.patch_${patch_name}_${patch_hash}")

   # Check if patch has already been applied
   if(EXISTS "${patch_marker}")
      message(STATUS "Patch '${patch_name}' already applied")
      return()
   endif()

   # Reset the git directory
   execute_process(
      COMMAND git reset --hard HEAD
      WORKING_DIRECTORY "${ARG_SOURCE_DIR}"
      RESULT_VARIABLE check_result
      ERROR_VARIABLE check_error
      OUTPUT_QUIET
   )
   if(NOT check_result EQUAL 0)
      message(FATAL_ERROR "Git reset failed: ${check_error}")
   endif()
   execute_process(
      COMMAND git clean -fdx
      WORKING_DIRECTORY "${ARG_SOURCE_DIR}"
      RESULT_VARIABLE check_result
      ERROR_VARIABLE check_error
      OUTPUT_QUIET
   )
   if(NOT check_result EQUAL 0)
      message(FATAL_ERROR "Git clean failed: ${check_error}")
   endif()

   # Apply the patch
   message(STATUS "Applying patch: ${patch_name}")
   execute_process(
      COMMAND git apply --check "${ARG_PATCH_FILE}"
      WORKING_DIRECTORY "${ARG_SOURCE_DIR}"
      RESULT_VARIABLE check_result
      ERROR_VARIABLE check_error
      OUTPUT_QUIET
   )
   # If patch check fails, we won't apply it
   if(NOT check_result EQUAL 0)
      message(FATAL_ERROR "Patch '${patch_name}' cannot be applied: ${check_error}")
   endif()

   # Actually apply the patch
   execute_process(
      COMMAND git apply "${ARG_PATCH_FILE}"
      WORKING_DIRECTORY "${ARG_SOURCE_DIR}"
      RESULT_VARIABLE patch_result
      ERROR_VARIABLE patch_error
      OUTPUT_VARIABLE patch_output
   )

   # Check for errors and warning
   if(NOT patch_result EQUAL 0)
      message(FATAL_ERROR "Failed to apply patch '${patch_name}': ${patch_error}")
   endif()
   if(patch_error)
      message(WARNING "Patch '${patch_name}' applied with warnings: ${patch_error}")
   endif()

   # Create marker file to indicate this patch has been applied
   file(WRITE "${patch_marker}" "Patch applied on: ${CMAKE_CURRENT_LIST_FILE}")
   message(STATUS "Successfully applied patch: ${patch_name}")
endfunction()

################################################################################
# Function to add a dependency from a tar.gz archive
# Parameters:
#   URL - URL to download the tar.gz file from
#   NAME - Name for the dependency
#   VERSION - Version of the dependency
#   OUTPUT_DIR - Variable name to store the resulting source directory
################################################################################

function(add_tar_gz_dependency)
   # Parse arguments
   set(options "")
   set(oneValueArgs URL NAME VERSION OUTPUT_DIR)
   set(multiValueArgs "")
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

   # Validate required arguments
   if(NOT DEFINED ARG_URL)
      message(FATAL_ERROR "URL parameter is required for add_tar_gz_dependency")
   endif()
   if(NOT DEFINED ARG_NAME)
      message(FATAL_ERROR "NAME parameter is required for add_tar_gz_dependency")
   endif()
   if(NOT DEFINED ARG_VERSION)
      message(FATAL_ERROR "VERSION parameter is required for add_tar_gz_dependency")
   endif()
   if(NOT DEFINED ARG_OUTPUT_DIR)
      message(FATAL_ERROR "OUTPUT_DIR parameter is required for add_tar_gz_dependency")
   endif()

   # Set up dependency variables
   set(DOWNLOAD_DIR "${CMAKE_CURRENT_BINARY_DIR}/_deps")
   set(SOURCE_DIR "${DOWNLOAD_DIR}/${ARG_NAME}-${ARG_VERSION}")
   set(TARBALL_PATH "${DOWNLOAD_DIR}/${ARG_NAME}-${ARG_VERSION}.tar.gz")

   # Check if the directory already exists
   if(NOT EXISTS ${SOURCE_DIR})
      # Create the download directory if it doesn't exist
      file(MAKE_DIRECTORY ${DOWNLOAD_DIR})

      # Download the tarball
      message(STATUS "Downloading ${ARG_NAME} ${ARG_VERSION}...")
      file(DOWNLOAD ${ARG_URL} ${TARBALL_PATH}
         STATUS DOWNLOAD_STATUS)

      list(GET DOWNLOAD_STATUS 0 STATUS_CODE)
      if(NOT STATUS_CODE EQUAL 0)
         list(GET DOWNLOAD_STATUS 1 ERROR_MESSAGE)
         message(FATAL_ERROR "Error downloading ${ARG_NAME}: ${ERROR_MESSAGE}")
      endif()

      # Extract the tarball
      message(STATUS "Extracting ${ARG_NAME} source...")
      execute_process(
         COMMAND ${CMAKE_COMMAND} -E tar xzf ${TARBALL_PATH}
         WORKING_DIRECTORY ${DOWNLOAD_DIR}
         RESULT_VARIABLE EXTRACT_RESULT OUTPUT_QUIET
      )

      if(NOT EXTRACT_RESULT EQUAL 0)
         # Apply patch if provided
         if(DEFINED ARG_PATCH_FILE)
            message(STATUS "Applying patch...")

         endif()
         message(FATAL_ERROR "Failed to extract ${ARG_NAME} source")
      endif()

      # Initialize git repository and commit
      message(STATUS "Initializing git repository...")
      execute_process(
         COMMAND git init -b main
         WORKING_DIRECTORY ${SOURCE_DIR}
         RESULT_VARIABLE GIT_INIT_RESULT OUTPUT_QUIET
      )

      if(NOT GIT_INIT_RESULT EQUAL 0)
         message(FATAL_ERROR "Failed to initialize git repository")
      endif()

      execute_process(
         COMMAND git add .
         WORKING_DIRECTORY ${SOURCE_DIR}
         RESULT_VARIABLE GIT_ADD_RESULT OUTPUT_QUIET
      )

      if(NOT GIT_ADD_RESULT EQUAL 0)
         message(FATAL_ERROR "Failed to add files to git")
      endif()

      execute_process(
         COMMAND git config --local user.email "john@doe.com"
         COMMAND git config --local user.name "John Doe"
         COMMAND git commit -m "Initial commit of ${ARG_NAME} ${ARG_VERSION} source"
         WORKING_DIRECTORY ${SOURCE_DIR}
         RESULT_VARIABLE GIT_COMMIT_RESULT OUTPUT_QUIET
      )

      if(NOT GIT_COMMIT_RESULT EQUAL 0)
         message(FATAL_ERROR "Failed to commit files to git")
      endif()
   else()
      message(STATUS "${ARG_NAME} source directory already exists at: ${SOURCE_DIR}")
   endif()

   # Set the output variable in the parent scope
   set(${ARG_OUTPUT_DIR} ${SOURCE_DIR} PARENT_SCOPE)
   message(STATUS "Using ${ARG_NAME} source directory: ${SOURCE_DIR}")
endfunction()