cmake_minimum_required(VERSION 3.24.0)

include(CheckFortranCompilerFlag)

# NOTE: flang does not currently (as of 2023/03/20) support the -w flag. If
# support for the flag is added, this should be removed.
remove_definitions(-w)

# This option is added because as of 2023/03/20, several tests in this
# directory have been disabled. Some of them exercise unsupported non-standard
# extensions, others trigger a "not yet implemented" assertion while some cause
# flang to crash. This option forces all the tests to build and can be used to
# determine if any of the disabled tests can be enabled.
option(TEST_SUITE_FORTRAN_FORCE_ALL_TESTS
  "Build and run all gfortran tests, including those in the 'unsupported', 'unimplemented', 'skipped', and 'failing' categories."
  OFF)

# Since the FORCE_ALL_TESTS option is a bit too blunt, there are some other
# options to force building some subsets of the disabled tests.

# The 'unsupported' tests exercise non-standard extensions that are not
# currently supported. But there is a chance some may be in the future, in which
# case, it may be worthwhile seeing if any can be removed from the list and
# enabled permanently.
option(TEST_SUITE_FORTRAN_FORCE_UNSUPPORTED_TESTS
  "Build and run all 'unsupported' gfortran tests. These usually test non-standard extensions."
  OFF)

# The 'unimplemented' tests trigger a "not yet implemented" assertion at
# compile-time. If those features are implemented, enabling those tests may help
# in identifying those that can be removed from the list and permanently enabled
# because the root cause has been addressed.
option(TEST_SUITE_FORTRAN_FORCE_UNIMPLEMENTED_TESTS
  "Build and run all 'unimplemented' gfortran tests. These are tests that fail at build-time because of unimplemented features in flang."
  OFF)

# The 'skipped' tests cause flang to crash at compile-time for "non-obvious"
# reasons. They could be related to unimplemented features, or they could be
# bugs in the compiler. In any case, enabling them may help identify those tests
# that can be removed from the list and permanently enabled because the root
# cause has been addressed.
option(TEST_SUITE_FORTRAN_FORCE_SKIPPED_TESTS
  "Build and run all 'skipped' gfortran tests. These are tests that cause flang to crash."
  OFF)

# The 'failing' tests fail to pass either because of a bug somewhere in the
# compiler or the runtime. Enabling these tests may help identify those tests
# that can be removed from the list and permanently enabled because the root
# cause has been addressed.
option(TEST_SUITE_FORTRAN_FORCE_FAILING_TESTS
  "Build and run all 'failing' tests. These tests failed at runtime, perhaps due to bugs in the code generator or bugs/unimplemented features in the runtime."
  OFF)

# The ISO_Fortran_binding.h file is required to run some of the tests. This
# header is copied to ${CMAKE_INSTALL_PREFIX}/include/flang at flang install
# time which can be found automatically. If the compiler being tested here is
# not installed, that file will not be found. In that case, the path to it must
# be provided explicitly.
set(TEST_SUITE_FORTRAN_ISO_C_HEADER_DIR "" CACHE STRING
  "Path to the directory containing ISO_Fortran_bindings.h header file.")

# The following cause errors if they are passed to flang via FFLAGS. This could
# be because they are currently unsupported and might eventually be supported
# or because they are GCC-specific and will never be supported.
#
# FIXME: The flags here necessarily include the value as well, not just the
# flag itself. For instance, in the list are -fcheck=all, -fcheck=bits etc. In
# principle, one only needs the -fcheck. The argument should not matter. The
# problem is that the annotation parser currently does not parse the flag into
# `flag-name` and `flag-value`. Once this is fixed, we need only have the
# flag name here.
set(FLANG_ERRORING_FFLAGS
  # The "flags" that do not start with a hyphen (-) are actually arguments to
  # some other flag but use the "-flag value" syntax (as opposed to the
  # "-flag=value" syntax). Since we don't actually parse the command line, they
  # are treated as if they were "flags" .
  analyzer-max-svalue-depth=0
  ggc-min-expand=0
  ggc-min-heapsize=0
  iv-max-considered-uses=2
  large-stack-frame=4000
  max-completely-peel-loop-nest-depth=1
  max-completely-peeled-insns=0
  max-completely-peeled-insns=200
  max-cse-insns=0
  max-inline-insns-auto=0
  max-inline-insns-single=0
  parloops-chunk-size=2
  parloops-min-per-thread=5
  sccvn-max-alias-queries-per-access=1
  vect-epilogues-nomask=0
  vect-max-peeling-for-alignment=0

  # This is an argument that should go with -idirafter which is not correctly
  # handled right now. Once that is fixed, this can be removed.
  fdaf
  "/fdaf/"

  -dA
  -dH
  -dirafter
  -dp
  -faggressive-function-elimination
  -fall-intrinsics
  -fallow-argument-mismatch
  -fallow-invalid-boz
  -fautomatic
  -fblas-matmul-limit=1
  -fbounds-check
  -fcheck-array-temporaries
  -fcheck=all
  -fcheck=bits
  -fcheck=bounds
  -fcheck=do
  -fcheck=mem
  -fcheck=pointer
  -fcheck=recursion
  -fcompare-debug
  -fcoarray=lib
  -fcoarray=single
  -fcray-pointer
  -fd-lines-as-code
  -fd-lines-as-comments
  -fdec
  -fdec-format-defaults
  -fdec-static
  -fdec-structure
  -fdollar-ok
  -frecord-marker=4
  -fbounds-check
  -fcheck-bounds
  -fcheck=all
  -fcheck=bits
  # Not sure if the -fdefault-* options will be supported. Maybe in a different
  # form in which case, this will have to be modified to accommodate those.
  -fdefault-real-10
  -fdefault-real-16
  -fdiagnostics-format=json
  -fdiagnostics-show-option
  -fdollar-ok
  -fdump-ipa-cp-details
  -fdump-ipa-fnsummary-details
  -fdump-ipa-inline-details
  -fdump-ipa-sra-details
  -fdump-rtl-combine
  -fdump-rtl-expand
  -fdump-tree-all
  -fdump-tree-cunroll-details
  -fdump-tree-cunrolli-details
  -fdump-tree-dom2
  -fdump-tree-dom2-details
  -fdump-tree-forwprop2
  -fdump-tree-fre1
  -fdump-tree-gimple
  -fdump-tree-ifcvt
  -fdump-tree-ldist-all
  -fdump-tree-ldist-details
  -fdump-tree-lim2
  -fdump-tree-lim2-details
  -fdump-tree-linterchange-details
  -fdump-tree-lversion-details
  -fdump-tree-omplower
  -fdump-tree-optimized
  -fdump-tree-optimized-raw
  -fdump-tree-original
  -fdump-tree-original-lineno
  -fdump-tree-parloops2-details
  -fdump-tree-pcom-details
  -fdump-tree-pre
  -fdump-tree-pre-details
  -fdump-tree-profile_estimate
  -fdump-tree-reassoc1
  -fdump-tree-slp-details
  -fdump-tree-slp2-details
  -fdump-tree-vect-details
  -fexceptions
  -fexpensive-optimizations
  -fexternal-blas
  -ff2c
  -ffixed-xmm1
  -ffixed-xmm10
  -ffixed-xmm11
  -ffixed-xmm12
  -ffixed-xmm13
  -ffixed-xmm14
  -ffixed-xmm15
  -ffixed-xmm2
  -ffixed-xmm3
  -ffixed-xmm4
  -ffixed-xmm5
  -ffixed-xmm6
  -ffixed-xmm7
  -ffixed-xmm8
  -ffixed-xmm9
  -ffloat-store
  -ffree-line-length-none
  -ffrontend-optimize
  -fgcse
  -fgcse-after-reload
  -fgnu-tm
  -findirect-inlining
  -finit-character=32
  -finit-derived
  -finit-local-zero
  -finit-integer=42
  -finit-integer=12345678
  -finit-logical=0
  -finit-logical=true
  -finit-real=inf
  -finline-functions
  -finline-matmul-limit=0
  -finline-matmul-limit=10
  -finline-matmul-limit=100
  -finline-matmul-limit=1000
  -finline-matmul-limit=2
  -finline-matmul-limit=30
  -finline-small-functions
  -finstrument-functions
  -fipa-cp
  -fipa-cp-clone
  -fipa-pta
  -fipa-reference
  -flinker-output=nolto-rel
  -floop-interchange
  -fmax-array-constructor=100000
  -fmax-stack-var-size=8
  -fmax-stack-var-size=100
  -fmodule-private
  -fmodulo-sched
  -fno-align-commons
  -fno-asynchronous-unwind-tables
  -fno-backtrace
  -fno-bounds-check
  -fno-check-array-temporaries
  -fno-code-hoisting
  -fno-dec
  -fno-dse
  -fno-early-inlining
  -fno-f2c
  -fno-frontend-loop-interchange
  -fno-frontend-optimize
  -fno-guess-branch-probability
  -fno-init-local-zero
  -fno-inline
  -fno-inline-arg-packing
  -fno-inline-functions-called-once
  -fno-ipa-cp
  -fno-ipa-icf
  -fno-ipa-modref
  -fno-ipa-sra
  -fno-move-loop-stores
  -fno-openacc
  -fno-openmp
  -fno-pad-source
  -fno-protect-parens
  -fno-range-check
  -fno-realloc-lhs
  -fno-schedule-insns
  -fno-sign-zero
  -fno-strict-aliasing
  -fno-trapping-math
  -fno-tree-ccp
  -fno-tree-ch
  -fno-tree-copy-prop
  -fno-tree-dce
  -fno-tree-dominator-opts
  -fno-tree-forwprop
  -fno-tree-fre
  -fno-tree-loop-ch
  -fno-tree-loop-distribute-patterns
  -fno-tree-loop-im
  -fno-tree-loop-ivcanon
  -fno-tree-loop-optimize
  -fno-tree-loop-vectorize
  -fno-tree-pre
  -fno-tree-scev-cprop
  -fno-tree-sink
  -fno-tree-slp-vectorize
  -fno-tree-vectorize
  -fno-tree-vrp
  -fnon-call-exceptions
  -fopenmp-simd
  -fopt-info-vec-optimized
  -fpad-source
  -fpeel-loops
  -fpre-include=simd-builtins-1.h
  -fpre-include=simd-builtins-3.h
  -fpre-include=simd-builtins-4.h
  -fpre-include=simd-builtins-7.h
  -fpre-include=simd-builtins-8.h
  -fpreprocessed
  -fpredictive-commoning
  -fprefetch-loop-arrays
  -fprofile-arcs
  -fprofile-generate
  -frecord-marker=4
  -frecursive
  -frepack-arrays
  -frounding-math
  -fsanitize=float-cast-overflow
  -fsanitize=null
  -fsanitize=signed-integer-overflow
  -fsanitize=undefined
  -fschedule-insns
  -fsecond-underscore
  -fsel-sched-pipelining
  -fsel-sched-pipelining-outer-loops
  -fselective-scheduling
  -fselective-scheduling2
  -fset-g77-defaults
  -fshort-enums
  -fstrict-aliasing
  -fsplit-loops
  -ftest-forall-temp
  -ftest-coverage
  -ftracer
  -ftrapv
  -ftree-loop-distribution
  -ftree-loop-if-convert
  -ftree-loop-vectorize
  -ftree-parallelize-loops
  -ftree-parallelize-loops=2
  -ftree-pre
  -ftree-slp-vectorize
  -ftree-tail-merge
  -ftree-vectorize
  -ftree-vrp
  -funconstrained-commons
  -funroll-all-loops
  -funroll-loops
  -funsafe-math-optimizations
  -fvect-cost-model=dynamic
  -fwhole-program
  -fwrapv
  -gno-strict-dwarf
  -idirafter
  -mavx
  -mavx2
  -mavx512f
  -mcmodel=medium
  -mdalign
  -mdejagnu-cpu=power4
  -mdejagnu-cpu=power7
  -mdejagnu-cpu=power10
  -mfpmath=387
  -mfpmath=sse
  -mlow-precision-sqrt
  -mno-avx
  -mno-power8-vector
  -mno-power9-vector
  -mprefer-avx128
  -msse
  -msse2
  -msse3
  -msse4.1
  -mtune=amdfam10
  -mtune=generic
  -mveclibabi=mass
  -mveclibabi=svml
  -mvsx
  -mvzeroupper
  -mzarch
  -nostdinc
  -nostdlib
  # -Os might eventually be supported, so this might also need to be removed
  # at some point
  -Og
  -Os
  -pedantic-errors
  # -pthread should be supported at some point.
  -pthread
  -r
  # At some point, if we ever support explicit standard flags, some of these
  # should be removed.
  -pedantic-errors
  -std=gnu
  -std=legacy
  -std=f95
  --std=f95
  -std=f2003
  -std=f2008
  -std=f2008ts
  # At the time of writing, -W warnings are not supported. flang errors out
  # saying that only -Werror is supported.
  -W
  -Waliasing
  -Wall
  -Wampersand
  -Wanalyzer-too-complex
  -Warray-bounds
  -Warray-temporaries
  -Wc-binding-type
  -Wcharacter-truncation
  -Wcompare-reals
  -Wconversion
  -Wconversion-extra
  -Wdate-time
  -Wdo-subscript
  -Werror
  -Wextra
  -Wfunction-elimination
  -Wimplicit-interface
  -Wimplicit-procedure
  -Winteger-division
  -Wintrinsic-shadow
  -Wintrinsics-std
  -Wline-truncation
  -Wmaybe-uninitialized
  -Wmissing-include-dirs
  -Wno-all
  -Wno-analyzer-malloc-leak
  -Wno-analyzer-memory-leak
  -Wno-analyzer-null-dereference
  -Wno-analyzer-possible-null-dereference
  -Wno-analyzer-too-complex
  -Wno-analyzer-use-of-uninitialized-value
  -Wno-c-binding-type
  -Wno-complain-wrong-lang
  -Wno-cpp
  -Wno-error
  -Wno-error=cpp
  -Wno-intrinsic-shadow
  -Wno-intrinsics-std
  -Wno-line-truncation
  -Wno-lto-type-mismatch
  -Wno-missing-include-dirs
  -Wno-overwrite-recursive
  -Wno-pedantic
  -Wno-tabs
  -Wno-underflow
  -Wno-uninitialized
  -Wno-unused-dummy-argument
  -Wno-zerotrip
  -Wopenacc-parallelism
  -Wpadded
  -Wrealloc-lhs
  -Wrealloc-lhs-all
  -Wreturn-type
  -Wstringop-overflow
  -Wsurprising
  -Wtabs
  -Wtarget-lifetime
  -Wundefined-do-loop
  -Wuninitialized
  -Wunused
  -Wunused-dummy-argument
  -Wunused-function
  -Wunused-label
  -Wunused-parameter
  -Wunused-variable
  -Wzerotrip
  -w
  --param
)

# Determine disabled tests for this directory and return them via the OUT
# parameter.
function(gfortran_populate_disabled_tests out)
  set(unsupported "")
  set(unimplemented "")
  set(skipped "")
  set(failing "")

  # This will provide the lists of unsupported, unimplemented, skipped and
  # failing files.
  include(${CMAKE_CURRENT_SOURCE_DIR}/DisabledFiles.cmake)

  list(APPEND unsupported ${UNSUPPORTED_FILES})
  list(APPEND unimplemented ${UNIMPLEMENTED_FILES})
  list(APPEND skipped ${SKIPPED_FILES})
  list(APPEND failing ${FAILING_FILES})

  # do the same for any requested feature extentions
  foreach(feature ${TEST_SUITE_FORTRAN_FEATURES})
    set(UNSUPPORTED_FILES "")
    set(UNIMPLEMENTED_FILES "")
    set(SKIPPED_FILES "")
    set(FAILING_FILES "")
    include(${CMAKE_CURRENT_SOURCE_DIR}/DisabledFiles${feature}.cmake)
    list(APPEND unsupported ${UNSUPPORTED_FILES})
    list(APPEND unimplemented ${UNIMPLEMENTED_FILES})
    list(APPEND skipped ${SKIPPED_FILES})
    list(APPEND failing ${FAILING_FILES})

    # enable any tests that now pass for this feature
    set(SUPPORTED_FILES "")
    set(IMPLEMENTED_FILES "")
    set(UNSKIPPED_FILES "")
    set(PASSING_FILES "")
    include(${CMAKE_CURRENT_SOURCE_DIR}/EnabledFiles${feature}.cmake)
    list(REMOVE_ITEM unsupported ${SUPPORTED_FILES})
    list(REMOVE_ITEM unimplemented ${IMPLEMENTED_FILES})
    list(REMOVE_ITEM skipped ${UNSKIPPED_FILES})
    list(REMOVE_ITEM failing ${PASSING_FILES})
  endforeach()

  set(disabled "")

  # There is still a chance that some of the unsupported tests may need to be
  # enabled, for instance if the non-standard extensions that they exercise are
  # supported due to user demand.
  if (NOT TEST_SUITE_FORTRAN_FORCE_ALL_TESTS AND
      NOT TEST_SUITE_FORTRAN_FORCE_UNSUPPORTED_TESTS)
    list(APPEND disabled ${unsupported})
  endif()

  # For the remaining tests, there is cause to build and run the skipped, failing
  # and unimplemented tests since some could be enabled once some feature is
  # implemented. Eventually, all the TEST_SUITE_FORTRAN_FORCE_* options (perhaps
  # with the exception of TEST_SUITE_FORTRAN_FORCE_UNSUPPORTED_TESTS) should
  # become redundant and removed.
  if (NOT TEST_SUITE_FORTRAN_FORCE_ALL_TESTS AND
      NOT TEST_SUITE_FORTRAN_FORCE_UNIMPLEMENTED_TESTS)
    list(APPEND disabled ${unimplemented})
  endif()

  if (NOT TEST_SUITE_FORTRAN_FORCE_ALL_TESTS AND
      NOT TEST_SUITE_FORTRAN_FORCE_SKIPPED_TESTS)
    list(APPEND disabled ${skipped})
  endif()

  if (NOT TEST_SUITE_FORTRAN_FORCE_ALL_TESTS AND
      NOT TEST_SUITE_FORTRAN_FORCE_FAILING_TESTS)
    list(APPEND disabled ${failing})
  endif()

  set(${out} ${disabled} PARENT_SCOPE)
endfunction()

# Check the test configuration to make sure that it is not out of date.
# USED_FORT is the list of Fortran files that are used in the tests. USED_OTHER
# is the list of non-Fortran files that are used. This is intended be a sanity
# check in case the test suite is updated without updating the static test
# configuration. In particular, we want to catch situations where failing to
# update the test configuration results in the new new tests being skipped
# silently.
function(gfortran_check_test_config used_fort used_other)
  list(SORT used_fort)
  list(REMOVE_DUPLICATES used_fort)

  list(SORT used_other)
  list(REMOVE_DUPLICATES used_other)

  # All the Fortran files in the current directory.
  file(GLOB files CONFIGURE_DEPENDS LIST_DIRECTORIES false
    *.f*
    *.F*
  )
  list(SORT files)

  set(msg_unused "File not used in any test configuration")
  set(msg_missing "File used in test configuration not found")
  set(msg_rerun "You may need to run utils/update-test-config.py")

  # Now that files and used_fort are both sorted and without any duplicates,
  # they should be identical. If they are not, it suggests that some Fortran
  # files have been added or removed.
  foreach (f u IN ZIP_LISTS files used_fort)
    if (NOT f STREQUAL u)
      list(FIND used ${f} idx)
      if (idx EQUAL -1)
        message(FATAL_ERROR "${msg_unused}\n  ${f}\n${msg_rerun}\n")
      else ()
        message(FATAL_ERROR "${msg_missing}\n  ${u}\n${msg_rerun}\n")
      endif ()
    endif ()
  endforeach ()

  # It is highly likely that any non-Fortran files will be dependents of tests.
  # They are most likely to be .c files, but we cannot guarantee that. Just
  # check if the files in the test configuration exist. If any dependent files
  # are added and they are missing from the test configuration, it will most
  # likely result in a build-time error, so it won't pass by silently.
  foreach (f ${used_other})
    if (NOT EXISTS ${f})
      message(FATAL_ERROR "${msg_missing}\n  ${f}\n${msg_rerun}\n")
    endif ()
  endforeach()
endfunction()

# Generate a unique target name from the given base and prepend it with the
# given prefix.
function(gfortran_unique_target_name prefix base out)
  # There are a few tests - in different directories - with duplicate filenames.
  # CMake requires all target names to be unique, so we add a disambiguator. The
  # disambiguator uses the path of the file relative to the top-level directory
  # containing all the tests from the gfortran test suite to ensure that
  # targets in different directories will have distinct names.
  set(result "")

  # The ${base} argument is guaranteed to be the absolute path to a source file.
  string(REPLACE "${PROJECT_SOURCE_DIR}/Fortran/gfortran/" "" result "${base}")

  # Replace any '/' separators with 2 underscores. Just replacing it by a single
  # underscore results in conflicts. For instance, there is a conflict between
  # regression/coarray_ptr_comp_2.f08 and regression/coarray/ptr_comp_2.f08
  # which are unrelated tests. Other such conflicts are probably also unrelated.
  string(REPLACE "/" "__" result "${result}")

  # Retain the extension of the source file in the final target name because
  # there are cases where two source files with the same basename but different
  # extensions and they, too, represent completely different and unrelated
  # tests.
  string(REPLACE "." "_" result "${result}")

  set(${out} "${prefix}-${result}" PARENT_SCOPE)
endfunction()

# Several tests in the suite build modules with the same name at build-time.
# Others create/write/read files with the same name at test-time. In either
# case, these are race conditions which can lead to non-deterministic failures
# at build and/or test time. To work around this, have each test run in its
# own directory.
#
# This directory is also used as module directory at build-time.
#
# It may be "cleaner" to have separate directories - one that serves as the
# module directory and the other as the working directory, but that is
# probably unnecessary.
#
# Make a working directory for the given target and return the full path of
# the resulting directory.
function(gfortran_make_working_dir tgt out)
  set(working_dir "${CMAKE_CURRENT_BINARY_DIR}/${tgt}.wd")

  file(MAKE_DIRECTORY ${working_dir})

  set("${out}" "${working_dir}" PARENT_SCOPE)
endfunction()

# Setup a "compile" test. EXPECT_ERROR will be ON if the compile test is
# expected to fail, OFF otherwise. MAIN is the main test file. In the case of
# multi-file tests, OTHERS will be the remaining files needed by the test.
# FFLAGS are compiler flags needed by the test. LDFLAGS are linker flags needed
# by the test.
function(gfortran_add_compile_test expect_error main others fflags ldflags)
  # The test-suite expects an executable to be produced at build time and for
  # that executable to be run at test time. The result (in the form of the
  # return code or the output written to stdout/stderr) is used to determine
  # whether the test has succeeded. The "compile" tests are intended to exercise
  # the behavior of the compiler itself. There isn't a clean way of having the
  # compiler be executed at test time. Instead, the compiler is run at
  # build time and the diagnostics/errors saved to a file as needed. This file is
  # compared to a reference output at test time to determine success/failure of
  # the test. A dummy executable is also built. This does nothing, but provides
  # something that the test suite can "run" at test time.

  # PREFIX_COMPILE will have been defined in the subdirectory from which this
  # function is called.
  gfortran_unique_target_name("${PREFIX_COMPILE}" "${main}" target)
  gfortran_make_working_dir("${target}" working_dir)

  # The output of the compilation of the test file. This may contain warnings
  # and error messages. If the compilation succeeded without any warnings or
  # other diagnostics, it will be empty.
  set(out ${target}.out)

  # Add the CMake-wide environment variable CMAKE_Fortran_FLAGS
  # CMake escapes spaces. To really get a space (between arguments) use a ;
  string(REPLACE " " ";" fflags "${fflags};${CMAKE_Fortran_FLAGS}")

  add_custom_command(
    OUTPUT ${out}
    COMMAND ${CMAKE_COMMAND}
    -DCMD="${CMAKE_Fortran_COMPILER_LAUNCHER};${CMAKE_Fortran_COMPILER};-c;${fflags};${ldflags};${others};${main}"
    -DALWAYS_SAVE_DIAGS=OFF
    -DWORKING_DIRECTORY=${working_dir}
    -DOUTPUT_FILE=${out}
    -P ${COMPILE_SCRIPT_BIN}
    USES_TERMINAL
    COMMENT "Compiling ${main}")

  add_custom_target(${target}
    ALL
    DEPENDS ${out}
    SOURCES ${main} ${others})

  # The dummy and empty reference output files are in
  # ${CMAKE_BINARY_DIR}/Fortran/gfortran. This function could be called from
  # any of the subdirectories under ${CMAKE_BINARY_DIR}/Fortran/gfortran. The
  # tests need paths relative to the directory containing the test, so calculate
  # the relative path back to ${CMAKE_BINARY_DIR}/Fortran/gfortran.
  file(RELATIVE_PATH relpath
    ${CMAKE_CURRENT_BINARY_DIR}
    ${CMAKE_BINARY_DIR}/Fortran/gfortran)

  # The test suite expects an executable to run, so give it the dummy (see
  # comments above).
  llvm_test_run(EXECUTABLE %S/${relpath}/${DUMMY_EXE})

  # The verification compares the saved diagnostics file against what is
  # expected. For the test. The reference output may have been extracted from
  # the DejaGNU annotations in the test file, or it may be an empty file if the
  # compilation of the test file was expected to be successful and without any
  # diagnostics.
  if (expect_error)
    # Since we don't check for any particular error, we expect "some" error.
    # In that case, the compiler's diagnostic output will be non-empty.
    llvm_test_verify(%b/not ${DIFFPROG} %S/${relpath}/${EMPTY_FILE} %S/${out})
  else ()
    llvm_test_verify(${DIFFPROG} %S/${relpath}/${EMPTY_FILE} %S/${out})
  endif ()

  llvm_add_test(${target}.test %S/${relpath}/${DUMMY_EXE})
endfunction()

# Setup an "execute" test. In the case of multi-file tests, MAIN will be the
# main file. For multi-file tests, OTHERS will be the remaining files needed by
# the test. FFLAGS are additional compiler flags needed by the test. LDFLAGS
# are the other linker flags needed by the test. If EXPECT_ERROR evaluates to
# true, the test is expected to fail.
function(gfortran_add_execute_test expect_error main others fflags ldflags)
  # PREFIX_EXECUTE will have been defined in the subdirectory from which this
  # function is called.
  gfortran_unique_target_name("${PREFIX_EXECUTE}" "${main}" target)
  gfortran_make_working_dir("${target}" working_dir)
  get_filename_component(working_dir_name "${working_dir}" NAME)

  llvm_test_executable_no_test(${target} ${main} ${others})
  if (expect_error)
    llvm_test_run(
      EXECUTABLE "%b/not --crash %S/${target}"
      WORKDIR "%S/${working_dir_name}")
  else ()
    llvm_test_run(WORKDIR "%S/${working_dir_name}")
  endif ()
  llvm_add_test_for_target(${target})

  target_include_directories(${target}
    PRIVATE ${ISO_FORTRAN_C_HEADER_DIR} ${working_dir})
  target_compile_options(${target} PRIVATE "${fflags}")
  target_link_options(${target} PRIVATE "${ldflags}")
  set_target_properties(${target} PROPERTIES
    Fortran_MODULE_DIRECTORY ${working_dir})

  # This is a workaround because cmake does not currently recognize the .f03
  # and .f08 extensions. A patch to fix cmake has been accepted and the fix
  # should be available in CMake 3.27. It might be better to check the CMake
  # version and do this conditionally.
  list(APPEND sources ${main})
  list(APPEND sources ${others})
  foreach(source ${sources})
    get_filename_component(ext ${source} LAST_EXT)
    if("${ext}" STREQUAL ".f03" OR
        "${ext}" STREQUAL ".F03" OR
        "${ext}" STREQUAL ".f08" OR
        "${ext}" STREQUAL ".F08")
      set_source_files_properties(${source} PROPERTIES LANGUAGE Fortran)
    endif()
  endforeach()

  set_target_properties(${target} PROPERTIES LINKER_LANGUAGE Fortran)
endfunction()

# The main entry point to populate the tests in the current source directory.
# This parses the static test configuration file, filters out the disabled
# tests, sets up the tests and performs some sanity checks. The keyword FFLAGS
# and LDFLAGS arguments can be used to force specific compile-time and link-time
# flags to be used when building the tests.
function(gfortran_populate_tests)
  cmake_parse_arguments(GFORTRAN "" "" "FFLAGS;LDFLAGS" ${ARGN})

  # These are used to collect the list of source files that are used in at
  # least one test. This is used as a sanity check to ensure that all the
  # source files are accounted for. This is necessary to alert the user in case
  # the tests were updated by upstream gfortran but the static test
  # configuration was not re-generated.
  set(used_fort)
  set(used_other)

  string(REPLACE "${CMAKE_SOURCE_DIR}/" "" pwd "${CMAKE_CURRENT_SOURCE_DIR}")
  message(STATUS "Adding directory ${pwd}")

  # The target triple is roughly of the form ${arch}-${vendor}-${sys}. Cmake
  # has no concept of a vendor, so we set it to "unknown". The targets
  # specification in the tests generally ignores the vendor and only matches
  # against either the architecture or the system, so this is ok.
  string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" arch)
  string(TOLOWER "${CMAKE_SYSTEM_NAME}" sys)
  set(triple "${arch}-unknown-${sys}")

  set(disabled)
  gfortran_populate_disabled_tests(disabled)

  file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/tests.cmake lines)
  foreach (line ${lines})
    # Skip comment lines where the first non-whitespace character is a #.
    if (line MATCHES "^[ ]*#")
      continue()
    endif()

    list(GET line 1 sources_t)
    string(REPLACE " " ";" sources "${sources_t}")
    list(TRANSFORM sources PREPEND ${CMAKE_CURRENT_SOURCE_DIR}/)

    # The tests in the configuration must be added to the used list even if the
    # test is disabled because the sanity check will expect that the list of
    # Fortran files in the directory exactly matches the list of used Fortran
    # files.
    set(rest)
    list(LENGTH sources nsources)
    math(EXPR iend "${nsources} - 1")
    foreach (i RANGE ${iend})
      list(GET sources ${i} source)
      if (source MATCHES "^.+[.][Ff].*$")
        list(APPEND used_fort ${source})
      else ()
        list(APPEND used_other ${source})
      endif ()
      if (${i} GREATER 0)
        list(APPEND rest ${source})
      endif ()
    endforeach()

    # If the test is only allowed to run on certain targets, process those.
    list(GET line 4 incl_t)
    if (incl_t)
      # If there are any explicit include targets, then we should assume that
      # we cannot run the test on the current platform unless there is at
      # least one match.
      set(exclude ON)
      string(REPLACE " " ";" includes ${incl_t})
      foreach (incl ${includes})
        string(REGEX MATCH ${incl} m ${triple})
        if (m)
          set(exclude OFF)
        endif ()
      endforeach()

      # The current platform was not matched, so we should not run the test.
      if (exclude)
        continue()
      endif ()
    endif ()

    # If the test is explicitly disabled on certain targets, process those.
    list(GET line 5 excl_t)
    if (excl_t)
      # If there are any targets to explicitly exclude, then we should assume
      # that we can run the test on this platform unless there is at least
      # one match.
      set(exclude OFF)
      string(REPLACE " " ";" excludes ${excl_t})
      foreach (excl ${excludes})
        string(REGEX MATCH ${excl} m ${triple})
        if (m)
          set(exclude ON)
        endif ()
      endforeach ()

      # The current platform was matched, so we should not run the test.
      if (exclude)
        continue ()
      endif()
    endif ()

    # Only the main file will be in the list of disabled tests. If it is, move
    # on to the next test in the configuration.
    list(GET sources 0 main)
    list(FIND disabled ${main} i)
    if (NOT i EQUAL -1)
      continue ()
    endif()

    # The test was not excluded and not disabled. Now we can process the other
    # parameters and set up the test.
    set(xfail OFF)
    list(GET line 2 xfail_t)
    if (xfail_t STREQUAL "xfail")
      set(xfail ON)
    endif ()

    set(fflags)
    list(GET line 3 options_t)
    string(REPLACE " " ";" file_fflags "${options_t}")
    list(REMOVE_ITEM file_fflags ${FLANG_ERRORING_FFLAGS})
    list(APPEND fflags ${GFORTRAN_FFLAGS})
    list(APPEND fflags ${file_fflags})

    set(ldflags)
    list(APPEND ldflags ${GFORTRAN_LDFLAGS})

    list(GET line 0 kind)
    if (kind STREQUAL "run")
      gfortran_add_execute_test(${xfail} ${main} "${rest}" "${fflags}" "${ldflags}")
    else()
      # FIXME: For now, we treat all non-execute tests as compile tests, but we
      # probably should do something more sensible for the "preprocess",
      # "assemble", and "link" tests.
      gfortran_add_compile_test(${xfail} ${main} "${rest}" "${fflags}" "${ldflags}")
    endif()
  endforeach()

  # It would be nice to do the sanity check early, but that would complicate
  # this code since cmake is not the nicest programming language.
  gfortran_check_test_config("${used_fort}" "${used_other}")
endfunction()

set(HEADER_SEARCH_PATH "${TEST_SUITE_FORTRAN_ISO_C_HEADER_DIR}")
if (NOT HEADER_SEARCH_PATH)
  get_filename_component(Fortran_BINDIR ${CMAKE_Fortran_COMPILER} DIRECTORY)
  get_filename_component(Fortran_PREFIX ${Fortran_BINDIR} DIRECTORY)

  set(HEADER_SEARCH_PATH "${Fortran_PREFIX}/include/flang")
endif()

find_file(ISO_FORTRAN_C_HEADER
  ISO_Fortran_binding.h
  PATHS ${HEADER_SEARCH_PATH}
  REQUIRED)

get_filename_component(ISO_FORTRAN_C_HEADER_DIR
  "${ISO_FORTRAN_C_HEADER}"
  DIRECTORY)

# The program to be used to verify the results. The programs here should take
# two files as arguments, return 0 if the files are identical, non-zero
# otherwise.
set(DIFFPROG)
if (WIN32)
  find_program(DIFFPROG
    NAMES fc.exe
    REQUIRED)
else ()
  find_program(DIFFPROG
    NAMES diff cmp
    REQUIRED)
endif ()

# The test suite expects to be able to run something at test-time. For the
# compile tests, there is nothing to be run. While a better solution will be
# to modify the test suite to allow for cases like this, for the moment, just
# create an empty executable that will be run for each test.
set(DUMMY_SRC ${CMAKE_CURRENT_BINARY_DIR}/dummy.f90)
file(WRITE ${DUMMY_SRC} "program test\nend program test")

set(DUMMY_EXE "dummy")
add_executable(${DUMMY_EXE} ${DUMMY_SRC})

# This script compiles the files that are "compile" tests. It may save the
# diagnostics to file as needed (see the options that the script accepts). There
# should be no dependence on the source files at test-time, so copy the compile
# script over to the build directory. For the moment, nothing is compiled at
# test-time, but that might change.
set(COMPILE_SCRIPT compile-save-diags.cmake)
set(COMPILE_SCRIPT_SRC ${CMAKE_CURRENT_SOURCE_DIR}/${COMPILE_SCRIPT})
set(COMPILE_SCRIPT_BIN ${CMAKE_CURRENT_BINARY_DIR}/${COMPILE_SCRIPT})

file(COPY
  ${CMAKE_CURRENT_SOURCE_DIR}/${COMPILE_SCRIPT}
  DESTINATION ${CMAKE_CURRENT_BINARY_DIR})

# In some case, the "compile" tests are expected to pass. Since diagnostics are
# only saved on failure, the diagnostics file produced when compiling the test
# should be empty. An empty file can, therefore, be used as reference output.
set(EMPTY_FILE "gfortran-compile-empty.reference.out")
file(TOUCH ${CMAKE_CURRENT_BINARY_DIR}/${EMPTY_FILE})

add_subdirectory(regression)
add_subdirectory(torture)