[SystemZ] Optimize bcmp calls (PR47420)

[xbolva00]

Summary

Solves https://bugs.llvm.org/show_bug.cgi?id=47420

[jonpa]

Maybe also have the test case from my original patch which transforms a memcmp to a bcmp...?

If it is really ok to pass bcmp to visitMemCmpCall(), I think a comment on that specifies this would be nice, both for visitMemCmpCall() and EmitTargetCodeForMemcmp().

[xbolva00]

In D87988#2287804, @jonpa wrote:

Maybe also have the test case from my original patch which transforms a memcmp to a bcmp...?

If it is really ok to pass bcmp to visitMemCmpCall(), I think a comment on that specifies this would be nice, both for visitMemCmpCall() and EmitTargetCodeForMemcmp().

X86 emits same inline codegen for cmp and memcmp:
https://godbolt.org/z/W4dE1z

Right, I will adjust to make it more clear.

[xbolva00]

Maybe also have the test case from my original patch which transforms a memcmp to a bcmp...?

There are already many test cases for memcmp->bcmp transform so I dont see a need for it.

[jonpa]

Right, I will adjust to make it more clear.

I still think it would be nice to mention this in SelectionDAGTargetInfo.h (in the comment for EmitTargetCodeForMemcmp()) as well...?

[xbolva00]

In D87988#2289487, @jonpa wrote:

Right, I will adjust to make it more clear.

I still think it would be nice to mention this in SelectionDAGTargetInfo.h (in the comment for EmitTargetCodeForMemcmp()) as well...?

Added.

[jonpa]

This looks ok to me, but let's wait for @uweigand as well.

[uweigand]

LGTM as well.

llvm/include/llvm/CodeGen/SelectionDAGTargetInfo.h

public:
   virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl,
                                           SDValue Chain, SDValue Op1,
                                           SDValue Op2, SDValue Op3,
                                           Align Alignment, bool isVolatile,
                                           MachinePointerInfo DstPtrInfo) const {
     return SDValue();
   }
 
-  /// Emit target-specific code that performs a memcmp, in cases where that is
+  /// Emit target-specific code that performs a memcmp/bcmp, in cases where that is
   /// faster than a libcall. The first returned SDValue is the result of the
   /// memcmp and the second is the chain. Both SDValues can be null if a normal
   /// libcall should be used.
   virtual std::pair<SDValue, SDValue>
   EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
                           SDValue Op1, SDValue Op2, SDValue Op3,
                           MachinePointerInfo Op1PtrInfo,
                           MachinePointerInfo Op2PtrInfo) const {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

private:
   void visitMaskedStore(const CallInst &I, bool IsCompressing = false);
   void visitMaskedGather(const CallInst &I);
   void visitMaskedScatter(const CallInst &I);
   void visitAtomicCmpXchg(const AtomicCmpXchgInst &I);
   void visitAtomicRMW(const AtomicRMWInst &I);
   void visitFence(const FenceInst &I);
   void visitPHI(const PHINode &I);
   void visitCall(const CallInst &I);
-  bool visitMemCmpCall(const CallInst &I);
+  bool visitMemCmpBCmpCall(const CallInst &I);
   bool visitMemPCpyCall(const CallInst &I);
   bool visitMemChrCall(const CallInst &I);
   bool visitStrCpyCall(const CallInst &I, bool isStpcpy);
   bool visitStrCmpCall(const CallInst &I);
   bool visitStrLenCall(const CallInst &I);
   bool visitStrNLenCall(const CallInst &I);
   bool visitUnaryFloatCall(const CallInst &I, unsigned Opcode);
   bool visitBinaryFloatCall(const CallInst &I, unsigned Opcode);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

EVT VT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
                                                     I.getType(), true);
   if (IsSigned)
     Value = DAG.getSExtOrTrunc(Value, getCurSDLoc(), VT);
   else
     Value = DAG.getZExtOrTrunc(Value, getCurSDLoc(), VT);
   setValue(&I, Value);
 }
 
-/// See if we can lower a memcmp call into an optimized form. If so, return
+/// See if we can lower a memcmp/bcmp call into an optimized form. If so, return
 /// true and lower it. Otherwise return false, and it will be lowered like a
 /// normal call.
 /// The caller already checked that \p I calls the appropriate LibFunc with a
 /// correct prototype.
-bool SelectionDAGBuilder::visitMemCmpCall(const CallInst &I) {
+bool SelectionDAGBuilder::visitMemCmpBCmpCall(const CallInst &I) {
   const Value *LHS = I.getArgOperand(0), *RHS = I.getArgOperand(1);
   const Value *Size = I.getArgOperand(2);
   const ConstantInt *CSize = dyn_cast<ConstantInt>(Size);
   if (CSize && CSize->getZExtValue() == 0) {
     EVT CallVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
                                                           I.getType(), true);
     setValue(&I, DAG.getConstant(0, getCurSDLoc(), CallVT));
     return true;
if (Function *F = I.getCalledFunction()) {
     // can't be a library call.  Don't do the check if marked as nobuiltin for
     // some reason or the call site requires strict floating point semantics.
     LibFunc Func;
     if (!I.isNoBuiltin() && !I.isStrictFP() && !F->hasLocalLinkage() &&
         F->hasName() && LibInfo->getLibFunc(*F, Func) &&
         LibInfo->hasOptimizedCodeGen(Func)) {
       switch (Func) {
       default: break;
+      case LibFunc_bcmp:
+        if (visitMemCmpBCmpCall(I))
+          return;
+        break;
       case LibFunc_copysign:
       case LibFunc_copysignf:
       case LibFunc_copysignl:
         // We already checked this call's prototype; verify it doesn't modify
         // errno.
         if (I.onlyReadsMemory()) {
           SDValue LHS = getValue(I.getArgOperand(0));
           SDValue RHS = getValue(I.getArgOperand(1));
if (!I.isNoBuiltin() && !I.isStrictFP() && !F->hasLocalLinkage() &&
         break;
       case LibFunc_exp2:
       case LibFunc_exp2f:
       case LibFunc_exp2l:
         if (visitUnaryFloatCall(I, ISD::FEXP2))
           return;
         break;
       case LibFunc_memcmp:
-        if (visitMemCmpCall(I))
+        if (visitMemCmpBCmpCall(I))
           return;
         break;
       case LibFunc_mempcpy:
         if (visitMemPCpyCall(I))
           return;
         break;
       case LibFunc_memchr:
         if (visitMemChrCall(I))

llvm/test/CodeGen/SystemZ/bcmp.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
+
+declare signext i32 @bcmp(i8* nocapture, i8* nocapture, i64)
+
+define zeroext i1 @test_bcmp_eq_0(i8* nocapture readonly %A, i8* nocapture readonly %B) {
+; CHECK-LABEL: test_bcmp_eq_0:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    clc 0(2,%r3), 0(%r2)
+; CHECK-NEXT:    ipm %r0
+; CHECK-NEXT:    afi %r0, -268435456
+; CHECK-NEXT:    risbg %r2, %r0, 63, 191, 33
+; CHECK-NEXT:    br %r14
+  %c = tail call signext i32 @bcmp(i8* %A, i8* %B, i64 2)
+  %res  = icmp eq i32 %c, 0
+  ret i1 %res
+}
+
+define signext i32 @test_bcmp(i8* nocapture readonly %A, i8* nocapture readonly %B) {
+; CHECK-LABEL: test_bcmp:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    clc 0(2,%r3), 0(%r2)
+; CHECK-NEXT:    ipm %r0
+; CHECK-NEXT:    sllg %r0, %r0, 34
+; CHECK-NEXT:    srag %r2, %r0, 62
+; CHECK-NEXT:    br %r14
+  %res = tail call signext i32 @bcmp(i8* %A, i8* %B, i64 2)
+  ret i32 %res
+}