git: 66ef1ce5b399 - stable/12 - r356104 | jhibbits | 2019-12-27 00:06:28 +0100 (Fri, 27 Dec 2019) | 25 lines

The branch stable/12 has been updated by dim:

URL: https://cgit.FreeBSD.org/src/commit/?id=66ef1ce5b3998bfd0cd7b1664f52a5f559eafde8

commit 66ef1ce5b3998bfd0cd7b1664f52a5f559eafde8
Author:     Dimitry Andric <dim@FreeBSD.org>
AuthorDate: 2020-08-06 19:11:24 +0000
Commit:     Dimitry Andric <dim@FreeBSD.org>
CommitDate: 2021-12-22 09:58:21 +0000

    r356104 | jhibbits | 2019-12-27 00:06:28 +0100 (Fri, 27 Dec 2019) | 25 lines
    
    [PowerPC] enable atomic.c in compiler_rt and do not check and forces
    lock/lock_free decisions in compiled time
    
    Summary:
    Enables atomic.c in compiler_rt and forces clang to not emit a call for runtime
    decision about lock/lock_free.  At compiling time, if clang can't decide if
    atomic operation can be lock free, it emits calls to external functions  like
    `__atomic_is_lock_free`, `__c11_atomic_is_lock_free` and
    `__atomic_always_lock_free`, postponing decision to a runtime check.  According
    to LLVM code documentation, the mechanism exists due to differences between
    x86_64 processors that can't be decided at runtime.
    
    On PowerPC and PowerPCSPE (32 bits), we already know in advance it can't be lock
    free, so we force the decision at compile time and avoid having to implement it
    in an external library.
    
    This patch was made after 32 bit users testing the PowePC32 bit ISO reported
    llvm could not be compiled with in-base llvm due to `__atomic_load8` not
    implemented.
    
    Submitted by:   alfredo.junior_eldorado.org.br
    Reviewed by:    jhibbits, dim
    
    Differential Revision:  https://reviews.freebsd.org/D22549
    
    (cherry picked from commit 0faeaeed40a4c42a778a088cbdad0bc54468eef4)
---
 contrib/llvm-project/clang/lib/AST/ExprConstant.cpp    |  7 +++++++
 contrib/llvm-project/compiler-rt/lib/builtins/atomic.c | 13 ++++++++++---
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/contrib/llvm-project/clang/lib/AST/ExprConstant.cpp b/contrib/llvm-project/clang/lib/AST/ExprConstant.cpp
index 41a4ae4b91c8..97d5d7bb2180 100644
--- a/contrib/llvm-project/clang/lib/AST/ExprConstant.cpp
+++ b/contrib/llvm-project/clang/lib/AST/ExprConstant.cpp
@@ -11529,6 +11529,13 @@ bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
       }
     }
 
+    // Avoid emiting call for runtime decision on PowerPC 32-bit
+    // The lock free possibilities on this platform are covered by the lines 
+    // above and we know in advance other cases require lock
+    if (Info.Ctx.getTargetInfo().getTriple().getArch() == llvm::Triple::ppc) {
+        return Success(0, E);
+    }
+
     return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
         Success(0, E) : Error(E);
   }
diff --git a/contrib/llvm-project/compiler-rt/lib/builtins/atomic.c b/contrib/llvm-project/compiler-rt/lib/builtins/atomic.c
index 8634a72e77d1..2a69101fbcee 100644
--- a/contrib/llvm-project/compiler-rt/lib/builtins/atomic.c
+++ b/contrib/llvm-project/compiler-rt/lib/builtins/atomic.c
@@ -120,13 +120,20 @@ static __inline Lock *lock_for_pointer(void *ptr) {
   return locks + (hash & SPINLOCK_MASK);
 }
 
-/// Macros for determining whether a size is lock free.  Clang can not yet
-/// codegen __atomic_is_lock_free(16), so for now we assume 16-byte values are
-/// not lock free.
+/// Macros for determining whether a size is lock free.
 #define IS_LOCK_FREE_1 __c11_atomic_is_lock_free(1)
 #define IS_LOCK_FREE_2 __c11_atomic_is_lock_free(2)
 #define IS_LOCK_FREE_4 __c11_atomic_is_lock_free(4)
+
+/// 32 bit PowerPC doesn't support 8-byte lock_free atomics
+#if !defined(__powerpc64__) && defined(__powerpc__)
+#define IS_LOCK_FREE_8 0
+#else
 #define IS_LOCK_FREE_8 __c11_atomic_is_lock_free(8)
+#endif
+
+/// Clang can not yet codegen __atomic_is_lock_free(16), so for now we assume
+/// 16-byte values are not lock free.
 #define IS_LOCK_FREE_16 0
 
 /// Macro that calls the compiler-generated lock-free versions of functions