[InstCombine] Fold Int2Ptr/PtrToInt if the ptr is dereferenceable using API

[Krishnakariya]

Summary

Split from D107822.
In this patch, we remove the roundtrip cast if p is dereferenceable.
We check whether p is dereferenceable using the "isDereferenceableAndAlignedPointer" API.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

 //===- InstCombineCasts.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the visit functions for cast operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InstCombineInternal.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/KnownBits.h"
 #include "llvm/Transforms/InstCombine/InstCombiner.h"
 #include <numeric>
 using namespace llvm;
if (match(Src, m_OneUse(m_Shuffle(m_Value(X), m_Undef(), m_Mask(Mask))))) {
     auto *DestTy = dyn_cast<FixedVectorType>(Ty);
     if (SrcTy && DestTy &&
         SrcTy->getNumElements() == DestTy->getNumElements() &&
         SrcTy->getPrimitiveSizeInBits() == DestTy->getPrimitiveSizeInBits()) {
       Value *CastX = Builder.CreateCast(CI.getOpcode(), X, DestTy);
       return new ShuffleVectorInst(CastX, UndefValue::get(DestTy), Mask);
     }
   }
-
+  // Replace Int2Ptr/Ptr2Int RoundTrip Cast with bitcast if the pointer
+  // is dereferenceable.
+  Value *Ptr = isIntToPtrRoundTripCast(&CI);
+  if (Ptr) {
+    if (isDereferenceableAndAlignedPointer(Ptr, Align(1), APInt(64, 1), DL)) {
+      return new BitCastInst(Ptr, CI.getDestTy());
+    }
+  }
   return nullptr;
 }
 
 /// Constants and extensions/truncates from the destination type are always
 /// free to be evaluated in that type. This is a helper for canEvaluate*.
 static bool canAlwaysEvaluateInType(Value *V, Type *Ty) {
   if (isa<Constant>(V))
     return true;

llvm/test/Transforms/InstCombine/load-int2ptr-fold.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S -disable-i2p-p2i-opt < %s | FileCheck %s
 
 target datalayout = "e-p:64:64-p1:16:16-p2:32:32:32-p3:64:64:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @foo (i8* %a, i8* %b)
 
 define void @test_dereferenceable(i8* %X, i8* dereferenceable(1) %Z, i1 %cmp) {
 ; CHECK-LABEL: @test_dereferenceable(
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
+; CHECK-NEXT:    [[X_I:%.*]] = ptrtoint i8* [[X:%.*]] to i64
+; CHECK-NEXT:    [[X_P:%.*]] = inttoptr i64 [[X_I]] to i8*
 ; CHECK-NEXT:    br label [[CALL:%.*]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    br label [[CALL]]
 ; CHECK:       call:
-; CHECK-NEXT:    [[PHI_1_IN_IN:%.*]] = phi i8* [ [[Z:%.*]], [[IF_ELSE]] ], [ [[X:%.*]], [[IF_THEN]] ]
-; CHECK-NEXT:    [[PHI_1_IN:%.*]] = ptrtoint i8* [[PHI_1_IN_IN]] to i64
-; CHECK-NEXT:    [[PHI_1:%.*]] = inttoptr i64 [[PHI_1_IN]] to i8*
+; CHECK-NEXT:    [[PHI_1:%.*]] = phi i8* [ [[Z:%.*]], [[IF_ELSE]] ], [ [[X_P]], [[IF_THEN]] ]
 ; CHECK-NEXT:    tail call void @foo(i8* [[PHI_1]], i8* [[PHI_1]])
 ; CHECK-NEXT:    ret void
 ;
   br i1 %cmp, label %if.then, label %if.else
 
 if.then:
   %X.i = ptrtoint i8* %X to i64
   %X.p = inttoptr i64 %X.i to i8*

 define void @test_dereferenceable_2(i8* dereferenceable(16) %X, i8* dereferenceable(16) %Z, i1 %cmp) {
 ; CHECK-LABEL: @test_dereferenceable_2(
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    br label [[CALL:%.*]]
 ; CHECK:       if.else:
 ; CHECK-NEXT:    br label [[CALL]]
 ; CHECK:       call:
-; CHECK-NEXT:    [[PHI_1_IN_IN:%.*]] = phi i8* [ [[Z:%.*]], [[IF_ELSE]] ], [ [[X:%.*]], [[IF_THEN]] ]
-; CHECK-NEXT:    [[PHI_1_IN:%.*]] = ptrtoint i8* [[PHI_1_IN_IN]] to i64
-; CHECK-NEXT:    [[PHI_1:%.*]] = inttoptr i64 [[PHI_1_IN]] to i8*
+; CHECK-NEXT:    [[PHI_1:%.*]] = phi i8* [ [[Z:%.*]], [[IF_ELSE]] ], [ [[X:%.*]], [[IF_THEN]] ]
 ; CHECK-NEXT:    tail call void @foo(i8* nonnull [[PHI_1]], i8* nonnull [[PHI_1]])
 ; CHECK-NEXT:    ret void
 ;
   br i1 %cmp, label %if.then, label %if.else
 
 if.then:
   %X.i = ptrtoint i8* %X to i64
   %X.p = inttoptr i64 %X.i to i8*