diff options
Diffstat (limited to 'sys-devel/clang/files/4.0.1/0001-Frontend-Correct-values-of-ATOMIC_-_LOCK_FREE-to-mat.patch')
| -rw-r--r-- | sys-devel/clang/files/4.0.1/0001-Frontend-Correct-values-of-ATOMIC_-_LOCK_FREE-to-mat.patch | 87 |
1 files changed, 87 insertions, 0 deletions
diff --git a/sys-devel/clang/files/4.0.1/0001-Frontend-Correct-values-of-ATOMIC_-_LOCK_FREE-to-mat.patch b/sys-devel/clang/files/4.0.1/0001-Frontend-Correct-values-of-ATOMIC_-_LOCK_FREE-to-mat.patch new file mode 100644 index 000000000000..f52d445eb05b --- /dev/null +++ b/sys-devel/clang/files/4.0.1/0001-Frontend-Correct-values-of-ATOMIC_-_LOCK_FREE-to-mat.patch @@ -0,0 +1,87 @@ +From f1ea62e93cba334828c427146cc2ca7718a9ffb3 Mon Sep 17 00:00:00 2001 +From: Michal Gorny <mgorny@gentoo.org> +Date: Mon, 9 Jan 2017 20:54:20 +0000 +Subject: [PATCH] [Frontend] Correct values of ATOMIC_*_LOCK_FREE to match + builtin + +Correct the logic used to set ATOMIC_*_LOCK_FREE preprocessor macros not +to rely on the ABI alignment of types. Instead, just assume all those +types are aligned correctly by default since clang uses safe alignment +for _Atomic types even if the underlying types are aligned to a lower +boundary by default. + +For example, the 'long long' and 'double' types on x86 are aligned to +32-bit boundary by default. However, '_Atomic long long' and '_Atomic +double' are aligned to 64-bit boundary, therefore satisfying +the requirements of lock-free atomic operations. + +This fixes PR #19355 by correcting the value of +__GCC_ATOMIC_LLONG_LOCK_FREE on x86, and therefore also fixing +the assumption made in libc++ tests. This also fixes PR #30581 by +applying a consistent logic between the functions used to implement +both interfaces. + +Differential Revision: https://reviews.llvm.org/D28213 + +git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@291477 91177308-0d34-0410-b5e6-96231b3b80d8 +--- + lib/Frontend/InitPreprocessor.cpp | 10 ++++------ + test/Sema/atomic-ops.c | 4 ---- + 2 files changed, 4 insertions(+), 10 deletions(-) + +diff --git a/lib/Frontend/InitPreprocessor.cpp b/lib/Frontend/InitPreprocessor.cpp +index 17603ada11..4502c92499 100644 +--- a/lib/Frontend/InitPreprocessor.cpp ++++ b/lib/Frontend/InitPreprocessor.cpp +@@ -286,12 +286,12 @@ static void DefineFastIntType(unsigned TypeWidth, bool IsSigned, + + /// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with + /// the specified properties. +-static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign, +- unsigned InlineWidth) { ++static const char *getLockFreeValue(unsigned TypeWidth, unsigned InlineWidth) { + // Fully-aligned, power-of-2 sizes no larger than the inline + // width will be inlined as lock-free operations. +- if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 && +- TypeWidth <= InlineWidth) ++ // Note: we do not need to check alignment since _Atomic(T) is always ++ // appropriately-aligned in clang. ++ if ((TypeWidth & (TypeWidth - 1)) == 0 && TypeWidth <= InlineWidth) + return "2"; // "always lock free" + // We cannot be certain what operations the lib calls might be + // able to implement as lock-free on future processors. +@@ -881,7 +881,6 @@ static void InitializePredefinedMacros(const TargetInfo &TI, + #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \ + Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \ + getLockFreeValue(TI.get##Type##Width(), \ +- TI.get##Type##Align(), \ + InlineWidthBits)); + DEFINE_LOCK_FREE_MACRO(BOOL, Bool); + DEFINE_LOCK_FREE_MACRO(CHAR, Char); +@@ -894,7 +893,6 @@ static void InitializePredefinedMacros(const TargetInfo &TI, + DEFINE_LOCK_FREE_MACRO(LLONG, LongLong); + Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE", + getLockFreeValue(TI.getPointerWidth(0), +- TI.getPointerAlign(0), + InlineWidthBits)); + #undef DEFINE_LOCK_FREE_MACRO + } +diff --git a/test/Sema/atomic-ops.c b/test/Sema/atomic-ops.c +index 8ebf3eaed4..d3ebdf67db 100644 +--- a/test/Sema/atomic-ops.c ++++ b/test/Sema/atomic-ops.c +@@ -14,11 +14,7 @@ _Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, ""); + _Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, ""); + _Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, ""); + _Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, ""); +-#ifdef __i386__ +-_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 1, ""); +-#else + _Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 2, ""); +-#endif + _Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, ""); + + _Static_assert(__c11_atomic_is_lock_free(1), ""); +-- +2.12.0 + |