diff options
author | Michal Klocek <michal.klocek@qt.io> | 2018-09-25 18:45:32 +0200 |
---|---|---|
committer | Allan Sandfeld Jensen <allan.jensen@qt.io> | 2021-11-11 13:13:30 +0100 |
commit | 9aedef545e3b698644ca68a60ca24882edf71b5d (patch) | |
tree | 104fc4b54ca2c346aa9bbf64fd511e86d89332c3 /gn | |
parent | 8c55f364dad167964b4959554863f905967cc239 (diff) | |
download | qtwebengine-chromium-9aedef545e3b698644ca68a60ca24882edf71b5d.tar.gz |
Better platform support for GN
Merge of patches:
Add x86 target support for gn
Fix creation of 'x86' toolchain in gn
Fix x86-32 builds with GCC 8
Fix building gn on arm
Task-number: QTBUG-70728
Fixes: QTBUG-72391
Fixes: QTBUG-72393
Change-Id: I7316edb5acb9832736eee368a02fbc39650d0136
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
Reviewed-by: Michal Klocek <michal.klocek@qt.io>
Diffstat (limited to 'gn')
-rw-r--r-- | gn/base/numerics/safe_conversions_arm_impl.h | 51 | ||||
-rw-r--r-- | gn/base/numerics/safe_math_arm_impl.h | 122 | ||||
-rwxr-xr-x | gn/build/gen.py | 40 |
3 files changed, 196 insertions, 17 deletions
diff --git a/gn/base/numerics/safe_conversions_arm_impl.h b/gn/base/numerics/safe_conversions_arm_impl.h new file mode 100644 index 00000000000..da5813f65e9 --- /dev/null +++ b/gn/base/numerics/safe_conversions_arm_impl.h @@ -0,0 +1,51 @@ +// Copyright 2017 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ +#define BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ + +#include <cassert> +#include <limits> +#include <type_traits> + +#include "base/numerics/safe_conversions_impl.h" + +namespace base { +namespace internal { + +// Fast saturation to a destination type. +template <typename Dst, typename Src> +struct SaturateFastAsmOp { + static const bool is_supported = + std::is_signed<Src>::value && std::is_integral<Dst>::value && + std::is_integral<Src>::value && + IntegerBitsPlusSign<Src>::value <= IntegerBitsPlusSign<int32_t>::value && + IntegerBitsPlusSign<Dst>::value <= IntegerBitsPlusSign<int32_t>::value && + !IsTypeInRangeForNumericType<Dst, Src>::value; + + __attribute__((always_inline)) static Dst Do(Src value) { + int32_t src = value; + typename std::conditional<std::is_signed<Dst>::value, int32_t, + uint32_t>::type result; + if (std::is_signed<Dst>::value) { + asm("ssat %[dst], %[shift], %[src]" + : [dst] "=r"(result) + : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign<Dst>::value <= 32 + ? IntegerBitsPlusSign<Dst>::value + : 32)); + } else { + asm("usat %[dst], %[shift], %[src]" + : [dst] "=r"(result) + : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign<Dst>::value < 32 + ? IntegerBitsPlusSign<Dst>::value + : 31)); + } + return static_cast<Dst>(result); + } +}; + +} // namespace internal +} // namespace base + +#endif // BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ diff --git a/gn/base/numerics/safe_math_arm_impl.h b/gn/base/numerics/safe_math_arm_impl.h new file mode 100644 index 00000000000..a7cda1bb238 --- /dev/null +++ b/gn/base/numerics/safe_math_arm_impl.h @@ -0,0 +1,122 @@ +// Copyright 2017 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ +#define BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ + +#include <cassert> +#include <limits> +#include <type_traits> + +#include "base/numerics/safe_conversions.h" + +namespace base { +namespace internal { + +template <typename T, typename U> +struct CheckedMulFastAsmOp { + static const bool is_supported = + FastIntegerArithmeticPromotion<T, U>::is_contained; + + // The following is much more efficient than the Clang and GCC builtins for + // performing overflow-checked multiplication when a twice wider type is + // available. The below compiles down to 2-3 instructions, depending on the + // width of the types in use. + // As an example, an int32_t multiply compiles to: + // smull r0, r1, r0, r1 + // cmp r1, r1, asr #31 + // And an int16_t multiply compiles to: + // smulbb r1, r1, r0 + // asr r2, r1, #16 + // cmp r2, r1, asr #15 + template <typename V> + __attribute__((always_inline)) static bool Do(T x, U y, V* result) { + using Promotion = typename FastIntegerArithmeticPromotion<T, U>::type; + Promotion presult; + + presult = static_cast<Promotion>(x) * static_cast<Promotion>(y); + *result = static_cast<V>(presult); + return IsValueInRangeForNumericType<V>(presult); + } +}; + +template <typename T, typename U> +struct ClampedAddFastAsmOp { + static const bool is_supported = + BigEnoughPromotion<T, U>::is_contained && + IsTypeInRangeForNumericType< + int32_t, + typename BigEnoughPromotion<T, U>::type>::value; + + template <typename V> + __attribute__((always_inline)) static V Do(T x, U y) { + // This will get promoted to an int, so let the compiler do whatever is + // clever and rely on the saturated cast to bounds check. + if (IsIntegerArithmeticSafe<int, T, U>::value) + return saturated_cast<V>(x + y); + + int32_t result; + int32_t x_i32 = x; + int32_t y_i32 = y; + + asm("qadd %[result], %[first], %[second]" + : [result] "=r"(result) + : [first] "r"(x_i32), [second] "r"(y_i32)); + return saturated_cast<V>(result); + } +}; + +template <typename T, typename U> +struct ClampedSubFastAsmOp { + static const bool is_supported = + BigEnoughPromotion<T, U>::is_contained && + IsTypeInRangeForNumericType< + int32_t, + typename BigEnoughPromotion<T, U>::type>::value; + + template <typename V> + __attribute__((always_inline)) static V Do(T x, U y) { + // This will get promoted to an int, so let the compiler do whatever is + // clever and rely on the saturated cast to bounds check. + if (IsIntegerArithmeticSafe<int, T, U>::value) + return saturated_cast<V>(x - y); + + int32_t result; + int32_t x_i32 = x; + int32_t y_i32 = y; + + asm("qsub %[result], %[first], %[second]" + : [result] "=r"(result) + : [first] "r"(x_i32), [second] "r"(y_i32)); + return saturated_cast<V>(result); + } +}; + +template <typename T, typename U> +struct ClampedMulFastAsmOp { + static const bool is_supported = CheckedMulFastAsmOp<T, U>::is_supported; + + template <typename V> + __attribute__((always_inline)) static V Do(T x, U y) { + // Use the CheckedMulFastAsmOp for full-width 32-bit values, because + // it's fewer instructions than promoting and then saturating. + if (!IsIntegerArithmeticSafe<int32_t, T, U>::value && + !IsIntegerArithmeticSafe<uint32_t, T, U>::value) { + V result; + if (CheckedMulFastAsmOp<T, U>::Do(x, y, &result)) + return result; + return CommonMaxOrMin<V>(IsValueNegative(x) ^ IsValueNegative(y)); + } + + assert((FastIntegerArithmeticPromotion<T, U>::is_contained)); + using Promotion = typename FastIntegerArithmeticPromotion<T, U>::type; + return saturated_cast<V>(static_cast<Promotion>(x) * + static_cast<Promotion>(y)); + } +}; + +} // namespace internal +} // namespace base + +#endif // BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ diff --git a/gn/build/gen.py b/gn/build/gen.py index d6f6013d798..13c09c9a270 100755 --- a/gn/build/gen.py +++ b/gn/build/gen.py @@ -307,7 +307,7 @@ def WriteGNNinja(path, platform, host, options): ld = os.environ.get('LD', 'g++') ar = os.environ.get('AR', 'ar') else: - cxx = os.environ.get('CXX', 'clang++') + cxx = os.environ.get('CXX', 'c++') ld = cxx ar = os.environ.get('AR', 'ar') @@ -387,21 +387,17 @@ def WriteGNNinja(path, platform, host, options): if not options.no_static_libstdcpp: ldflags.append('-static-libstdc++') - if platform.is_mingw() or platform.is_msys(): - cflags.remove('-std=c++17') - cflags.extend([ - '-Wno-deprecated-copy', - '-Wno-implicit-fallthrough', - '-Wno-redundant-move', - '-Wno-unused-variable', - '-Wno-format', # Use of %llx, which is supported by _UCRT, false positive - '-Wno-strict-aliasing', # Dereferencing punned pointer - '-Wno-cast-function-type', # Casting FARPROC to RegDeleteKeyExPtr - '-std=gnu++17', - ]) - else: - # This is needed by libc++. - libs.append('-ldl') + cflags.remove('-std=c++17') + cflags.extend([ + '-Wno-deprecated-copy', + '-Wno-implicit-fallthrough', + '-Wno-redundant-move', + '-Wno-unused-variable', + '-Wno-format', # Use of %llx, which is supported by _UCRT, false positive + '-Wno-strict-aliasing', # Dereferencing punned pointer + '-Wno-cast-function-type', # Casting FARPROC to RegDeleteKeyExPtr + '-std=gnu++17', + ]) elif platform.is_darwin(): min_mac_version_flag = '-mmacosx-version-min=10.9' cflags.append(min_mac_version_flag) @@ -465,7 +461,11 @@ def WriteGNNinja(path, platform, host, options): '/D_HAS_EXCEPTIONS=0', ]) - ldflags.extend(['/DEBUG', '/MACHINE:x64']) + target_arch = windows_target_build_arch() + if target_arch == 'x64': + ldflags.extend(['/MACHINE:x64']) + else: + ldflags.extend(['/MACHINE:x86']) static_libraries = { 'base': {'sources': [ @@ -811,6 +811,12 @@ def WriteGNNinja(path, platform, host, options): platform, host, options, cflags, ldflags, libflags, include_dirs, libs) +def windows_target_build_arch(): + target_arch = os.environ.get('Platform') + if target_arch in ['x64', 'x86']: return target_arch + + if platform.machine().lower() in ['x86_64', 'amd64']: return 'x64' + return 'x86' if __name__ == '__main__': sys.exit(main(sys.argv[1:])) |