mirrors/arrow
0
0 Fork 0
mirror of https://github.com/apache/arrow.git synced 2026-10-28 16:47:19 +08:00
Code Activity
Files
main
arrow/cpp/cmake_modules/SetupCxxFlags.cmake
T
Sutou Kouhei e53d3f202b GH-51690: [C++] Don't define __SSE2__ globally with MSVC (#53952) 
### Rationale for this change

`simdjson >= 5` uses GCC builtins such as `__builtin_ctz` when `__SSE2__` is defined. So we can't build Apache Arrow C++ with `simdjson >= 5` and MSVC because we define `__SSE2__` globally.

### What changes are included in this PR?

We don't need to define `__SSE2__` because xsimd detects SSE2 by `_M_X64` with MSVC.

We still need to define `__SSE4_1__`/`__SSE4_2__` for xsimd because MSVC doesn't define them even with `/arch:SSE4.2`. But we define them only where SSE4.2 is enabled. So they are no longer defined with `ARROW_SIMD_LEVEL=NONE`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.

### Was AI used for this PR?

In accordance to the [AI generation guidelines](https://arrow.apache.org/docs/dev/developers/overview.html#ai-generated-code), please disclose below whether and how AI was used in this PR.

**PR code and description written by:**

- [x] Human
- [x] AI

**Reviewed before submission by:**

- [x] Human
- [ ] AI
- [ ] Not reviewed

* GitHub Issue: #51690

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
2026-10-23 12:03:55 +09:00

754 lines
31 KiB
CMake
Raw Permalink Blame History

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# Check if the target architecture and compiler supports some special
# instruction sets that would boost performance.
include(CheckCXXCompilerFlag)
include(CheckCXXSourceCompiles)
# Get cpu architecture
message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}")
if(NOT DEFINED ARROW_CPU_FLAG)
if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
set(ARROW_CPU_FLAG "emscripten")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64|amd64|X86|x86|i[3456]86|x64")
set(ARROW_CPU_FLAG "x86")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm$|armv[4-7]|armv8l")
set(ARROW_CPU_FLAG "aarch32")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|ARM64|arm64|armv")
set(ARROW_CPU_FLAG "aarch64")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "powerpc|ppc")
set(ARROW_CPU_FLAG "ppc")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "s390x")
set(ARROW_CPU_FLAG "s390x")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64")
set(ARROW_CPU_FLAG "riscv64")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
set(ARROW_CPU_FLAG "loongarch64")
else()
message(FATAL_ERROR "Unknown system processor")
endif()
endif()
# Check architecture specific compiler flags
if(ARROW_CPU_FLAG STREQUAL "x86")
# x86/amd64 compiler flags, msvc/gcc/clang
if(MSVC)
# MSVC doesn't define __SSE4_1__/__SSE4_2__ even with /arch:SSE4.2 (unlike
# other compilers) but xsimd needs them to consider SSE4.x available. We
# define them only where SSE4.2 is enabled. We don't define __SSE2__
# because xsimd detects SSE2 by _M_X64 and simdjson >= 5 uses GCC builtins
# when __SSE2__ is defined.
# See also:
# * https://learn.microsoft.com/en-us/cpp/build/reference/arch-x64
# * https://github.com/xtensor-stack/xsimd/issues/878
# * https://github.com/apache/arrow/issues/51690
set(ARROW_SSE4_2_FLAG "/arch:SSE4.2" "-D__SSE4_1__" "-D__SSE4_2__")
set(ARROW_AVX2_FLAGS "/arch:AVX2")
# MSVC has no specific flag for BMI2, it seems to be enabled with AVX2
set(ARROW_BMI2_FLAGS "/arch:AVX2")
set(ARROW_AVX512_FLAG "/arch:AVX512")
set(CXX_SUPPORTS_SSE4_2 TRUE)
else()
set(ARROW_SSE4_2_FLAG "-msse4.2")
set(ARROW_AVX2_FLAGS "-march=haswell")
set(ARROW_BMI2_FLAG "-mbmi2")
# skylake-avx512 consists of AVX512F,AVX512BW,AVX512VL,AVX512CD,AVX512DQ
set(ARROW_AVX512_FLAG "-march=skylake-avx512")
# Append the avx2/avx512 subset option also, fix issue ARROW-9877 for homebrew-cpp
list(APPEND ARROW_AVX2_FLAGS "-mavx2")
set(ARROW_AVX512_FLAG
"${ARROW_AVX512_FLAG} -mavx512f -mavx512cd -mavx512vl -mavx512dq -mavx512bw")
check_cxx_compiler_flag(${ARROW_SSE4_2_FLAG} CXX_SUPPORTS_SSE4_2)
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
# Check for AVX extensions on 64-bit systems only, as 32-bit support seems iffy
list(JOIN ARROW_AVX2_FLAGS " " ARROW_AVX2_FLAGS_COMMAND_LINE)
if(MINGW AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412
message(STATUS "Disable AVX2 support on gcc / MINGW for now")
else()
check_cxx_compiler_flag("${ARROW_AVX2_FLAGS_COMMAND_LINE}" CXX_SUPPORTS_AVX2)
endif()
if(MINGW)
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65782
message(STATUS "Disable AVX512 support on MINGW for now")
else()
# Check for AVX512 support in the compiler.
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${ARROW_AVX512_FLAG}")
check_cxx_source_compiles("
#ifdef _MSC_VER
#include <intrin.h>
#else
#include <immintrin.h>
#endif
int main() {
__m512i mask = _mm512_set1_epi32(0x1);
char out[32];
_mm512_storeu_si512(out, mask);
return 0;
}"
CXX_SUPPORTS_AVX512)
set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
endif()
endif()
# Runtime SIMD level it can get from compiler and ARROW_RUNTIME_SIMD_LEVEL
if(CXX_SUPPORTS_SSE4_2 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES
"^(SSE4_2|AVX2|AVX512|MAX)$")
set(ARROW_HAVE_RUNTIME_SSE4_2 ON)
add_definitions(-DARROW_HAVE_RUNTIME_SSE4_2)
endif()
# Note: for now we assume that AVX2 support should also enable BMI2 support,
# at least at compile-time (more care may be required for runtime dispatch).
if(CXX_SUPPORTS_AVX2 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(AVX2|AVX512|MAX)$")
set(ARROW_HAVE_RUNTIME_AVX2 ON)
set(ARROW_HAVE_RUNTIME_BMI2 ON)
add_definitions(-DARROW_HAVE_RUNTIME_AVX2 -DARROW_HAVE_RUNTIME_BMI2)
endif()
if(CXX_SUPPORTS_AVX512 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(AVX512|MAX)$")
set(ARROW_HAVE_RUNTIME_AVX512 ON)
add_definitions(-DARROW_HAVE_RUNTIME_AVX512)
endif()
if(ARROW_SIMD_LEVEL STREQUAL "DEFAULT")
set(ARROW_SIMD_LEVEL "SSE4_2")
endif()
elseif(ARROW_CPU_FLAG STREQUAL "ppc")
# power compiler flags, gcc/clang only
set(ARROW_ALTIVEC_FLAG "-maltivec")
check_cxx_compiler_flag(${ARROW_ALTIVEC_FLAG} CXX_SUPPORTS_ALTIVEC)
if(ARROW_SIMD_LEVEL STREQUAL "DEFAULT")
set(ARROW_SIMD_LEVEL "NONE")
endif()
elseif(ARROW_CPU_FLAG STREQUAL "aarch64")
# Arm64 compiler flags, gcc/clang only
set(ARROW_ARMV8_MARCH "armv8-a")
set(ARROW_SVE_FLAGS "-march=${ARROW_ARMV8_MARCH}+sve")
set(ARROW_SVE128_FLAGS "${ARROW_SVE_FLAGS}" "-msve-vector-bits=128")
set(ARROW_SVE256_FLAGS "${ARROW_SVE_FLAGS}" "-msve-vector-bits=256")
set(ARROW_SVE512_FLAGS "${ARROW_SVE_FLAGS}" "-msve-vector-bits=512")
# We only have a way to do SVE dynamic dispatch on Linux (BSD may be possible
# but is currently not implemented).
# We still support explicitly setting runtime SIMD level to some SVE values
# on these platforms as this can be useful in development for building SVE
# code locally. The compiler supports it but the code won't run.
if((APPLE OR WIN32) AND ARROW_RUNTIME_SIMD_LEVEL STREQUAL "MAX")
set(ARROW_RUNTIME_SIMD_LEVEL "NONE")
endif()
check_cxx_compiler_flag("${ARROW_SVE_FLAGS}" CXX_SUPPORTS_SVE)
if(CXX_SUPPORTS_SVE AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(SVE128|SVE256|SVE512|MAX)$")
set(ARROW_HAVE_RUNTIME_SVE128 ON)
add_definitions(-DARROW_HAVE_RUNTIME_SVE128)
endif()
if(CXX_SUPPORTS_SVE AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(SVE256|SVE512|MAX)$")
set(ARROW_HAVE_RUNTIME_SVE256 ON)
add_definitions(-DARROW_HAVE_RUNTIME_SVE256)
endif()
if(CXX_SUPPORTS_SVE AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(SVE512|MAX)$")
set(ARROW_HAVE_RUNTIME_SVE512 ON)
add_definitions(-DARROW_HAVE_RUNTIME_SVE512)
endif()
if(ARROW_SIMD_LEVEL STREQUAL "DEFAULT")
set(ARROW_SIMD_LEVEL "NEON")
endif()
endif()
# Support C11
if(NOT DEFINED CMAKE_C_STANDARD)
set(CMAKE_C_STANDARD 11)
endif()
# This ensures that a standard higher than the minimum can be passed correctly
if(NOT DEFINED CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD 20)
elseif(${CMAKE_CXX_STANDARD} VERSION_LESS 20)
message(FATAL_ERROR "Cannot set a CMAKE_CXX_STANDARD smaller than 20")
endif()
# We require a C++20 compliant compiler
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# ARROW-6848: Do not use GNU (or other CXX) extensions
set(CMAKE_CXX_EXTENSIONS OFF)
# Build with -fPIC so that can static link our libraries into other people's
# shared libraries
set(CMAKE_POSITION_INDEPENDENT_CODE ${ARROW_POSITION_INDEPENDENT_CODE})
set(UNKNOWN_COMPILER_MESSAGE
"Unknown compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
# Compiler flags used when building Arrow libraries (but not tests, utilities, etc.)
set(ARROW_LIBRARIES_ONLY_CXX_FLAGS)
# compiler flags that are common across debug/release builds
if(WIN32)
# TODO(wesm): Change usages of C runtime functions that MSVC says are
# insecure, like std::getenv
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
if(MSVC)
# ARROW-1931 See https://github.com/google/googletest/issues/1318
#
# This is added to CMAKE_CXX_FLAGS instead of CXX_COMMON_FLAGS since only the
# former is passed into the external projects
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING")
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# clang-cl
set(CXX_COMMON_FLAGS "-EHsc")
else()
# Fix annoying D9025 warning
string(REPLACE "/W3" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
# Set desired warning level (e.g. set /W4 for more warnings)
#
# ARROW-2986: Without /EHsc we get C4530 warning
set(CXX_COMMON_FLAGS "/W3 /EHsc")
endif()
# Enable the conforming preprocessor to support C++20 features.
#
# See also:
# * https://devblogs.microsoft.com/cppblog/announcing-full-support-for-a-c-c-conformant-preprocessor-in-msvc/
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Zc:preprocessor")
if(ARROW_USE_STATIC_CRT)
foreach(c_flag
CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELWITHDEBINFO)
string(REPLACE "/MD" "/MT" ${c_flag} "${${c_flag}}")
endforeach()
endif()
# Support large object code
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /bigobj")
# We may use UTF-8 in source code such as
# cpp/src/arrow/compute/kernels/scalar_string_test.cc
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /utf-8")
else()
# MinGW
check_cxx_compiler_flag(-Wa,-mbig-obj CXX_SUPPORTS_BIG_OBJ)
if(CXX_SUPPORTS_BIG_OBJ)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wa,-mbig-obj")
endif()
endif(MSVC)
else()
# Common flags set below with warning level
set(CXX_COMMON_FLAGS "")
endif()
# BUILD_WARNING_LEVEL add warning/error compiler flags. The possible values are
# - PRODUCTION: Build with `-Wall` but do not add `-Werror`, so warnings do not
# halt the build.
# - CHECKIN: Build with `-Wall` and `-Wextra`. Also, add `-Werror` in debug mode
# so that any important warnings fail the build.
# - EVERYTHING: Like `CHECKIN`, but possible extra flags depending on the
# compiler, including `-Wextra`, `-Weverything`, `-pedantic`.
# This is the most aggressive warning level.
# Defaults BUILD_WARNING_LEVEL to `CHECKIN`, unless CMAKE_BUILD_TYPE is
# `RELEASE`, then it will default to `PRODUCTION`. The goal of defaulting to
# `CHECKIN` is to avoid friction with long response time from CI.
if(NOT BUILD_WARNING_LEVEL)
if("${UPPERCASE_BUILD_TYPE}" STREQUAL "RELEASE")
set(BUILD_WARNING_LEVEL PRODUCTION)
else()
set(BUILD_WARNING_LEVEL CHECKIN)
endif()
endif(NOT BUILD_WARNING_LEVEL)
string(TOUPPER ${BUILD_WARNING_LEVEL} BUILD_WARNING_LEVEL)
message(STATUS "Arrow build warning level: ${BUILD_WARNING_LEVEL}")
macro(arrow_add_werror_if_debug)
# Treat all compiler warnings as errors
if(MSVC)
string(APPEND CMAKE_C_FLAGS_DEBUG " /WX")
string(APPEND CMAKE_CXX_FLAGS_DEBUG " /WX")
else()
string(APPEND CMAKE_C_FLAGS_DEBUG " -Werror")
string(APPEND CMAKE_CXX_FLAGS_DEBUG " -Werror")
endif()
endmacro()
if("${BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN")
# Pre-checkin builds
if(MSVC)
# https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warnings-by-compiler-version
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /W3")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4365")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4267")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4838")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang"
OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
OR CMAKE_CXX_COMPILER_ID STREQUAL "IBMClang")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wextra")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wdocumentation")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DARROW_WARN_DOCUMENTATION")
if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
# size_t is 32 bit in Emscripten wasm32 - ignore conversion errors
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-shorten-64-to-32")
else()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wshorten-64-to-32")
endif()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-missing-braces")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-constant-logical-operand")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-return-stack-address")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wdate-time")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-conversion")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-sign-conversion")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wdate-time")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wimplicit-fallthrough")
string(APPEND CXX_ONLY_FLAGS " -Wredundant-move")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wunused-result")
# Flag non-static functions that don't have corresponding declaration in a .h file.
# Only for Arrow libraries, since this is not a problem in tests or utilities.
list(APPEND ARROW_LIBRARIES_ONLY_CXX_FLAGS "-Wmissing-declarations")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
"IntelLLVM")
if(WIN32)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wno-deprecated")
else()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated")
endif()
else()
message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
endif()
arrow_add_werror_if_debug()
elseif("${BUILD_WARNING_LEVEL}" STREQUAL "EVERYTHING")
# Pedantic builds for fixing warnings
if(MSVC)
string(REPLACE "/W3" "" CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS}")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
# https://docs.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level
# /wdnnnn disables a warning where "nnnn" is a warning number
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
"Clang")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Weverything")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-c++98-compat")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-c++98-compat-pedantic")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wpedantic")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wextra")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wunused-result")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
"IntelLLVM")
if(WIN32)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
else()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
endif()
else()
message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
endif()
arrow_add_werror_if_debug()
else()
# Production builds (warning are not treated as errors)
if(MSVC)
# https://docs.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level
# TODO: Enable /Wall and disable individual warnings until build compiles without errors
# /wdnnnn disables a warning where "nnnn" is a warning number
string(REPLACE "/W3" "" CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS}")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /W3")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang"
OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
"IntelLLVM")
if(WIN32)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
else()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
endif()
else()
message(FATAL_ERROR "${UNKNOWN_COMPILER_MESSAGE}")
endif()
endif()
if(MSVC)
# Disable annoying "performance warning" about int-to-bool conversion
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4800")
# Disable unchecked iterator warnings, equivalent to /D_SCL_SECURE_NO_WARNINGS
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4996")
# Disable "switch statement contains 'default' but no 'case' labels" warning
# (required for protobuf, see https://github.com/protocolbuffers/protobuf/issues/6885)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4065")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "7.0" OR CMAKE_CXX_COMPILER_VERSION
VERSION_GREATER "7.0")
# Without this, gcc >= 7 warns related to changes in C++17
set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -Wno-noexcept-type")
endif()
if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "13.0" OR CMAKE_CXX_COMPILER_VERSION
VERSION_GREATER "13.0")
# -Wself-move added in GCC 13 warns when a value is moved to itself
# See https://gcc.gnu.org/gcc-13/changes.html
set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -Wno-self-move")
endif()
# Disabling semantic interposition allows faster calling conventions
# when calling global functions internally, and can also help inlining.
# See https://stackoverflow.com/questions/35745543/new-option-in-gcc-5-3-fno-semantic-interposition
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fno-semantic-interposition")
# Add colors when paired with ninja
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
if(CMAKE_UNITY_BUILD)
# Work around issue similar to https://bugs.webkit.org/show_bug.cgi?id=176869
set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -Wno-subobject-linkage")
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
"Clang")
# Clang options for all builds
# Using Clang with ccache causes a bunch of spurious warnings that are
# purportedly fixed in the next version of ccache. See the following for details:
#
# http://petereisentraut.blogspot.com/2011/05/ccache-and-clang.html
# http://petereisentraut.blogspot.com/2011/09/ccache-and-clang-part-2.html
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Qunused-arguments")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments")
# Avoid error when an unknown warning flag is passed
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unknown-warning-option")
# Add colors when paired with ninja
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
# Don't complain about optimization passes that were not possible
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-pass-failed")
if(APPLE)
# Avoid clang / libc++ error about C++17 aligned allocation on macOS.
# See https://chromium.googlesource.com/chromium/src/+/eee44569858fc650b635779c4e34be5cb0c73186%5E%21/#F0
# for details.
string(APPEND CXX_ONLY_FLAGS " -fno-aligned-new")
if(CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 20)
# Avoid C++17 std::get 'not available' issue on macOS 10.13
# This will be required until at least R 4.4 is released and
# CRAN (hopefully) stops checking on 10.13
string(APPEND CXX_ONLY_FLAGS " -D_LIBCPP_DISABLE_AVAILABILITY")
endif()
endif()
endif()
# if build warning flags is set, add to CXX_COMMON_FLAGS
if(BUILD_WARNING_FLAGS)
# Use BUILD_WARNING_FLAGS with BUILD_WARNING_LEVEL=everything to disable
# warnings (use with Clang's -Weverything flag to find potential errors)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${BUILD_WARNING_FLAGS}")
endif(BUILD_WARNING_FLAGS)
# Only enable additional instruction sets if they are supported
if(ARROW_CPU_FLAG STREQUAL "x86")
if(MINGW)
# Enable _xgetbv() intrinsic to query OS support for ZMM register saves
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -mxsave")
endif()
if(ARROW_SIMD_LEVEL STREQUAL "AVX512")
if(NOT CXX_SUPPORTS_AVX512)
message(FATAL_ERROR "AVX512 required but compiler doesn't support it.")
endif()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${ARROW_AVX512_FLAG}")
add_definitions(-DARROW_HAVE_AVX512 -DARROW_HAVE_AVX2 -DARROW_HAVE_BMI2
-DARROW_HAVE_SSE4_2)
elseif(ARROW_SIMD_LEVEL STREQUAL "AVX2")
if(NOT CXX_SUPPORTS_AVX2)
message(FATAL_ERROR "AVX2 required but compiler doesn't support it.")
endif()
list(JOIN ARROW_AVX2_FLAGS " " ARROW_AVX2_FLAGS_COMMAND_LINE)
string(APPEND CXX_COMMON_FLAGS " ${ARROW_AVX2_FLAGS_COMMAND_LINE}")
add_definitions(-DARROW_HAVE_AVX2 -DARROW_HAVE_BMI2 -DARROW_HAVE_SSE4_2)
elseif(ARROW_SIMD_LEVEL STREQUAL "SSE4_2")
if(NOT CXX_SUPPORTS_SSE4_2)
message(FATAL_ERROR "SSE4.2 required but compiler doesn't support it.")
endif()
list(JOIN ARROW_SSE4_2_FLAG " " ARROW_SSE4_2_FLAG_COMMAND_LINE)
string(APPEND CXX_COMMON_FLAGS " ${ARROW_SSE4_2_FLAG_COMMAND_LINE}")
add_definitions(-DARROW_HAVE_SSE4_2)
elseif(NOT ARROW_SIMD_LEVEL STREQUAL "NONE")
message(WARNING "ARROW_SIMD_LEVEL=${ARROW_SIMD_LEVEL} not supported by x86.")
endif()
endif()
if(ARROW_CPU_FLAG STREQUAL "ppc")
if(CXX_SUPPORTS_ALTIVEC AND ARROW_ALTIVEC)
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${ARROW_ALTIVEC_FLAG}")
endif()
endif()
if(ARROW_CPU_FLAG STREQUAL "aarch64")
if(ARROW_SIMD_LEVEL MATCHES "NEON|SVE[0-9]*")
set(ARROW_HAVE_NEON ON)
add_definitions(-DARROW_HAVE_NEON)
if(ARROW_SIMD_LEVEL MATCHES "SVE[0-9]*")
if(NOT CXX_SUPPORTS_SVE)
message(FATAL_ERROR "SVE required but compiler doesn't support it.")
endif()
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} ${ARROW_SVE_FLAGS}")
string(REGEX MATCH "[0-9]+" SVE_VECTOR_BITS ${ARROW_SIMD_LEVEL})
if(SVE_VECTOR_BITS)
set(ARROW_HAVE_SVE${SVE_VECTOR_BITS} ON)
add_definitions(-DARROW_HAVE_SVE${SVE_VECTOR_BITS})
# -msve-vector-bits=256
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -msve-vector-bits=${SVE_VECTOR_BITS}")
else()
set(ARROW_HAVE_SVE_SIZELESS ON)
add_definitions(-DARROW_HAVE_SVE_SIZELESS)
endif()
else() # ARM v8 without SVE
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -march=${ARROW_ARMV8_MARCH}")
endif()
elseif(NOT ARROW_SIMD_LEVEL STREQUAL "NONE")
message(WARNING "ARROW_SIMD_LEVEL=${ARROW_SIMD_LEVEL} not supported by Arm.")
endif()
endif()
if(NOT WIN32 AND NOT APPLE)
if(ARROW_USE_MOLD)
find_program(LD_MOLD ld.mold)
if(LD_MOLD)
unset(MOLD_LINKER_FLAGS)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1.0")
set(MOLD_LINKER_FLAGS "-fuse-ld=mold")
else()
message(STATUS "Need GCC 12.1.0 or later to use mold linker: ${CMAKE_CXX_COMPILER_VERSION}"
)
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0")
set(MOLD_LINKER_FLAGS "--ld-path=${LD_MOLD}")
else()
message(STATUS "Need clang 12.0.0 or later to use mold linker: ${CMAKE_CXX_COMPILER_VERSION}"
)
endif()
else()
message(STATUS "Using the default linker because compiler doesn't support mold: ${CMAKE_CXX_COMPILER_ID}"
)
endif()
if(MOLD_LINKER_FLAGS)
message(STATUS "Using optional mold linker")
string(APPEND CMAKE_EXE_LINKER_FLAGS " ${MOLD_LINKER_FLAGS}")
string(APPEND CMAKE_MODULE_LINKER_FLAGS " ${MOLD_LINKER_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${MOLD_LINKER_FLAGS}")
endif()
else()
message(STATUS "Using the default linker because mold isn't found")
endif()
endif()
endif()
if(ARROW_USE_LLD)
find_program(LD_LLD ld.lld)
if(LD_LLD)
unset(LLD_LINKER_FLAGS)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "9.1.0")
set(LLD_LINKER_FLAGS "-fuse-ld=lld")
else()
message(STATUS "Need GCC 9.1.0 or later to use LLD linker: ${CMAKE_CXX_COMPILER_VERSION}"
)
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0")
set(LLD_LINKER_FLAGS "--ld-path=${LD_LLD}")
else()
message(STATUS "Need clang 12.0.0 or later to use LLD linker: ${CMAKE_CXX_COMPILER_VERSION}"
)
endif()
else()
message(STATUS "Using the default linker because compiler doesn't support LLD: ${CMAKE_CXX_COMPILER_ID}"
)
endif()
if(LLD_LINKER_FLAGS)
message(STATUS "Using optional LLVM LLD linker")
string(APPEND CMAKE_EXE_LINKER_FLAGS " ${LLD_LINKER_FLAGS}")
string(APPEND CMAKE_MODULE_LINKER_FLAGS " ${LLD_LINKER_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${LLD_LINKER_FLAGS}")
else()
message(STATUS "Using the default linker because the LLD isn't supported")
endif()
endif()
endif()
# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .')
# For all builds:
# For CMAKE_BUILD_TYPE=Debug
# -ggdb: Enable gdb debugging
# For CMAKE_BUILD_TYPE=Release
# -O2 (not -O3): Enable compiler optimizations
# Debug symbols are stripped for reduced binary size.
# For CMAKE_BUILD_TYPE=RelWithDebInfo
# Same as Release, except with debug symbols enabled.
if(NOT MSVC)
set(C_RELEASE_FLAGS "")
if(CMAKE_C_FLAGS_RELEASE MATCHES "-O3")
string(APPEND C_RELEASE_FLAGS " -O2")
endif()
set(CXX_RELEASE_FLAGS "")
if(CMAKE_CXX_FLAGS_RELEASE MATCHES "-O3")
string(APPEND CXX_RELEASE_FLAGS " -O2")
endif()
set(C_RELWITHDEBINFO_FLAGS "")
if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES "-O3")
string(APPEND C_RELWITHDEBINFO_FLAGS " -O2")
endif()
set(CXX_RELWITHDEBINFO_FLAGS "")
if(CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "-O3")
string(APPEND CXX_RELWITHDEBINFO_FLAGS " -O2")
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
string(APPEND C_RELEASE_FLAGS " -ftree-vectorize")
string(APPEND CXX_RELEASE_FLAGS " -ftree-vectorize")
string(APPEND C_RELWITHDEBINFO_FLAGS " -ftree-vectorize")
string(APPEND CXX_RELWITHDEBINFO_FLAGS " -ftree-vectorize")
endif()
set(C_DEBUG_FLAGS "")
set(CXX_DEBUG_FLAGS "")
if(NOT MSVC)
if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
# with -g it uses DWARF debug info, which is really slow to build
# on emscripten (and uses tons of memory)
string(REPLACE "-g" " " CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
string(REPLACE "-g" " " CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
string(APPEND C_DEBUG_FLAGS " -g2")
string(APPEND CXX_DEBUG_FLAGS " -g2")
string(APPEND C_RELWITHDEBINFO_FLAGS " -g2")
string(APPEND CXX_RELWITHDEBINFO_FLAGS " -g2")
# without -O1, emscripten executables are *MASSIVE*. Don't use -O0
if(NOT CMAKE_C_FLAGS_DEBUG MATCHES "-O")
string(APPEND C_DEBUG_FLAGS " -O1")
endif()
if(NOT CMAKE_CXX_FLAGS_DEBUG MATCHES "-O")
string(APPEND CXX_DEBUG_FLAGS " -O1")
endif()
else()
if(NOT CMAKE_C_FLAGS_DEBUG MATCHES "-O")
string(APPEND C_DEBUG_FLAGS " -O0")
endif()
if(NOT CMAKE_CXX_FLAGS_DEBUG MATCHES "-O")
string(APPEND CXX_DEBUG_FLAGS " -O0")
endif()
if(ARROW_GGDB_DEBUG)
string(APPEND C_DEBUG_FLAGS " -ggdb")
string(APPEND CXX_DEBUG_FLAGS " -ggdb")
string(APPEND C_RELWITHDEBINFO_FLAGS " -ggdb")
string(APPEND CXX_RELWITHDEBINFO_FLAGS " -ggdb")
endif()
endif()
endif()
string(APPEND CMAKE_C_FLAGS_RELEASE "${C_RELEASE_FLAGS} ${ARROW_C_FLAGS_RELEASE}")
string(APPEND CMAKE_CXX_FLAGS_RELEASE "${CXX_RELEASE_FLAGS} ${ARROW_CXX_FLAGS_RELEASE}")
string(APPEND CMAKE_C_FLAGS_DEBUG "${C_DEBUG_FLAGS} ${ARROW_C_FLAGS_DEBUG}")
string(APPEND CMAKE_CXX_FLAGS_DEBUG "${CXX_DEBUG_FLAGS} ${ARROW_CXX_FLAGS_DEBUG}")
string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO
"${C_RELWITHDEBINFO_FLAGS} ${ARROW_C_FLAGS_RELWITHDEBINFO}")
string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO
"${CXX_RELWITHDEBINFO_FLAGS} ${ARROW_CXX_FLAGS_RELWITHDEBINFO}")
endif()
message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}")
# ----------------------------------------------------------------------
# MSVC-specific linker options
if(MSVC)
set(MSVC_LINKER_FLAGS)
if(MSVC_LINK_VERBOSE)
set(MSVC_LINKER_FLAGS "${MSVC_LINKER_FLAGS} /VERBOSE:LIB")
endif()
if(NOT ARROW_USE_STATIC_CRT)
set(MSVC_LINKER_FLAGS "${MSVC_LINKER_FLAGS} /NODEFAULTLIB:LIBCMT")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MSVC_LINKER_FLAGS}")
endif()
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
# flags are:
# 1) We force *everything* to build as position independent
# 2) And with support for C++ exceptions
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -fexceptions")
# deprecated-literal-operator error is thrown in datetime (vendored lib in arrow)
set(CMAKE_CXX_FLAGS
"${CMAKE_CXX_FLAGS} -fPIC -fexceptions -Wno-error=deprecated-literal-operator")
# flags for creating shared libraries (only used in pyarrow, because
# Emscripten builds libarrow as static)
# flags are:
# 1) Tell it to use JavaScript / WebAssembly 64 bit number support.
# 2) Tell it to build with support for C++ exceptions
# 3) Skip linker flags error which happens with -soname parameter
set(ARROW_EMSCRIPTEN_LINKER_FLAGS "-sWASM_BIGINT=1 -fexceptions -Wno-error=linkflags")
set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS
"-sSIDE_MODULE=1 ${ARROW_EMSCRIPTEN_LINKER_FLAGS}")
set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS
"-sSIDE_MODULE=1 ${ARROW_EMSCRIPTEN_LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "-sSIDE_MODULE=1 ${ARROW_EMSCRIPTEN_LINKER_FLAGS}")
if(ARROW_TESTING)
# Deeply nested tests need a larger stack (1 MiB).
set(ARROW_EMSCRIPTEN_TEST_STACK_SIZE 1048576)
# flags for building test executables for use in node
if("${UPPERCASE_BUILD_TYPE}" STREQUAL "RELEASE")
set(CMAKE_EXE_LINKER_FLAGS
"${ARROW_EMSCRIPTEN_LINKER_FLAGS} -sSTACK_SIZE=${ARROW_EMSCRIPTEN_TEST_STACK_SIZE} -sALLOW_MEMORY_GROWTH -lnodefs.js -lnoderawfs.js --pre-js ${BUILD_SUPPORT_DIR}/emscripten-test-init.js"
)
else()
set(CMAKE_EXE_LINKER_FLAGS
"${ARROW_EMSCRIPTEN_LINKER_FLAGS} -sERROR_ON_WASM_CHANGES_AFTER_LINK=1 -sSTACK_SIZE=${ARROW_EMSCRIPTEN_TEST_STACK_SIZE} -sALLOW_MEMORY_GROWTH -lnodefs.js -lnoderawfs.js --pre-js ${BUILD_SUPPORT_DIR}/emscripten-test-init.js"
)
endif()
else()
set(CMAKE_EXE_LINKER_FLAGS "${ARROW_EMSCRIPTEN_LINKER_FLAGS} -sALLOW_MEMORY_GROWTH")
endif()
endif()
View Git Blame Copy Permalink