1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
|
# -----------------------------------------------------------------------------
# This file is included individually from various subdirectories (JSC, WTF,
# WebCore, WebKit) in order to allow scripts to build only part of WebKit.
# We want to run this file only once.
# -----------------------------------------------------------------------------
if (NOT HAS_RUN_WEBKIT_COMMON)
set(HAS_RUN_WEBKIT_COMMON TRUE)
if (NOT CMAKE_BUILD_TYPE)
message(WARNING "No CMAKE_BUILD_TYPE value specified, defaulting to RelWithDebInfo.")
set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build." FORCE)
else ()
message(STATUS "The CMake build type is: ${CMAKE_BUILD_TYPE}")
endif ()
# Exporting compile commands is available for Ninja and Makefile generators
# See https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html
if (DEVELOPER_MODE AND (CMAKE_GENERATOR MATCHES "Makefile" OR CMAKE_GENERATOR MATCHES "Ninja"))
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
endif ()
option(ENABLE_JAVASCRIPTCORE "Enable building JavaScriptCore" ON)
option(ENABLE_WEBCORE "Enable building JavaScriptCore" ON)
option(ENABLE_WEBKIT "Enable building WebKit" ON)
if (NOT ENABLE_JAVASCRIPTCORE)
set(ENABLE_WEBCORE OFF)
endif ()
if (NOT ENABLE_WEBCORE)
set(ENABLE_WEBKIT OFF)
endif ()
if (NOT DEFINED ENABLE_TOOLS AND EXISTS "${CMAKE_SOURCE_DIR}/Tools")
set(ENABLE_TOOLS ON)
endif ()
if (NOT DEFINED ENABLE_WEBINSPECTORUI)
set(ENABLE_WEBINSPECTORUI ON)
endif ()
# -----------------------------------------------------------------------------
# Determine which port will be built
# -----------------------------------------------------------------------------
set(ALL_PORTS
GTK
JSCOnly
Mac
PlayStation
WPE
Win
)
set(PORT "NOPORT" CACHE STRING "choose which WebKit port to build (one of ${ALL_PORTS})")
list(FIND ALL_PORTS ${PORT} RET)
if (${RET} EQUAL -1)
if (APPLE)
set(PORT "Mac")
else ()
message(FATAL_ERROR "Please choose which WebKit port to build (one of ${ALL_PORTS})")
endif ()
endif ()
string(TOLOWER ${PORT} WEBKIT_PORT_DIR)
# -----------------------------------------------------------------------------
# Determine the compiler
# -----------------------------------------------------------------------------
if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "AppleClang")
set(COMPILER_IS_CLANG ON)
endif ()
if (${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
if (${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS "11.2.0")
message(FATAL_ERROR "GCC 11.2 or newer is required to build WebKit. Use a newer GCC version or Clang.")
endif ()
endif ()
if (${CMAKE_CXX_COMPILER_ID} STREQUAL "QCC")
set(COMPILER_IS_QCC ON)
set(COMPILER_IS_GCC_OR_CLANG ON)
endif ()
if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
set(COMPILER_IS_GCC_OR_CLANG ON)
endif ()
if (MSVC AND COMPILER_IS_CLANG)
set(COMPILER_IS_CLANG_CL ON)
endif ()
# -----------------------------------------------------------------------------
# Determine the target processor
# -----------------------------------------------------------------------------
# Use MSVC_CXX_ARCHITECTURE_ID instead of CMAKE_SYSTEM_PROCESSOR when defined,
# since the later one just resolves to the host processor on Windows.
if (MSVC_CXX_ARCHITECTURE_ID)
string(TOLOWER ${MSVC_CXX_ARCHITECTURE_ID} LOWERCASE_CMAKE_SYSTEM_PROCESSOR)
else ()
string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} LOWERCASE_CMAKE_SYSTEM_PROCESSOR)
endif ()
if (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "(^aarch64|^arm64|^cortex-?[am][2-7][2-8])")
set(WTF_CPU_ARM64 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "(^arm|^cortex)")
set(WTF_CPU_ARM 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "^mips64")
set(WTF_CPU_MIPS64 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
set(WTF_CPU_MIPS 1)
elseif (CMAKE_CXX_LIBRARY_ARCHITECTURE STREQUAL "x86_64-linux-gnux32")
set(WTF_CPU_UNKNOWN 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "(x64|x86_64|amd64)")
# FORCE_32BIT is set in the build script when --32-bit is passed
# on a Linux/intel 64bit host. This allows us to produce 32bit
# binaries without setting the build up as a crosscompilation,
# which is the only way to modify CMAKE_SYSTEM_PROCESSOR.
if (FORCE_32BIT)
set(WTF_CPU_X86 1)
else ()
set(WTF_CPU_X86_64 1)
endif ()
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "(i[3-6]86|x86)")
set(WTF_CPU_X86 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc|powerpc)")
set(WTF_CPU_PPC 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64")
set(WTF_CPU_PPC64 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")
set(WTF_CPU_PPC64LE 1)
elseif (LOWERCASE_CMAKE_SYSTEM_PROCESSOR MATCHES "^loongarch64")
set(WTF_CPU_LOONGARCH64 1)
else ()
set(WTF_CPU_UNKNOWN 1)
endif ()
# -----------------------------------------------------------------------------
# Determine the operating system
# -----------------------------------------------------------------------------
if (UNIX)
if (APPLE)
set(WTF_OS_MACOS 1)
elseif (CMAKE_SYSTEM_NAME MATCHES "Linux")
set(WTF_OS_LINUX 1)
else ()
set(WTF_OS_UNIX 1)
endif ()
elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
set(WTF_OS_WINDOWS 1)
elseif (CMAKE_SYSTEM_NAME MATCHES "Fuchsia")
set(WTF_OS_FUCHSIA 1)
else ()
message(FATAL_ERROR "Unknown OS '${CMAKE_SYSTEM_NAME}'")
endif ()
# -----------------------------------------------------------------------------
# Default library types
# -----------------------------------------------------------------------------
# By default, only the highest-level libraries, WebKitLegacy and WebKit, are
# shared, because properly building shared libraries that depend on each other
# can be tricky. Override these in Options*.cmake for your port as needed.
set(bmalloc_LIBRARY_TYPE STATIC)
set(WTF_LIBRARY_TYPE STATIC)
set(JavaScriptCore_LIBRARY_TYPE STATIC)
set(PAL_LIBRARY_TYPE STATIC)
set(WebCore_LIBRARY_TYPE STATIC)
set(WebKitLegacy_LIBRARY_TYPE SHARED)
set(WebKit_LIBRARY_TYPE SHARED)
set(WebCoreTestSupport_LIBRARY_TYPE STATIC)
set(CMAKE_POSITION_INDEPENDENT_CODE True)
# -----------------------------------------------------------------------------
# Install JavaScript shell
# -----------------------------------------------------------------------------
option(SHOULD_INSTALL_JS_SHELL "generate an installation rule to install the built JavaScript shell")
# -----------------------------------------------------------------------------
# Default output directories, which can be overwritten by ports
#------------------------------------------------------------------------------
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
# -----------------------------------------------------------------------------
# Find common packages (used by all ports)
# -----------------------------------------------------------------------------
if (WIN32)
list(APPEND CMAKE_PROGRAM_PATH $ENV{SystemDrive}/cygwin/bin)
endif ()
# TODO Enforce version requirement for perl
find_package(Perl 5.10.0 REQUIRED)
find_package(PerlModules COMPONENTS English FindBin JSON::PP REQUIRED)
# This module looks preferably for version 3 of Python. If not found, version 2 is searched.
find_package(Python COMPONENTS Interpreter REQUIRED)
# Set the variable with uppercase name to keep compatibility with code and users expecting it.
set(PYTHON_EXECUTABLE ${Python_EXECUTABLE} CACHE FILEPATH "Path to the Python interpreter")
# We cannot check for RUBY_FOUND because it is set only when the full package is installed and
# the only thing we need is the interpreter. Unlike Python, cmake does not provide a macro
# for finding only the Ruby interpreter.
find_package(Ruby 2.5)
if (NOT RUBY_EXECUTABLE OR RUBY_VERSION VERSION_LESS 2.5)
message(FATAL_ERROR "Ruby 2.5 or higher is required.")
endif ()
# -----------------------------------------------------------------------------
# Helper macros and feature defines
# -----------------------------------------------------------------------------
# To prevent multiple inclusion, most modules should be included once here.
include(CheckCCompilerFlag)
include(CheckCSourceCompiles)
include(CheckCXXCompilerFlag)
include(CheckCXXSourceCompiles)
include(CheckFunctionExists)
include(CheckIncludeFile)
include(CheckSymbolExists)
include(CheckStructHasMember)
include(CheckTypeSize)
include(CMakeDependentOption)
include(CMakeParseArguments)
include(CMakePushCheckState)
include(ProcessorCount)
include(WebKitPackaging)
include(WebKitMacros)
include(WebKitFS)
include(WebKitCCache)
include(WebKitCompilerFlags)
include(WebKitStaticAnalysis)
include(WebKitFeatures)
include(WebKitFindPackage)
include(OptionsCommon)
include(Options${PORT})
# Check gperf after including OptionsXXX.cmake since gperf is required only when ENABLE_WEBCORE is true,
# and ENABLE_WEBCORE is configured in OptionsXXX.cmake.
if (ENABLE_WEBCORE)
# TODO Enforce version requirement for gperf
find_package(Gperf 3.0.1 REQUIRED)
endif ()
# -----------------------------------------------------------------------------
# Generate a usable compile_commands.json when using unified builds
# -----------------------------------------------------------------------------
# Ideally this would be done during configure or generation, but CMake doesn't
# produce compile_commands.json until generation has ended. Having a build
# target that processes it is the next best thing we can do.
if (CMAKE_EXPORT_COMPILE_COMMANDS AND ENABLE_UNIFIED_BUILDS)
# compile_commands.json
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/DeveloperTools/compile_commands.json
DEPENDS ${CMAKE_SOURCE_DIR}/Tools/Scripts/rewrite-compile-commands
${CMAKE_BINARY_DIR}/compile_commands.json
COMMAND ${Python_EXECUTABLE}
${CMAKE_SOURCE_DIR}/Tools/Scripts/rewrite-compile-commands
${CMAKE_BINARY_DIR}/compile_commands.json
${CMAKE_BINARY_DIR}/DeveloperTools/compile_commands.json
${CMAKE_SOURCE_DIR}
${CMAKE_BINARY_DIR}
VERBATIM
)
add_custom_target(RewriteCompileCommands
ALL
DEPENDS ${CMAKE_BINARY_DIR}/DeveloperTools/compile_commands.json
)
elseif (CMAKE_EXPORT_COMPILE_COMMANDS)
# Create a simple symlink in DeveloperTools/compile_commands.json so that
# it can be relied upon regardless of unified or non-unified builds.
file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/DeveloperTools)
set(COMPILE_COMMANDS_PATH "../compile_commands.json")
cmake_path(NATIVE_PATH COMPILE_COMMANDS_PATH COMPILE_COMMANDS_PATH)
file(CREATE_LINK
${COMPILE_COMMANDS_PATH}
${CMAKE_BINARY_DIR}/DeveloperTools/compile_commands.json
SYMBOLIC
)
endif ()
# CLANGD_AUTO_SETUP defaults to ON if ENABLE_DEVELOPER_MODE or if building inside <SOURCE>/WebKitBuild
set(webkitbuild_dir ${CMAKE_SOURCE_DIR}/WebKitBuild)
cmake_path(IS_PREFIX webkitbuild_dir ${CMAKE_BINARY_DIR} NORMALIZE building_inside_WebKitBuild)
if (building_inside_WebKitBuild OR ENABLE_DEVELOPER_MODE)
set(clangd_auto_setup_default ON)
else ()
set(clangd_auto_setup_default OFF)
endif ()
cmake_dependent_option(CLANGD_AUTO_SETUP
"Install a .clangd configuration file and a compile_commands.json symlink
in the root of the source tree to have out-of-the-box code completion
in editors."
${clangd_auto_setup_default}
CMAKE_EXPORT_COMPILE_COMMANDS
OFF
)
if (CLANGD_AUTO_SETUP)
# update-compile-commands-symlink.conf
add_custom_command(
OUTPUT ${CMAKE_SOURCE_DIR}/update-compile-commands-symlink.conf
DEPENDS ${TOOLS_DIR}/clangd/update-compile-commands-symlink-conf
${TOOLS_DIR}/clangd/update-compile-commands-symlink.conf.example
COMMAND ${Python_EXECUTABLE}
${TOOLS_DIR}/clangd/update-compile-commands-symlink-conf
${TOOLS_DIR}/clangd/update-compile-commands-symlink.conf.example
${CMAKE_SOURCE_DIR}/update-compile-commands-symlink.conf
VERBATIM
)
# compile_commands.json
add_custom_target(UpdateCompileCommandsSymlink
ALL
DEPENDS ${CMAKE_BINARY_DIR}/DeveloperTools/compile_commands.json
${CMAKE_SOURCE_DIR}/update-compile-commands-symlink.conf
COMMAND ${Python_EXECUTABLE}
${TOOLS_DIR}/clangd/update-compile-commands-symlink
${CMAKE_SOURCE_DIR}/compile_commands.json
${CMAKE_SOURCE_DIR}/update-compile-commands-symlink.conf
VERBATIM
)
# .clangd
add_custom_command(
OUTPUT ${CMAKE_SOURCE_DIR}/.clangd
DEPENDS ${TOOLS_DIR}/clangd/update-clangd-config
${TOOLS_DIR}/clangd/clangd-config.yaml.tpl
COMMAND ${Python_EXECUTABLE}
${TOOLS_DIR}/clangd/update-clangd-config
${TOOLS_DIR}/clangd/clangd-config.yaml.tpl
${CMAKE_SOURCE_DIR}/.clangd
VERBATIM
)
add_custom_target(UpdateClangdConf
ALL
DEPENDS ${CMAKE_SOURCE_DIR}/.clangd
)
endif ()
# -----------------------------------------------------------------------------
# Job pool to avoid running too many memory hungry processes
# -----------------------------------------------------------------------------
if (DEFINED ENV{WEBKIT_NINJA_LINK_MAX})
list(APPEND WK_POOLS "link_pool_jobs=$ENV{WEBKIT_NINJA_LINK_MAX}")
elseif (${CMAKE_BUILD_TYPE} STREQUAL "Release" OR ${CMAKE_BUILD_TYPE} STREQUAL "MinSizeRel")
list(APPEND WK_POOLS link_pool_jobs=4)
else ()
list(APPEND WK_POOLS link_pool_jobs=2)
endif ()
set(CMAKE_JOB_POOL_LINK link_pool_jobs)
if (DEFINED ENV{WEBKIT_NINJA_COMPILE_MAX})
list(APPEND WK_POOLS "compile_pool_jobs=$ENV{WEBKIT_NINJA_COMPILE_MAX}")
set(CMAKE_JOB_POOL_COMPILE compile_pool_jobs)
endif ()
set_property(GLOBAL PROPERTY JOB_POOLS ${WK_POOLS})
# -----------------------------------------------------------------------------
# Create derived sources directories
# -----------------------------------------------------------------------------
file(MAKE_DIRECTORY ${WTF_DERIVED_SOURCES_DIR})
file(MAKE_DIRECTORY ${JavaScriptCore_DERIVED_SOURCES_DIR})
if (ENABLE_WEBCORE)
file(MAKE_DIRECTORY ${PAL_DERIVED_SOURCES_DIR})
file(MAKE_DIRECTORY ${WebCore_DERIVED_SOURCES_DIR})
endif ()
if (ENABLE_WEBKIT)
file(MAKE_DIRECTORY ${WebKit_DERIVED_SOURCES_DIR})
endif ()
if (ENABLE_WEBKIT_LEGACY)
file(MAKE_DIRECTORY ${WebKitLegacy_DERIVED_SOURCES_DIR})
endif ()
if (ENABLE_WEBDRIVER)
file(MAKE_DIRECTORY ${WebDriver_DERIVED_SOURCES_DIR})
endif ()
# -----------------------------------------------------------------------------
# config.h
# -----------------------------------------------------------------------------
CREATE_CONFIGURATION_HEADER()
endif ()
|
