[PowerPC] Allow llvm.ppc.cfence to accept pointer types

[lkail]

Summary

In the context of atomic load, integer, pointer and float point types are allowed, thus we should allow llvm.ppc.cfence to accept any type mentioned.

Fixes https://github.com/llvm/llvm-project/issues/55983.

[lkail]

Rebased to where float tests are added.

[lkail]

Added original reduced case from @nemanjai .

[vchuravy]

This looks great. Is this safe to backport to LLVM13 or LLVM14?

[lkail]

In D127554#3578625, @vchuravy wrote:

This looks great. Is this safe to backport to LLVM13 or LLVM14?

Should be safe to LLVM-14, if there is 14.0.6. And noted that, when it's landed, it can be cherry-picked cleanly to LLVM-14 due to the floating point tests added.

[lkail]

Avoid using undef in tests.

[shchenz]

LGTM with one nit.

Thanks for fixing this.

llvm/include/llvm/IR/IntrinsicsPowerPC.td

1500

Maybe we need to add assertion in PPCTargetLowering::emitTrailingFence to explicitly check when we generate ppc_cfence, we are not generating fence for any undesired types? After this change, any type is accepted, for example fp128 or vector types.

IR level verifier can be disabled and the assertion when lower this intrinsic in ISEL is a little late IMO.

[vchuravy]

Backported this for Julia to 13 & 14 and this fixes our build!

[lkail]

Rebased.

[thakis]

Looks like this breaks tests on non-linux: http://45.33.8.238/macm1/37997/step_11.txt , http://45.33.8.238/win/60800/step_11.txt

Please take a look and revert for now if it takes a while to fix.

[lkail]

In D127554#3606867, @thakis wrote:

Looks like this breaks tests on non-linux: http://45.33.8.238/macm1/37997/step_11.txt , http://45.33.8.238/win/60800/step_11.txt

Please take a look and revert for now if it takes a while to fix.

Hi, I've pushed a fix https://github.com/llvm/llvm-project/commit/106657df4cb36b325056efc57c91340d3d85236d. Should be green in next build.

[nemanjai]

llvm/test/CodeGen/PowerPC/cfence-double.ll

7–8

Is the plan here to do something better than assert? Perhaps emit a fatal error? What happens on non-assert builds on these tests now? Something terrible?

[lkail]

llvm/test/CodeGen/PowerPC/cfence-double.ll

7–8

I've posted https://reviews.llvm.org/D127563 to fix cfence on floating point types on PowerPC side. Alternative solution would be https://reviews.llvm.org/D127609(since the solution on PowerPC side assumes the floating point value is converted from integer value). For non-assert builds, the test causes an ICE.

[lkail]

llvm/test/CodeGen/PowerPC/cfence-double.ll

7–8

The ICE is something like

LLVM ERROR: Cannot select: 0x6534da8: i64 = any_extend 0x6534b38
  0x6534b38: f64 = bitcast 0x6534ad0
    0x6534ad0: i64,ch = AtomicLoad<(load monotonic (s64) from %ir.0)> 0x64befe8, 0x6534a68
      0x6534a68: i64,ch = CopyFromReg 0x64befe8, Register:i64 %0
        0x6534a00: i64 = Register %0

llvm/include/llvm/IR/IntrinsicsPowerPC.td

 def int_ppc_tresume : ClangBuiltin<"__builtin_tresume">,
       Intrinsic<[llvm_i32_ty], [], []>;
 def int_ppc_tsuspend : ClangBuiltin<"__builtin_tsuspend">,
       Intrinsic<[llvm_i32_ty], [], []>;
 
 def int_ppc_ttest : ClangBuiltin<"__builtin_ttest">,
       Intrinsic<[llvm_i64_ty], [], []>;
 
-def int_ppc_cfence : Intrinsic<[], [llvm_anyint_ty], []>;
+// We currently use llvm.ppc.cfence in the context of atomic load which
+// in LLVM IR requires its type to be one of integer, pointer and
+// float point type. So llvm_any_ty here refers to type mentioned above.
+// Backend is supposed to lower these types to appropriate MVTs.
+def int_ppc_cfence : Intrinsic<[], [llvm_any_ty], []>;
 
 // PowerPC set FPSCR Intrinsic Definitions.
 def int_ppc_setrnd : ClangBuiltin<"__builtin_setrnd">,
       Intrinsic<[llvm_double_ty], [llvm_i32_ty], []>;
 }
 
 let TargetPrefix = "ppc" in {
   def int_ppc_vsx_assemble_pair :

llvm/test/CodeGen/PowerPC/cfence-double.ll

+; REQUIRES: asserts
 ; RUN: not --crash llc -opaque-pointers -mtriple=powerpc64le-unknown-unknown \
 ; RUN:   < %s 2>&1 | FileCheck %s
 ; RUN: not --crash llc -opaque-pointers -mtriple=powerpc64-unknown-unknown \
 ; RUN:   < %s 2>&1 | FileCheck %s
 
-; CHECK: Intrinsic has incorrect argument type!
-; CHECK: ptr @llvm.ppc.cfence.f64
+; CHECK: Assertion `VT.isInteger() && Operand.getValueType().isInteger() && "Invalid ANY_EXTEND!"' failed
+
 define double @foo(double* %dp) {
 entry:
   %0 = load atomic double, double* %dp acquire, align 8
   ret double %0
 }

llvm/test/CodeGen/PowerPC/cfence-float.ll

+; REQUIRES: asserts
 ; RUN: not --crash llc -opaque-pointers -mtriple=powerpc64le-unknown-unknown \
 ; RUN:   < %s 2>&1 | FileCheck %s
 ; RUN: not --crash llc -opaque-pointers -mtriple=powerpc64-unknown-unknown \
 ; RUN:   < %s 2>&1 | FileCheck %s
 
-; CHECK: Intrinsic has incorrect argument type!
-; CHECK: ptr @llvm.ppc.cfence.f32
+; CHECK: Assertion `VT.isInteger() && Operand.getValueType().isInteger() && "Invalid ANY_EXTEND!"' failed
+
 define float @bar(float* %fp) {
 entry:
   %0 = load atomic float, float* %fp acquire, align 4
   ret float %0
 }

llvm/test/CodeGen/PowerPC/issue55983.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -opaque-pointers -mtriple=powerpc64le-unknown-unknown < %s | FileCheck --check-prefix=CHECK-LE %s
+; RUN: llc -opaque-pointers -mtriple=powerpc64-unknown-unknown < %s | FileCheck %s
+
+define ptr @foo(ptr %p) {
+; CHECK-LE-LABEL: foo:
+; CHECK-LE:       # %bb.0: # %entry
+; CHECK-LE-NEXT:    ld 3, 0(3)
+; CHECK-LE-NEXT:    cmpd 7, 3, 3
+; CHECK-LE-NEXT:    bne- 7, .+4
+; CHECK-LE-NEXT:    isync
+; CHECK-LE-NEXT:    blr
+;
+; CHECK-LABEL: foo:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    ld 3, 0(3)
+; CHECK-NEXT:    cmpd 7, 3, 3
+; CHECK-NEXT:    bne- 7, .+4
+; CHECK-NEXT:    isync
+; CHECK-NEXT:    blr
+entry:
+  %0 = load atomic ptr, ptr %p acquire, align 8
+  ret ptr %0
+}
+
+define void @foobar({} addrspace(10)* addrspace(11)* %p) {
+; CHECK-LE-LABEL: foobar:
+; CHECK-LE:       # %bb.0: # %entry
+; CHECK-LE-NEXT:    ld 3, 0(3)
+; CHECK-LE-NEXT:    cmpd 7, 3, 3
+; CHECK-LE-NEXT:    bne- 7, .+4
+; CHECK-LE-NEXT:    isync
+;
+; CHECK-LABEL: foobar:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    ld 3, 0(3)
+; CHECK-NEXT:    cmpd 7, 3, 3
+; CHECK-NEXT:    bne- 7, .+4
+; CHECK-NEXT:    isync
+entry:
+  %0 = load atomic {} addrspace(10)*, {} addrspace(10)* addrspace(11)* %p acquire, align 8
+  unreachable
+}

llvm/test/Transforms/AtomicExpand/PowerPC/cfence-double.ll

-; RUN: not --crash opt -S -atomic-expand -mtriple=powerpc64le-unknown-unknown \
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -atomic-expand -mtriple=powerpc64le-unknown-unknown \
 ; RUN:   -opaque-pointers < %s 2>&1 | FileCheck %s
-; RUN: not --crash opt -S -atomic-expand -mtriple=powerpc64-unknown-unknown \
+; RUN: opt -S -atomic-expand -mtriple=powerpc64-unknown-unknown \
 ; RUN:   -opaque-pointers < %s 2>&1 | FileCheck %s
 
-; CHECK: Intrinsic has incorrect argument type!
-; CHECK: ptr @llvm.ppc.cfence.f64
 define double @foo(double* %dp) {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load atomic i64, ptr [[DP:%.*]] monotonic, align 8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i64 [[TMP0]] to double
+; CHECK-NEXT:    call void @llvm.ppc.cfence.f64(double [[TMP1]])
+; CHECK-NEXT:    ret double [[TMP1]]
+;
 entry:
   %0 = load atomic double, double* %dp acquire, align 8
   ret double %0
 }

llvm/test/Transforms/AtomicExpand/PowerPC/cfence-float.ll

-; RUN: not --crash opt -S -atomic-expand -mtriple=powerpc64le-unknown-unknown \
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -atomic-expand -mtriple=powerpc64le-unknown-unknown \
 ; RUN:   -opaque-pointers < %s 2>&1 | FileCheck %s
-; RUN: not --crash opt -S -atomic-expand -mtriple=powerpc64-unknown-unknown \
+; RUN: opt -S -atomic-expand -mtriple=powerpc64-unknown-unknown \
 ; RUN:   -opaque-pointers < %s 2>&1 | FileCheck %s
 
-; CHECK: Intrinsic has incorrect argument type!
-; CHECK: ptr @llvm.ppc.cfence.f32
 define float @bar(float* %fp) {
+; CHECK-LABEL: @bar(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load atomic i32, ptr [[FP:%.*]] monotonic, align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[TMP0]] to float
+; CHECK-NEXT:    call void @llvm.ppc.cfence.f32(float [[TMP1]])
+; CHECK-NEXT:    ret float [[TMP1]]
+;
 entry:
   %0 = load atomic float, float* %fp acquire, align 4
   ret float %0
 }

llvm/test/Transforms/AtomicExpand/PowerPC/issue55983.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -opaque-pointers -atomic-expand -S -mtriple=powerpc64le-unknown-unknown \
+; RUN:   %s | FileCheck %s
+; RUN: opt -opaque-pointers -atomic-expand -S -mtriple=powerpc64-unknown-unknown \
+; RUN:   %s | FileCheck %s
+
+define ptr @foo(ptr %p) {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load atomic ptr, ptr [[P:%.*]] monotonic, align 8
+; CHECK-NEXT:    call void @llvm.ppc.cfence.p0(ptr [[TMP0]])
+; CHECK-NEXT:    ret ptr [[TMP0]]
+;
+entry:
+  %0 = load atomic ptr, ptr %p acquire, align 8
+  ret ptr %0
+}
+
+define void @foobar({} addrspace(10)* addrspace(11)* %p) {
+; CHECK-LABEL: @foobar(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load atomic ptr addrspace(10), ptr addrspace(11) [[P:%.*]] monotonic, align 8
+; CHECK-NEXT:    call void @llvm.ppc.cfence.p10(ptr addrspace(10) [[TMP0]])
+; CHECK-NEXT:    unreachable
+;
+entry:
+  %0 = load atomic {} addrspace(10)*, {} addrspace(10)* addrspace(11)* %p acquire, align 8
+  unreachable
+}