[InstCombine] Support vectors in simplifyIntToPtrRoundTripCast.

[craig.topper]

Summary

This code compares getPointerTypeSizeInBits and getTypeSizeInBits.
getPointerTypeSizeInBits contains a call to getScalarType while
getTypeSizeInBits does not. This makes the code incorrect for vectors.

For scalable vectors this caused a warning about a scalable TypeSize
being converted to unsigned.

Switch to DL.getTypeSizeInBits for the pointers too. This should
work since inttoptr/ptrtoint can't change the number of elements.
This was suggested by @nikic in D139911.

Fixes PR59480.

[nikic]

LGTM

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

 //===- InstructionCombining.cpp - Combine multiple instructions -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static bool simplifyAssocCastAssoc(BinaryOperator *BinOp1,
   IC.replaceOperand(*BinOp1, 1, FoldedC);
   return true;
 }
 
 // Simplifies IntToPtr/PtrToInt RoundTrip Cast To BitCast.
 // inttoptr ( ptrtoint (x) ) --> x
 Value *InstCombinerImpl::simplifyIntToPtrRoundTripCast(Value *Val) {
   auto *IntToPtr = dyn_cast<IntToPtrInst>(Val);
-  if (IntToPtr && DL.getPointerTypeSizeInBits(IntToPtr->getDestTy()) ==
+  if (IntToPtr && DL.getTypeSizeInBits(IntToPtr->getDestTy()) ==
                       DL.getTypeSizeInBits(IntToPtr->getSrcTy())) {
     auto *PtrToInt = dyn_cast<PtrToIntInst>(IntToPtr->getOperand(0));
     Type *CastTy = IntToPtr->getDestTy();
     if (PtrToInt &&
         CastTy->getPointerAddressSpace() ==
             PtrToInt->getSrcTy()->getPointerAddressSpace() &&
-        DL.getPointerTypeSizeInBits(PtrToInt->getSrcTy()) ==
+        DL.getTypeSizeInBits(PtrToInt->getSrcTy()) ==
             DL.getTypeSizeInBits(PtrToInt->getDestTy())) {
       return CastInst::CreateBitOrPointerCast(PtrToInt->getOperand(0), CastTy,
                                               "", PtrToInt);
     }
   }
   return nullptr;
 }
 

llvm/test/Transforms/InstCombine/ptr-int-ptr-icmp.ll

 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %i = ptrtoint ptr %X to i64
   %p = inttoptr i64 %i to ptr
   %cmp = icmp eq ptr %p, %Y
   ret i1 %cmp
 }
 
+define <2 x i1> @func_vec(<2 x ptr> %X, <2 x ptr> %Y) {
+; CHECK-LABEL: @func_vec(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x ptr> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+;
+  %i = ptrtoint <2 x ptr> %X to <2 x i64>
+  %p = inttoptr <2 x i64> %i to <2 x ptr>
+  %cmp = icmp eq <2 x ptr> %p, %Y
+  ret <2 x i1> %cmp
+}
+
+define <vscale x 2 x i1> @func_svec(<vscale x 2 x ptr> %X, <vscale x 2 x ptr> %Y) {
+; CHECK-LABEL: @func_svec(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 2 x ptr> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret <vscale x 2 x i1> [[CMP]]
+;
+  %i = ptrtoint <vscale x 2 x ptr> %X to <vscale x 2 x i64>
+  %p = inttoptr <vscale x 2 x i64> %i to <vscale x 2 x ptr>
+  %cmp = icmp eq <vscale x 2 x ptr> %p, %Y
+  ret <vscale x 2 x i1> %cmp
+}
+
 define i1 @func_pointer_different_types(ptr %X, ptr %Y) {
 ; CHECK-LABEL: @func_pointer_different_types(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %i = ptrtoint ptr %X to i64
   %p = inttoptr i64 %i to ptr
   %cmp = icmp eq ptr %p, %Y