1include(CMakePushCheckState)
2include(CheckSymbolExists)
3
4# Because compiler-rt spends a lot of time setting up custom compile flags,
5# define a handy helper function for it. The compile flags setting in CMake
6# has serious issues that make its syntax challenging at best.
7function(set_target_compile_flags target)
8  set(argstring "")
9  foreach(arg ${ARGN})
10    set(argstring "${argstring} ${arg}")
11  endforeach()
12  set_property(TARGET ${target} PROPERTY COMPILE_FLAGS "${argstring}")
13endfunction()
14
15function(set_target_link_flags target)
16  set(argstring "")
17  foreach(arg ${ARGN})
18    set(argstring "${argstring} ${arg}")
19  endforeach()
20  set_property(TARGET ${target} PROPERTY LINK_FLAGS "${argstring}")
21endfunction()
22
23# Set the variable var_PYBOOL to True if var holds a true-ish string,
24# otherwise set it to False.
25macro(pythonize_bool var)
26  if (${var})
27    set(${var}_PYBOOL True)
28  else()
29    set(${var}_PYBOOL False)
30  endif()
31endmacro()
32
33# Appends value to all lists in ARGN, if the condition is true.
34macro(append_list_if condition value)
35  if(${condition})
36    foreach(list ${ARGN})
37      list(APPEND ${list} ${value})
38    endforeach()
39  endif()
40endmacro()
41
42# Appends value to all strings in ARGN, if the condition is true.
43macro(append_string_if condition value)
44  if(${condition})
45    foreach(str ${ARGN})
46      set(${str} "${${str}} ${value}")
47    endforeach()
48  endif()
49endmacro()
50
51macro(append_rtti_flag polarity list)
52  if(${polarity})
53    append_list_if(COMPILER_RT_HAS_FRTTI_FLAG -frtti ${list})
54    append_list_if(COMPILER_RT_HAS_GR_FLAG /GR ${list})
55  else()
56    append_list_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti ${list})
57    append_list_if(COMPILER_RT_HAS_GR_FLAG /GR- ${list})
58  endif()
59endmacro()
60
61macro(append_have_file_definition filename varname list)
62  check_include_file("${filename}" "${varname}")
63  if (NOT ${varname})
64    set("${varname}" 0)
65  endif()
66  list(APPEND ${list} "${varname}=${${varname}}")
67endmacro()
68
69macro(list_intersect output input1 input2)
70  set(${output})
71  foreach(it ${${input1}})
72    list(FIND ${input2} ${it} index)
73    if( NOT (index EQUAL -1))
74      list(APPEND ${output} ${it})
75    endif()
76  endforeach()
77endmacro()
78
79function(list_replace input_list old new)
80  set(replaced_list)
81  foreach(item ${${input_list}})
82    if(${item} STREQUAL ${old})
83      list(APPEND replaced_list ${new})
84    else()
85      list(APPEND replaced_list ${item})
86    endif()
87  endforeach()
88  set(${input_list} "${replaced_list}" PARENT_SCOPE)
89endfunction()
90
91# Takes ${ARGN} and puts only supported architectures in @out_var list.
92function(filter_available_targets out_var)
93  set(archs ${${out_var}})
94  foreach(arch ${ARGN})
95    list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
96    if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
97      list(APPEND archs ${arch})
98    endif()
99  endforeach()
100  set(${out_var} ${archs} PARENT_SCOPE)
101endfunction()
102
103function(check_compile_definition def argstring out_var)
104  if("${def}" STREQUAL "")
105    set(${out_var} TRUE PARENT_SCOPE)
106    return()
107  endif()
108  cmake_push_check_state()
109  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}")
110  check_symbol_exists(${def} "" ${out_var})
111  cmake_pop_check_state()
112endfunction()
113
114# test_target_arch(<arch> <def> <target flags...>)
115# Checks if architecture is supported: runs host compiler with provided
116# flags to verify that:
117#   1) <def> is defined (if non-empty)
118#   2) simple file can be successfully built.
119# If successful, saves target flags for this architecture.
120macro(test_target_arch arch def)
121  set(TARGET_${arch}_CFLAGS ${ARGN})
122  set(TARGET_${arch}_LINKFLAGS ${ARGN})
123  set(argstring "")
124  foreach(arg ${ARGN})
125    set(argstring "${argstring} ${arg}")
126  endforeach()
127  check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF)
128  if(NOT DEFINED CAN_TARGET_${arch})
129    if(NOT HAS_${arch}_DEF)
130      set(CAN_TARGET_${arch} FALSE)
131    elseif(TEST_COMPILE_ONLY)
132      try_compile_only(CAN_TARGET_${arch} ${TARGET_${arch}_CFLAGS})
133    else()
134      set(argstring "${CMAKE_EXE_LINKER_FLAGS} ${argstring}")
135      set(FLAG_NO_EXCEPTIONS "")
136      if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
137        set(FLAG_NO_EXCEPTIONS " -fno-exceptions ")
138      endif()
139      try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}
140                  COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS} ${FLAG_NO_EXCEPTIONS}"
141                  OUTPUT_VARIABLE TARGET_${arch}_OUTPUT
142                  CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${argstring}")
143    endif()
144  endif()
145  if(${CAN_TARGET_${arch}})
146    list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
147  elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" STREQUAL "${arch}" AND
148         COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE)
149    # Bail out if we cannot target the architecture we plan to test.
150    message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}")
151  endif()
152endmacro()
153
154macro(detect_target_arch)
155  check_symbol_exists(__arm__ "" __ARM)
156  check_symbol_exists(__aarch64__ "" __AARCH64)
157  check_symbol_exists(__x86_64__ "" __X86_64)
158  check_symbol_exists(__i686__ "" __I686)
159  check_symbol_exists(__i386__ "" __I386)
160  check_symbol_exists(__mips__ "" __MIPS)
161  check_symbol_exists(__mips64__ "" __MIPS64)
162  check_symbol_exists(__s390x__ "" __S390X)
163  check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32)
164  check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64)
165  if(__ARM)
166    add_default_target_arch(arm)
167  elseif(__AARCH64)
168    add_default_target_arch(aarch64)
169  elseif(__X86_64)
170    add_default_target_arch(x86_64)
171  elseif(__I686)
172    add_default_target_arch(i686)
173  elseif(__I386)
174    add_default_target_arch(i386)
175  elseif(__MIPS64) # must be checked before __MIPS
176    add_default_target_arch(mips64)
177  elseif(__MIPS)
178    add_default_target_arch(mips)
179  elseif(__S390X)
180    add_default_target_arch(s390x)
181  elseif(__WEBASSEMBLY32)
182    add_default_target_arch(wasm32)
183  elseif(__WEBASSEMBLY64)
184    add_default_target_arch(wasm64)
185  endif()
186endmacro()
187
188macro(load_llvm_config)
189  if (NOT LLVM_CONFIG_PATH)
190    find_program(LLVM_CONFIG_PATH "llvm-config"
191                 DOC "Path to llvm-config binary")
192    if (NOT LLVM_CONFIG_PATH)
193      message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH")
194    endif()
195  endif()
196  execute_process(
197    COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root"
198    RESULT_VARIABLE HAD_ERROR
199    OUTPUT_VARIABLE CONFIG_OUTPUT)
200  if (HAD_ERROR)
201    message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
202  endif()
203  string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT})
204  list(GET CONFIG_OUTPUT 0 BINARY_DIR)
205  list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR)
206  list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)
207  list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR)
208
209  set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree")
210  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
211  set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")
212  set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
213
214  # Make use of LLVM CMake modules.
215  file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE)
216  set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
217  list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
218  # Get some LLVM variables from LLVMConfig.
219  include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
220
221  set(LLVM_LIBRARY_OUTPUT_INTDIR
222    ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
223endmacro()
224
225macro(construct_compiler_rt_default_triple)
226  set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING
227      "Default triple for which compiler-rt runtimes will be built.")
228  if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE)
229    # Backwards compatibility: this variable used to be called
230    # COMPILER_RT_TEST_TARGET_TRIPLE.
231    set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE})
232  endif()
233
234  string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE})
235  list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH)
236  list(GET TARGET_TRIPLE_LIST 1 COMPILER_RT_DEFAULT_TARGET_OS)
237  list(GET TARGET_TRIPLE_LIST 2 COMPILER_RT_DEFAULT_TARGET_ABI)
238  # Determine if test target triple is specified explicitly, and doesn't match the
239  # default.
240  if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE)
241    set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE)
242  else()
243    set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE)
244  endif()
245endmacro()
246