[InstCombine] Folding `(inttoptr (and (ptrtoint Ptr), Mask))` -> `@llvm.ptrmask(Ptr, Mask)`

[goldstein.w.n]

Summary

This works if Ptr has noundef: https://alive2.llvm.org/ce/z/S6yEwr

Alive2 does not support @llvm.ptrmask, but @llvm.ptrmask is
documented as equivilent to:
(getelementptr i8 Ptr, (sub (and (ptrtoint Ptr), Mask), (ptrtoint Ptr)))

See: https://llvm.org/docs/LangRef.html#llvm-ptrmask-intrinsic

Alive2 also doesn't handle inttoptr, so the proof compares:

define i64 @src_ptrtoint(ptr noundef %p, i64 %m) {
  %pi = ptrtoint ptr %p to i64
  %pi_masked = and i64 %pi, %m
  ret i64 %pi_masked
}

define i64 @tgt_ptrtoint(ptr noundef %p, i64 %m) {
  %pi = ptrtoint ptr %p to i64
  %pi_m = and i64 %pi, %m
  %pi_off = sub i64 %pi_m, %pi
  %pm = getelementptr i8, ptr %p, i64 %pi_off
  %pi_masked = ptrtoint ptr %pm to i64
  ret i64 %pi_masked
}

Which verifies

[nikic]

This is not legal -- the fact that this is not legal is pretty much the whole reason why the ptrmask intrinsic exists in the first place. ptrmask preserves the provenance of the base object, while the ptrtoint/inttoptr sequence does not. The result of the inttoptr can have different provenance than the ptrtoint operand.

[goldstein.w.n]

In D154009#4457421, @nikic wrote:

This is not legal -- the fact that this is not legal is pretty much the whole reason why the ptrmask intrinsic exists in the first place. ptrmask preserves the provenance of the base object, while the ptrtoint/inttoptr sequence does not. The result of the inttoptr can have different provenance than the ptrtoint operand.

IC. Okay will abandon (likewise the rest of the series). Is there any way to get @llvm.ptrmask to generate in C code? Was having trouble doing that hence this patch.

[nikic]

In D154009#4457452, @goldstein.w.n wrote:

In D154009#4457421, @nikic wrote:

This is not legal -- the fact that this is not legal is pretty much the whole reason why the ptrmask intrinsic exists in the first place. ptrmask preserves the provenance of the base object, while the ptrtoint/inttoptr sequence does not. The result of the inttoptr can have different provenance than the ptrtoint operand.

IC. Okay will abandon (likewise the rest of the series). Is there any way to get @llvm.ptrmask to generate in C code? Was having trouble doing that hence this patch.

__builtin_align_down() ought to generate it, but doesn't due to insufficient optimization support for ptrmask, see https://github.com/llvm/llvm-project/blob/75a1797044fc049438bdfd1edaf16afa90fcfe24/clang/lib/CodeGen/CGBuiltin.cpp#L19174.

Apart from that, I believe it's only used for some vaargs lowering code.

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Type *Ty = CI.getOperand(0)->getType()->getWithNewType(
         DL.getIntPtrType(CI.getContext(), AS));
     Value *P = Builder.CreateZExtOrTrunc(CI.getOperand(0), Ty);
     return new IntToPtrInst(P, CI.getType());
   }
 
   if (Instruction *I = commonCastTransforms(CI))
     return I;
 
+  // Convert:
+  // (inttoptr (and (ptrtoint Ptr), Mask))
+  //    -> llvm.ptrmask(Ptr, Mask)
+  // IFF
+  //    Ptr is noundef
+  //    Non-vec type (ptrmask of vec is weird).
+  Value *Ptr, *Mask;
+  if (!CI.getType()->isVectorTy() &&
+      match(CI.getOperand(0),
+            m_OneUse(m_c_And(m_PtrToInt(m_Value(Ptr)), m_Value(Mask)))) &&
+      isGuaranteedNotToBeUndefOrPoison(Ptr))
+    return replaceInstUsesWith(CI, Builder.CreateIntrinsic(Ptr->getType(),
+                                                           Intrinsic::ptrmask,
+                                                           {Ptr, Mask}));
+
   return nullptr;
 }
 
 /// Implement the transforms for cast of pointer (bitcast/ptrtoint)
 Instruction *InstCombinerImpl::commonPointerCastTransforms(CastInst &CI) {
   Value *Src = CI.getOperand(0);
 
   if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Src)) {

llvm/test/Transforms/InstCombine/callsite_nonnull_args_through_casts.ll

entry:
   call void @foo(ptr %i2p)
   ret void
 }
 
 define void @maybenullAfterPtr2Int() {
 ; CHECK-LABEL: define void @maybenullAfterPtr2Int() {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint ptr [[A]] to i64
-; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[TMP0]], 4294967292
-; CHECK-NEXT:    [[I2P:%.*]] = inttoptr i64 [[TMP1]] to ptr
+; CHECK-NEXT:    [[I2P:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr nonnull [[A]], i64 4294967292)
 ; CHECK-NEXT:    call void @foo(ptr [[I2P]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32
   %p2i = ptrtoint ptr %a to i32      ; truncating ptr2int as sizeof(ptr) > sizeof(i32)
   %i2p = inttoptr i32 %p2i to ptr
   call void @foo(ptr %i2p)

llvm/test/Transforms/InstCombine/to-ptrmask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare ptr @llvm.ptrmask(ptr, i64)
 declare void @use.i64(i64)
 
 define ptr @intoptr_mask(ptr noundef %p, i64 %m) {
 ; CHECK-LABEL: define ptr @intoptr_mask
 ; CHECK-SAME: (ptr noundef [[P:%.*]], i64 [[M:%.*]]) {
-; CHECK-NEXT:    [[PI:%.*]] = ptrtoint ptr [[P]] to i64
-; CHECK-NEXT:    [[PI_MASKED:%.*]] = and i64 [[PI]], [[M]]
-; CHECK-NEXT:    [[PM:%.*]] = inttoptr i64 [[PI_MASKED]] to ptr
+; CHECK-NEXT:    [[PM:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[P]], i64 [[M]])
 ; CHECK-NEXT:    ret ptr [[PM]]
 ;
   %pi = ptrtoint ptr %p to i64
   %pi_masked = and i64 %pi, %m
   %pm = inttoptr i64 %pi_masked to ptr
   ret ptr %pm
 }