[CGP, PowerPC] try to constant fold before creating loads for memcmp expansion

[spatel]

Summary

I think this is the last step needed to avoid regressions for x86 before we flip the switch to allow expansion of the smallest set of memcpy() via CGP. The DAG version checks for constant strings, so we need to do that here too.

FWIW, the 2 constant test is not handled by LibCallSimplifier::optimizeMemCmp() because that code is limited to 8-bit constant arrays. LibCallSimplifier will also fail to optimize some 1 constant tests because its alignment requirements are too strict (shouldn't require alignment for a constant operand).

[nemanjai]

lib/CodeGen/CodeGenPrepare.cpp

1855 ↗

(On Diff #102094)

I think this would read nicer if we just had the dyn_cast<Constant> and then just initialized LoadSrc1 with a ternary operator.
But that's just a thought.

[spatel]

lib/CodeGen/CodeGenPrepare.cpp

1855 ↗

(On Diff #102094)

That would mean that if the pointer is a constant, then ConstantFoldLoadFromConstPtr always succeeds. But I don't think we can make that assumption.

[nemanjai]

lib/CodeGen/CodeGenPrepare.cpp

1855 ↗

(On Diff #102094)

Ah, OK fair enough. I didn't realize that.

[spatel]

Ping.

[echristo]

Looks OK to me.

[spatel]

Thanks, Eric!

For those following the progress for x86, I enabled the smallest sizes with:
https://reviews.llvm.org/rL305802

But now I see 2 more missed IR optimizations, and I'm again wondering: is there a reason for this expansion to occur in CGP rather than its own pass which could be before the final simplifycfg/instcombine in a normal opt pipeline?

Looking at the general 4-byte memcmp() expansion as an example:

define i32 @cmp4(i8* %x, i8* %y) {
loadbb:
  %0 = bitcast i8* %x to i32*
  %1 = bitcast i8* %y to i32*
  %2 = load i32, i32* %0
  %3 = load i32, i32* %1
  %4 = call i32 @llvm.bswap.i32(i32 %2)
  %5 = call i32 @llvm.bswap.i32(i32 %3)
  %6 = zext i32 %4 to i64   <--- the extends are unnecessary
  %7 = zext i32 %5 to i64
  %8 = sub i64 %6, %7       <--- causing a too-wide sub
  %9 = icmp ne i64 %8, 0    <--- and a too-wide cmp
  br i1 %9, label %res_block, label %endblock

res_block:                     
  %10 = icmp ult i64 %6, %7
  %11 = select i1 %10, i32 -1, i32 1
  br label %endblock

endblock:  <--- this could have been simplified to a select     
  %phi.res = phi i32 [ 0, %loadbb ], [ %11, %res_block ]
  ret i32 %phi.res
}

Sure enough, if we run -simplifycfg and -instcombine, we get:

%0 = bitcast i8* %x to i32*
%1 = bitcast i8* %y to i32*
%2 = load i32, i32* %0, align 4
%3 = load i32, i32* %1, align 4
%4 = call i32 @llvm.bswap.i32(i32 %2)
%5 = call i32 @llvm.bswap.i32(i32 %3)
%6 = icmp ne i32 %4, %5
%7 = icmp ult i32 %4, %5
%8 = select i1 %7, i32 -1, i32 1
%phi.res = select i1 %6, i32 %8, i32 0
ret i32 %phi.res

llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp

for (unsigned i = 0; i < NumLoads; ++i) {
     // Get the base address using the GEPIndex.
     if (GEPIndex != 0) {
       Source1 = Builder.CreateGEP(LoadSizeType, Source1,
                                   ConstantInt::get(LoadSizeType, GEPIndex));
       Source2 = Builder.CreateGEP(LoadSizeType, Source2,
                                   ConstantInt::get(LoadSizeType, GEPIndex));
     }
 
-    // Load LoadSizeType from the base address.
-    Value *LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
-    Value *LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);
+    // Get a constant or load a value for each source address.
+    Value *LoadSrc1 = nullptr;
+    if (auto *Source1C = dyn_cast<Constant>(Source1))
+      LoadSrc1 = ConstantFoldLoadFromConstPtr(Source1C, LoadSizeType, DL);
+    if (!LoadSrc1)
+      LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
+
+    Value *LoadSrc2 = nullptr;
+    if (auto *Source2C = dyn_cast<Constant>(Source2))
+      LoadSrc2 = ConstantFoldLoadFromConstPtr(Source2C, LoadSizeType, DL);
+    if (!LoadSrc2)
+      LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);
+
     if (NumLoads != 1) {
       if (LoadSizeType != MaxLoadType) {
         LoadSrc1 = Builder.CreateZExtOrTrunc(LoadSrc1, MaxLoadType);
         LoadSrc2 = Builder.CreateZExtOrTrunc(LoadSrc2, MaxLoadType);
       }
       // If we have multiple loads per block, we need to generate a composite
       // comparison using xor+or.
       Diff = Builder.CreateXor(LoadSrc1, LoadSrc2);

llvm/trunk/test/CodeGen/PowerPC/memCmpUsedInZeroEqualityComparison.ll

; CHECK-NEXT:    b .LBB4_3
   %call.lobit = lshr i32 %call, 31
   %call.lobit.not = xor i32 %call.lobit, 1
   ret i32 %call.lobit.not
 }
 
 ; Validate with memcmp()?:
 define signext i32 @equalityFoldTwoConstants() {
 ; CHECK-LABEL: equalityFoldTwoConstants:
-; CHECK:       # BB#0: # %loadbb
-; CHECK-NEXT:    addis 3, 2, .LzeroEqualityTest04.buffer1@toc@ha
-; CHECK-NEXT:    addis 4, 2, .LzeroEqualityTest04.buffer2@toc@ha
-; CHECK-NEXT:    ld 3, .LzeroEqualityTest04.buffer1@toc@l(3)
-; CHECK-NEXT:    ld 4, .LzeroEqualityTest04.buffer2@toc@l(4)
-; CHECK-NEXT:    cmpld 3, 4
-; CHECK-NEXT:    bne 0, .LBB5_2
-; CHECK-NEXT:  # BB#1: # %loadbb1
-; CHECK-NEXT:    addis 3, 2, .LzeroEqualityTest04.buffer1@toc@ha+8
-; CHECK-NEXT:    addis 4, 2, .LzeroEqualityTest04.buffer2@toc@ha+8
-; CHECK-NEXT:    ld 3, .LzeroEqualityTest04.buffer1@toc@l+8(3)
-; CHECK-NEXT:    ld 4, .LzeroEqualityTest04.buffer2@toc@l+8(4)
-; CHECK-NEXT:    cmpld 3, 4
-; CHECK-NEXT:    li 3, 0
-; CHECK-NEXT:    beq 0, .LBB5_3
-; CHECK-NEXT:  .LBB5_2: # %res_block
+; CHECK:       # BB#0: # %endblock
 ; CHECK-NEXT:    li 3, 1
-; CHECK-NEXT:  .LBB5_3: # %endblock
-; CHECK-NEXT:    cntlzw 3, 3
-; CHECK-NEXT:    srwi 3, 3, 5
 ; CHECK-NEXT:    blr
   %call = tail call signext i32 @memcmp(i8* bitcast ([15 x i32]* @zeroEqualityTest04.buffer1 to i8*), i8* bitcast ([15 x i32]* @zeroEqualityTest04.buffer2 to i8*), i64 16)
   %not.tobool = icmp eq i32 %call, 0
   %cond = zext i1 %not.tobool to i32
   ret i32 %cond
 }
 
 define signext i32 @equalityFoldOneConstant(i8* %X) {
 ; CHECK-LABEL: equalityFoldOneConstant:
 ; CHECK:       # BB#0: # %loadbb
-; CHECK-NEXT:    addis 4, 2, .LzeroEqualityTest04.buffer1@toc@ha
+; CHECK-NEXT:    li 4, 1
 ; CHECK-NEXT:    ld 5, 0(3)
-; CHECK-NEXT:    ld 4, .LzeroEqualityTest04.buffer1@toc@l(4)
-; CHECK-NEXT:    cmpld 4, 5
+; CHECK-NEXT:    sldi 4, 4, 32
+; CHECK-NEXT:    cmpld 5, 4
 ; CHECK-NEXT:    bne 0, .LBB6_2
 ; CHECK-NEXT:  # BB#1: # %loadbb1
-; CHECK-NEXT:    addis 4, 2, .LzeroEqualityTest04.buffer1@toc@ha+8
+; CHECK-NEXT:    li 4, 3
 ; CHECK-NEXT:    ld 3, 8(3)
-; CHECK-NEXT:    ld 4, .LzeroEqualityTest04.buffer1@toc@l+8(4)
-; CHECK-NEXT:    cmpld 4, 3
+; CHECK-NEXT:    sldi 4, 4, 32
+; CHECK-NEXT:    ori 4, 4, 2
+; CHECK-NEXT:    cmpld 3, 4
 ; CHECK-NEXT:    li 3, 0
 ; CHECK-NEXT:    beq 0, .LBB6_3
 ; CHECK-NEXT:  .LBB6_2: # %res_block
 ; CHECK-NEXT:    li 3, 1
 ; CHECK-NEXT:  .LBB6_3: # %endblock
 ; CHECK-NEXT:    cntlzw 3, 3
 ; CHECK-NEXT:    srwi 3, 3, 5
 ; CHECK-NEXT:    blr