[X86] Cleanup ADCX/ADOX instruction definitions.
[lldb.git] / llvm / cmake / platforms / WinMsvc.cmake
1 # Cross toolchain configuration for using clang-cl on non-Windows hosts to
2 # target MSVC.
3 #
4 # Usage:
5 # cmake -G Ninja
6 #    -DCMAKE_TOOLCHAIN_FILE=/path/to/this/file
7 #    -DHOST_ARCH=[aarch64|arm64|armv7|arm|i686|x86|x86_64|x64]
8 #    -DLLVM_NATIVE_TOOLCHAIN=/path/to/llvm/installation
9 #    -DMSVC_BASE=/path/to/MSVC/system/libraries/and/includes
10 #    -DWINSDK_BASE=/path/to/windows-sdk
11 #    -DWINSDK_VER=windows sdk version folder name
12 #
13 # HOST_ARCH:
14 #    The architecture to build for.
15 #
16 # LLVM_NATIVE_TOOLCHAIN:
17 #   *Absolute path* to a folder containing the toolchain which will be used to
18 #   build.  At a minimum, this folder should have a bin directory with a
19 #   copy of clang-cl, clang, clang++, and lld-link, as well as a lib directory
20 #   containing clang's system resource directory.
21 #
22 # MSVC_BASE:
23 #   *Absolute path* to the folder containing MSVC headers and system libraries.
24 #   The layout of the folder matches that which is intalled by MSVC 2017 on
25 #   Windows, and should look like this:
26 #
27 # ${MSVC_BASE}
28 #   include
29 #     vector
30 #     stdint.h
31 #     etc...
32 #   lib
33 #     x64
34 #       libcmt.lib
35 #       msvcrt.lib
36 #       etc...
37 #     x86
38 #       libcmt.lib
39 #       msvcrt.lib
40 #       etc...
41 #
42 # For versions of MSVC < 2017, or where you have a hermetic toolchain in a
43 # custom format, you must use symlinks or restructure it to look like the above.
44 #
45 # WINSDK_BASE:
46 #   Together with WINSDK_VER, determines the location of Windows SDK headers
47 #   and libraries.
48 #
49 # WINSDK_VER:
50 #   Together with WINSDK_BASE, determines the locations of Windows SDK headers
51 #   and libraries.
52 #
53 # WINSDK_BASE and WINSDK_VER work together to define a folder layout that matches
54 # that of the Windows SDK installation on a standard Windows machine.  It should
55 # match the layout described below.
56 #
57 # Note that if you install Windows SDK to a windows machine and simply copy the
58 # files, it will already be in the correct layout.
59 #
60 # ${WINSDK_BASE}
61 #   Include
62 #     ${WINSDK_VER}
63 #       shared
64 #       ucrt
65 #       um
66 #         windows.h
67 #         etc...
68 #   Lib
69 #     ${WINSDK_VER}
70 #       ucrt
71 #         x64
72 #         x86
73 #           ucrt.lib
74 #           etc...
75 #       um
76 #         x64
77 #         x86
78 #           kernel32.lib
79 #           etc
80 #
81 # IMPORTANT: In order for this to work, you will need a valid copy of the Windows
82 # SDK and C++ STL headers and libraries on your host.  Additionally, since the
83 # Windows libraries and headers are not case-correct, this toolchain file sets
84 # up a VFS overlay for the SDK headers and case-correcting symlinks for the
85 # libraries when running on a case-sensitive filesystem.
86
87
88 # When configuring CMake with a toolchain file against a top-level CMakeLists.txt,
89 # it will actually run CMake many times, once for each small test program used to
90 # determine what features a compiler supports.  Unfortunately, none of these
91 # invocations share a CMakeCache.txt with the top-level invocation, meaning they
92 # won't see the value of any arguments the user passed via -D.  Since these are
93 # necessary to properly configure MSVC in both the top-level configuration as well as
94 # all feature-test invocations, we set environment variables with the values so that
95 # these environments get inherited by child invocations.
96 function(init_user_prop prop)
97   if(${prop})
98     set(ENV{_${prop}} "${${prop}}")
99   else()
100     set(${prop} "$ENV{_${prop}}" PARENT_SCOPE)
101   endif()
102 endfunction()
103
104 function(generate_winsdk_vfs_overlay winsdk_include_dir output_path)
105   set(include_dirs)
106   file(GLOB_RECURSE entries LIST_DIRECTORIES true "${winsdk_include_dir}/*")
107   foreach(entry ${entries})
108     if(IS_DIRECTORY "${entry}")
109       list(APPEND include_dirs "${entry}")
110     endif()
111   endforeach()
112
113   file(WRITE "${output_path}"  "version: 0\n")
114   file(APPEND "${output_path}" "case-sensitive: false\n")
115   file(APPEND "${output_path}" "roots:\n")
116
117   foreach(dir ${include_dirs})
118     file(GLOB headers RELATIVE "${dir}" "${dir}/*.h")
119     if(NOT headers)
120       continue()
121     endif()
122
123     file(APPEND "${output_path}" "  - name: \"${dir}\"\n")
124     file(APPEND "${output_path}" "    type: directory\n")
125     file(APPEND "${output_path}" "    contents:\n")
126
127     foreach(header ${headers})
128       file(APPEND "${output_path}" "      - name: \"${header}\"\n")
129       file(APPEND "${output_path}" "        type: file\n")
130       file(APPEND "${output_path}" "        external-contents: \"${dir}/${header}\"\n")
131     endforeach()
132   endforeach()
133 endfunction()
134
135 function(generate_winsdk_lib_symlinks winsdk_um_lib_dir output_dir)
136   execute_process(COMMAND "${CMAKE_COMMAND}" -E make_directory "${output_dir}")
137   file(GLOB libraries RELATIVE "${winsdk_um_lib_dir}" "${winsdk_um_lib_dir}/*")
138   foreach(library ${libraries})
139     string(TOLOWER "${library}" symlink_name)
140     execute_process(COMMAND "${CMAKE_COMMAND}"
141                             -E create_symlink
142                             "${winsdk_um_lib_dir}/${library}"
143                             "${output_dir}/${symlink_name}")
144   endforeach()
145 endfunction()
146
147 set(CMAKE_SYSTEM_NAME Windows)
148 set(CMAKE_SYSTEM_VERSION 10.0)
149 set(CMAKE_SYSTEM_PROCESSOR AMD64)
150
151 init_user_prop(HOST_ARCH)
152 init_user_prop(LLVM_NATIVE_TOOLCHAIN)
153 init_user_prop(MSVC_BASE)
154 init_user_prop(WINSDK_BASE)
155 init_user_prop(WINSDK_VER)
156
157 if(NOT HOST_ARCH)
158   set(HOST_ARCH x86_64)
159 endif()
160 if(HOST_ARCH STREQUAL "aarch64" OR HOST_ARCH STREQUAL "arm64")
161   set(TRIPLE_ARCH "aarch64")
162   set(WINSDK_ARCH "arm64")
163 elseif(HOST_ARCH STREQUAL "armv7" OR HOST_ARCH STREQUAL "arm")
164   set(TRIPLE_ARCH "armv7")
165   set(WINSDK_ARCH "arm")
166 elseif(HOST_ARCH STREQUAL "i686" OR HOST_ARCH STREQUAL "x86")
167   set(TRIPLE_ARCH "i686")
168   set(WINSDK_ARCH "x86")
169 elseif(HOST_ARCH STREQUAL "x86_64" OR HOST_ARCH STREQUAL "x64")
170   set(TRIPLE_ARCH "x86_64")
171   set(WINSDK_ARCH "x64")
172 else()
173   message(SEND_ERROR "Unknown host architecture ${HOST_ARCH}. Must be aarch64 (or arm64), armv7 (or arm), i686 (or x86), or x86_64 (or x64).")
174 endif()
175
176 set(MSVC_INCLUDE "${MSVC_BASE}/include")
177 set(MSVC_LIB "${MSVC_BASE}/lib")
178 set(WINSDK_INCLUDE "${WINSDK_BASE}/Include/${WINSDK_VER}")
179 set(WINSDK_LIB "${WINSDK_BASE}/Lib/${WINSDK_VER}")
180
181 # Do some sanity checking to make sure we can find a native toolchain and
182 # that the Windows SDK / MSVC STL directories look kosher.
183 if(NOT EXISTS "${LLVM_NATIVE_TOOLCHAIN}/bin/clang-cl" OR
184    NOT EXISTS "${LLVM_NATIVE_TOOLCHAIN}/bin/lld-link")
185   message(SEND_ERROR
186           "LLVM_NATIVE_TOOLCHAIN folder '${LLVM_NATIVE_TOOLCHAIN}' does not "
187           "point to a valid directory containing bin/clang-cl and bin/lld-link "
188           "binaries")
189 endif()
190
191 if(NOT EXISTS "${MSVC_BASE}" OR
192    NOT EXISTS "${MSVC_INCLUDE}" OR
193    NOT EXISTS "${MSVC_LIB}")
194   message(SEND_ERROR
195           "CMake variable MSVC_BASE must point to a folder containing MSVC "
196           "system headers and libraries")
197 endif()
198
199 if(NOT EXISTS "${WINSDK_BASE}" OR
200    NOT EXISTS "${WINSDK_INCLUDE}" OR
201    NOT EXISTS "${WINSDK_LIB}")
202   message(SEND_ERROR
203           "CMake variable WINSDK_BASE and WINSDK_VER must resolve to a valid "
204           "Windows SDK installation")
205 endif()
206
207 if(NOT EXISTS "${WINSDK_INCLUDE}/um/Windows.h")
208   message(SEND_ERROR "Cannot find Windows.h")
209 endif()
210 if(NOT EXISTS "${WINSDK_INCLUDE}/um/WINDOWS.H")
211   set(case_sensitive_filesystem TRUE)
212 endif()
213
214 set(CMAKE_C_COMPILER "${LLVM_NATIVE_TOOLCHAIN}/bin/clang-cl" CACHE FILEPATH "")
215 set(CMAKE_CXX_COMPILER "${LLVM_NATIVE_TOOLCHAIN}/bin/clang-cl" CACHE FILEPATH "")
216 set(CMAKE_LINKER "${LLVM_NATIVE_TOOLCHAIN}/bin/lld-link" CACHE FILEPATH "")
217
218 # Even though we're cross-compiling, we need some native tools (e.g. llvm-tblgen), and those
219 # native tools have to be built before we can start doing the cross-build.  LLVM supports
220 # a CROSS_TOOLCHAIN_FLAGS_NATIVE argument which consists of a list of flags to pass to CMake
221 # when configuring the NATIVE portion of the cross-build.  By default we construct this so
222 # that it points to the tools in the same location as the native clang-cl that we're using.
223 list(APPEND _CTF_NATIVE_DEFAULT "-DCMAKE_ASM_COMPILER=${LLVM_NATIVE_TOOLCHAIN}/bin/clang")
224 list(APPEND _CTF_NATIVE_DEFAULT "-DCMAKE_C_COMPILER=${LLVM_NATIVE_TOOLCHAIN}/bin/clang")
225 list(APPEND _CTF_NATIVE_DEFAULT "-DCMAKE_CXX_COMPILER=${LLVM_NATIVE_TOOLCHAIN}/bin/clang++")
226
227 set(CROSS_TOOLCHAIN_FLAGS_NATIVE "${_CTF_NATIVE_DEFAULT}" CACHE STRING "")
228
229 set(COMPILE_FLAGS
230     -D_CRT_SECURE_NO_WARNINGS
231     --target=${TRIPLE_ARCH}-windows-msvc
232     -fms-compatibility-version=19.11
233     -imsvc "${MSVC_INCLUDE}"
234     -imsvc "${WINSDK_INCLUDE}/ucrt"
235     -imsvc "${WINSDK_INCLUDE}/shared"
236     -imsvc "${WINSDK_INCLUDE}/um"
237     -imsvc "${WINSDK_INCLUDE}/winrt")
238
239 if(case_sensitive_filesystem)
240   # Ensure all sub-configures use the top-level VFS overlay instead of generating their own.
241   init_user_prop(winsdk_vfs_overlay_path)
242   if(NOT winsdk_vfs_overlay_path)
243     set(winsdk_vfs_overlay_path "${CMAKE_BINARY_DIR}/winsdk_vfs_overlay.yaml")
244     generate_winsdk_vfs_overlay("${WINSDK_BASE}/Include/${WINSDK_VER}" "${winsdk_vfs_overlay_path}")
245     init_user_prop(winsdk_vfs_overlay_path)
246   endif()
247   list(APPEND COMPILE_FLAGS
248        -Xclang -ivfsoverlay -Xclang "${winsdk_vfs_overlay_path}")
249 endif()
250
251 string(REPLACE ";" " " COMPILE_FLAGS "${COMPILE_FLAGS}")
252
253 # We need to preserve any flags that were passed in by the user. However, we
254 # can't append to CMAKE_C_FLAGS and friends directly, because toolchain files
255 # will be re-invoked on each reconfigure and therefore need to be idempotent.
256 # The assignments to the _INITIAL cache variables don't use FORCE, so they'll
257 # only be populated on the initial configure, and their values won't change
258 # afterward.
259 set(_CMAKE_C_FLAGS_INITIAL "${CMAKE_C_FLAGS}" CACHE STRING "")
260 set(CMAKE_C_FLAGS "${_CMAKE_C_FLAGS_INITIAL} ${COMPILE_FLAGS}" CACHE STRING "" FORCE)
261
262 set(_CMAKE_CXX_FLAGS_INITIAL "${CMAKE_CXX_FLAGS}" CACHE STRING "")
263 set(CMAKE_CXX_FLAGS "${_CMAKE_CXX_FLAGS_INITIAL} ${COMPILE_FLAGS}" CACHE STRING "" FORCE)
264
265 set(LINK_FLAGS
266     # Prevent CMake from attempting to invoke mt.exe. It only recognizes the slashed form and not the dashed form.
267     /manifest:no
268
269     -libpath:"${MSVC_LIB}/${WINSDK_ARCH}"
270     -libpath:"${WINSDK_LIB}/ucrt/${WINSDK_ARCH}"
271     -libpath:"${WINSDK_LIB}/um/${WINSDK_ARCH}")
272
273 if(case_sensitive_filesystem)
274   # Ensure all sub-configures use the top-level symlinks dir instead of generating their own.
275   init_user_prop(winsdk_lib_symlinks_dir)
276   if(NOT winsdk_lib_symlinks_dir)
277     set(winsdk_lib_symlinks_dir "${CMAKE_BINARY_DIR}/winsdk_lib_symlinks")
278     generate_winsdk_lib_symlinks("${WINSDK_BASE}/Lib/${WINSDK_VER}/um/${WINSDK_ARCH}" "${winsdk_lib_symlinks_dir}")
279     init_user_prop(winsdk_lib_symlinks_dir)
280   endif()
281   list(APPEND LINK_FLAGS
282        -libpath:"${winsdk_lib_symlinks_dir}")
283 endif()
284
285 string(REPLACE ";" " " LINK_FLAGS "${LINK_FLAGS}")
286
287 # See explanation for compiler flags above for the _INITIAL variables.
288 set(_CMAKE_EXE_LINKER_FLAGS_INITIAL "${CMAKE_EXE_LINKER_FLAGS}" CACHE STRING "")
289 set(CMAKE_EXE_LINKER_FLAGS "${_CMAKE_EXE_LINKER_FLAGS_INITIAL} ${LINK_FLAGS}" CACHE STRING "" FORCE)
290
291 set(_CMAKE_MODULE_LINKER_FLAGS_INITIAL "${CMAKE_MODULE_LINKER_FLAGS}" CACHE STRING "")
292 set(CMAKE_MODULE_LINKER_FLAGS "${_CMAKE_MODULE_LINKER_FLAGS_INITIAL} ${LINK_FLAGS}" CACHE STRING "" FORCE)
293
294 set(_CMAKE_SHARED_LINKER_FLAGS_INITIAL "${CMAKE_SHARED_LINKER_FLAGS}" CACHE STRING "")
295 set(CMAKE_SHARED_LINKER_FLAGS "${_CMAKE_SHARED_LINKER_FLAGS_INITIAL} ${LINK_FLAGS}" CACHE STRING "" FORCE)
296
297 # CMake populates these with a bunch of unnecessary libraries, which requires
298 # extra case-correcting symlinks and what not. Instead, let projects explicitly
299 # control which libraries they require.
300 set(CMAKE_C_STANDARD_LIBRARIES "" CACHE STRING "" FORCE)
301 set(CMAKE_CXX_STANDARD_LIBRARIES "" CACHE STRING "" FORCE)
302
303 # Allow clang-cl to work with macOS paths.
304 set(CMAKE_USER_MAKE_RULES_OVERRIDE "${CMAKE_CURRENT_LIST_DIR}/ClangClCMakeCompileRules.cmake")