Handle IntToPtr in isBytewiseValue

[vitalybuka]

Summary

This helps with more efficient use of memset for pattern initialization

From @pcc prototype for -ftrivial-auto-var-init=pattern optimizations

Binary size change on CTMark, (with -fuse-ld=lld -Wl,--icf=all, similar results with default linker options)

                   master           patch      diff
Os           8.238864e+05    8.238864e+05       0.0 
O3           1.054797e+06    1.054797e+06       0.0 
Os zero      8.292384e+05    8.292384e+05       0.0 
O3 zero      1.062626e+06    1.062626e+06       0.0 
Os pattern   8.579712e+05    8.338048e+05 -0.030299 
O3 pattern   1.090502e+06    1.067574e+06 -0.020481

Zero vs Pattern on master

               zero       pattern      diff
Os     8.292384e+05  8.579712e+05  0.036578 
O3     1.062626e+06  1.090502e+06  0.025124

Zero vs Pattern with the patch

               zero       pattern      diff
Os     8.292384e+05  8.338048e+05  0.003333 
O3     1.062626e+06  1.067574e+06  0.003193

Improved only for -m64. -m32 is not improved.

[eugenis]

LGTM

[vitalybuka]

llvm/lib/Analysis/ValueTracking.cpp

3222 ↗

(On Diff #207180)

@pcc BTW, your original patch just gave up on size mismatch
Something like:

if (auto *CE = dyn_cast<ConstantExpr>(C)) {
    if (CE->getOpcode() == Instruction::IntToPtr &&
        cast<IntegerType>(CE->getOperand(0)->getType())->getBitWidth() ==
            DL.getPointerSizeInBits(
                cast<PointerType>(CE->getType())->getAddressSpace())) {
      return isBytewiseValue(CE->getOperand(0), DL);
    }
    return nullptr;
  }

Both versions affect binary size about the same.

cfe/trunk/test/CodeGenCXX/auto-var-init.cpp

 // CHECK-NEXT:  call void @llvm.memcpy
 // CHECK-NEXT:  call void @{{.*}}used{{.*}}%custom)
 
 TEST_UNINIT(intptr4, int*[4]);
 // CHECK-LABEL:      @test_intptr4_uninit()
 // CHECK:            %uninit = alloca [4 x i32*], align
 // CHECK-NEXT:       call void @{{.*}}used{{.*}}%uninit)
 // PATTERN-O1-LABEL: @test_intptr4_uninit()
-// PATTERN-O1:       %1 = getelementptr inbounds [4 x i32*], [4 x i32*]* %uninit, i64 0, i64 0
-// PATTERN-O1-NEXT:  store i32* inttoptr (i64 -6148914691236517206 to i32*), i32** %1, align 16
-// PATTERN-O1-NEXT:  %2 = getelementptr inbounds [4 x i32*], [4 x i32*]* %uninit, i64 0, i64 1
-// PATTERN-O1-NEXT:  store i32* inttoptr (i64 -6148914691236517206 to i32*), i32** %2, align 8
-// PATTERN-O1-NEXT:  %3 = getelementptr inbounds [4 x i32*], [4 x i32*]* %uninit, i64 0, i64 2
-// PATTERN-O1-NEXT:  store i32* inttoptr (i64 -6148914691236517206 to i32*), i32** %3, align 16
-// PATTERN-O1-NEXT:  %4 = getelementptr inbounds [4 x i32*], [4 x i32*]* %uninit, i64 0, i64 3
-// PATTERN-O1-NEXT:  store i32* inttoptr (i64 -6148914691236517206 to i32*), i32** %4, align 8
+// PATTERN-O1:       %1 = bitcast [4 x i32*]* %uninit to i8*
+// PATTERN-O1-NEXT:  call void @llvm.memset.p0i8.i64(i8* nonnull align 16 %1, i8 -86, i64 32, i1 false)
 // ZERO-LABEL:       @test_intptr4_uninit()
 // ZERO:             call void @llvm.memset{{.*}}, i8 0,
 
 TEST_BRACES(intptr4, int*[4]);
 // CHECK-LABEL: @test_intptr4_braces()
 // CHECK:       %braces = alloca [4 x i32*], align [[ALIGN:[0-9]*]]
 // CHECK-NEXT:  bitcast
 // CHECK-NEXT:  call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 32, i1 false)

llvm/trunk/lib/Analysis/ValueTracking.cpp

if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
     if (CI->getBitWidth() % 8 == 0) {
       assert(CI->getBitWidth() > 8 && "8 bits should be handled above!");
       if (!CI->getValue().isSplat(8))
         return nullptr;
       return ConstantInt::get(Ctx, CI->getValue().trunc(8));
     }
   }
 
+  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
+    if (CE->getOpcode() == Instruction::IntToPtr) {
+      auto PS = DL.getPointerSizeInBits(
+          cast<PointerType>(CE->getType())->getAddressSpace());
+      return isBytewiseValue(
+          ConstantExpr::getIntegerCast(CE->getOperand(0),
+                                       Type::getIntNTy(Ctx, PS), false),
+          DL);
+    }
+  }
+
   auto Merge = [&](Value *LHS, Value *RHS) -> Value * {
     if (LHS == RHS)
       return LHS;
     if (!LHS || !RHS)
       return nullptr;
     if (LHS == UndefInt8)
       return RHS;
     if (RHS == UndefInt8)

llvm/trunk/unittests/Analysis/ValueTrackingTest.cpp

const std::pair<const char *, const char *> IsBytewiseValueTests[] = {
         "i8 undef",
         "i16* undef",
     },
     {
         "i8 0",
         "i16* inttoptr (i64 0 to i16*)",
     },
     {
-        "",
+        "i8 -1",
         "i16* inttoptr (i64 -1 to i16*)",
     },
     {
-        "",
+        "i8 -86",
         "i16* inttoptr (i64 -6148914691236517206 to i16*)",
     },
     {
         "",
         "i16* inttoptr (i48 -1 to i16*)",
     },
     {
-        "",
+        "i8 -1",
         "i16* inttoptr (i96 -1 to i16*)",
     },
     {
         "i8 0",
         "[0 x i8] zeroinitializer",
     },
     {
         "i8 undef",