[ConstantFolding] Fold ptrtoint(gep i8 null, x) -> x

[arichardson]

Summary

I was looking at some missed optimizations in CHERI-enabled targets and
noticed that we weren't removing vtable indirection for calls via known
pointers-to-members. The underlying reason for this is that we represent
pointers-to-function-members as {i8 addrspace(200)*, i64} and generate the
constant offsets using (gep i8 null, <index>). We use a constant GEP here
since inttoptr should be avoided for CHERI capabilities. The pointer-to-member
call uses ptrtoint to extract the index, due to this missing fold we can't
infer the actual value loaded from the vtable.
This is the initial constant folding change for this pattern, I will add
InstSimplify/InstCombine folds as a follow-up.

We could fold all ptrtoint(inbounds GEP) to zero here since that is the
only valid offset for an inbounds GEP. If the offset is not zero, that GEP
is poison so returning 0 is valid (https://alive2.llvm.org/ce/z/Gzb5iH).
However, Clang currently generates inbounds GEPs on NULL for hand-written
offsetof() expressions, so this could result in miscompilation.

[nikic]

llvm/lib/Analysis/ConstantFolding.cpp

1376

This doesn't belong here. If we'd like to make this fold, it should work directly on gep null, x -> null, without requiring a ptrtoint around it. (Also note that this fold is not correct if null is defined, e.g. in non-zero address space).

[arichardson]

Drop unnncessary code and replace it with a comment explaining why we can ignore inbounds.

[arichardson]

llvm/lib/Analysis/ConstantFolding.cpp

1376

Yes I agree. I added that fold locally later but it caused lots of undesirable changes.

Langref has the following sentence:
The only in bounds address for a null pointer in the default address-space is the null pointer itself., and

null_pointer_is_valid
If null_pointer_is_valid is set, then the null address in address-space 0 is considered to be a valid address for memory loads and stores. Any analysis or optimization should not treat dereferencing a pointer to null as undefined behavior in this function. Note: Comparing address of a global variable to null may still evaluate to false because of a limitation in querying this attribute inside constant expressions.

So I guess that implies gep inbounds null is valid if that attribute is set? Should the GEP section be changed to something like
The only in bounds address for a null pointer in the default address-space is the null pointer itself. This does not apply if the null_pointer_is_valid attribute was used.

[lebedev.ri]

llvm/lib/Analysis/ConstantFolding.cpp

1353–1367

I don't think this is correct.
In int -> ptr -> int, the width can be different at all three stages,
so i'd expect two sextOrTruncOrSelf casts back to back.

[arichardson]

llvm/lib/Analysis/ConstantFolding.cpp

1353–1367

I believe the current code manually does a trunc if the inttoptr input type is larger than pointer size:
with a p:64:64:64:32 datalayout, ptrtoint (inttoptr i256 -1 to i8*) to i128 should result in
trunc ((i256)-1 & UINT64_MAX) to i128. The new code now does zext (trunc i256 -1 to i64) to i128 which I believe yields the same value? No existing tests were affected by this refactoring so it's either equivalent or we are missing test coverage.

Slightly unrelated: For our (CHERI) usecase pointer size in bits is wrong since we have 128-bit pointers but only 64-bit address range. I would like to change it to index size, but I am not sure if that is acceptable upstream. If not I could add another datalayout field for pointers that specifies the address range (defaulting to index size). For now this works for us since we have patched DL.getIntPtrType() to return i64 for our addrspace(200) pointers, but I would prefer to be explicit whether we care about address range or pointer type size. This might also help with non-integral pointers that have additional metadata (e.g. bounds) like our CHERI capabilities.

[lebedev.ri]

llvm/lib/Analysis/ConstantFolding.cpp

1353–1367

Ah, the reply i should have gotten is: "what are you talking about? there is a second cast, later on"

1355

1365

How do you know the result is a constant?

1366

1367

1371

[arichardson]

llvm/lib/Analysis/ConstantFolding.cpp

1365

Don't all inputs need to be constants if the GEP is a ConstantExpr? I couldn't think of a counter-example:

Even for globals this cast works fine:

@a = external addrspace(1) global i16

define i64 @nofold_ptrtoint_gep_global(i32 %x) {
  %ptr = getelementptr i16, i16 addrspace(1)* @a, i32 1
  %ret = ptrtoint i16 addrspace(1)* %ptr to i64
  ret i64 %ret
}

1365

If this is not true, I'm obviously happy to change it to dyn_cast and add the check.

[arichardson]

llvm/lib/Analysis/ConstantFolding.cpp

1353–1367

If this is not clear enough I can add a comment?

[arichardson]

Add missing /*Param=*/

[lebedev.ri]

Looks reasonable with nits.

llvm/lib/Analysis/ConstantFolding.cpp

1365

Err, right,
This also answers my further unanswered question as to why we need to special-handle this in instsimplify too.

[lebedev.ri]

LG

llvm/lib/Analysis/ConstantFolding.cpp

1371–1373

I don't think matters what is "safer", that mentioned code is UB, and UBSan will catch it.

[nikic]

llvm/lib/Analysis/ConstantFolding.cpp

1371–1373

I think this comment should just be dropped entirely. Any optimization that is valid without inbounds is valid with inbounds and does not require explicit justification.

[arichardson]

llvm/lib/Analysis/ConstantFolding.cpp

1371–1373

Sounds good to me. I added this comment since I only recently looked into the detailed semantics of inbounds/non-inbounds GEPs. But for someone familiar with it that is indeed obvious.

[lebedev.ri]

If there isn't a fold gep inbounds null, ??? --> bitcast(null) it might be interesting to add one though.

[arichardson]

Drop inbounds comment

[arichardson]

In D110245#3017539, @lebedev.ri wrote:

If there isn't a fold gep inbounds null, ??? --> bitcast(null) it might be interesting to add one though.

I tried adding a (gep inbounds null, nonzero) -> poison fold, but that broke lots of tests. (gep inbounds null, ..) -> null is a bit safer but will break &((TYPE *)0)->MEMBER) __builtin_offsetof fallbacks since they are constant-folded to null before UBSAN can handle it.

llvm/lib/Analysis/ConstantFolding.cpp

1361

The only open question I have is whether this is valid for non-integral pointers? It is definitely valid for CHERI capabilities which are non-integral but with a well defined pointer->int mapping (only int->pointer isn't).

[lebedev.ri]

In D110245#3017547, @arichardson wrote:

In D110245#3017539, @lebedev.ri wrote:

If there isn't a fold gep inbounds null, ??? --> bitcast(null) it might be interesting to add one though.

I tried adding a (gep inbounds null, nonzero) -> poison fold, but that broke lots of tests. (gep inbounds null, ..) -> null is a bit safer but will break &((TYPE *)0)->MEMBER) __builtin_offsetof fallbacks since they are constant-folded to null before UBSAN can handle it.

I personally find this approach problematic for forward progress.
https://alive2.llvm.org/ce/z/swyJHv <- gep inbounds null, ??? --> null is always fine
https://alive2.llvm.org/ce/z/fQUjCY <- (gep inbounds null, nonzero) --> undef is also fine
So anything that breaks was broken already. In case of tests, they probably just need to be updated.

[arichardson]

In D110245#3017554, @lebedev.ri wrote:

In D110245#3017547, @arichardson wrote:

In D110245#3017539, @lebedev.ri wrote:

If there isn't a fold gep inbounds null, ??? --> bitcast(null) it might be interesting to add one though.

I tried adding a (gep inbounds null, nonzero) -> poison fold, but that broke lots of tests. (gep inbounds null, ..) -> null is a bit safer but will break &((TYPE *)0)->MEMBER) __builtin_offsetof fallbacks since they are constant-folded to null before UBSAN can handle it.

I personally find this approach problematic for forward progress.
https://alive2.llvm.org/ce/z/swyJHv <- gep inbounds null, ??? --> null is always fine
https://alive2.llvm.org/ce/z/fQUjCY <- (gep inbounds null, nonzero) --> undef is also fine
So anything that breaks was broken already. In case of tests, they probably just need to be updated.

I would like to add this fold, but what about @nikic's comment about having a defined null pointer? I believe in that case the whole address space is inbounds of null?

[lebedev.ri]

In D110245#3017557, @arichardson wrote:

In D110245#3017554, @lebedev.ri wrote:

In D110245#3017547, @arichardson wrote:

In D110245#3017539, @lebedev.ri wrote:

If there isn't a fold gep inbounds null, ??? --> bitcast(null) it might be interesting to add one though.

I tried adding a (gep inbounds null, nonzero) -> poison fold, but that broke lots of tests. (gep inbounds null, ..) -> null is a bit safer but will break &((TYPE *)0)->MEMBER) __builtin_offsetof fallbacks since they are constant-folded to null before UBSAN can handle it.

I personally find this approach problematic for forward progress.
https://alive2.llvm.org/ce/z/swyJHv <- gep inbounds null, ??? --> null is always fine
https://alive2.llvm.org/ce/z/fQUjCY <- (gep inbounds null, nonzero) --> undef is also fine
So anything that breaks was broken already. In case of tests, they probably just need to be updated.

I would like to add this fold, but what about @nikic's comment about having a defined null pointer? I believe in that case the whole address space is inbounds of null?

Yep, these two folds i linked require !nullPointerIsDefined

[arichardson]

rebase after baseline test change

[arichardson]

Drop non-integral fixme. Should be safe as pointed out by @nikic in D110247

llvm/lib/Analysis/ConstantFolding.cpp

 
 Constant *llvm::ConstantFoldCastOperand(unsigned Opcode, Constant *C,
                                         Type *DestTy, const DataLayout &DL) {
   assert(Instruction::isCast(Opcode));
   switch (Opcode) {
   default:
     llvm_unreachable("Missing case");
   case Instruction::PtrToInt:
+    if (auto *CE = dyn_cast<ConstantExpr>(C)) {
+      Constant *FoldedValue = nullptr;
       // If the input is a inttoptr, eliminate the pair.  This requires knowing
       // the width of a pointer, so it can't be done in ConstantExpr::getCast.
-    if (auto *CE = dyn_cast<ConstantExpr>(C)) {
       if (CE->getOpcode() == Instruction::IntToPtr) {
-        Constant *Input = CE->getOperand(0);
-        unsigned InWidth = Input->getType()->getScalarSizeInBits();
-        unsigned PtrWidth = DL.getPointerTypeSizeInBits(CE->getType());
-        if (PtrWidth < InWidth) {
-          Constant *Mask =
-            ConstantInt::get(CE->getContext(),
-                             APInt::getLowBitsSet(InWidth, PtrWidth));
-          Input = ConstantExpr::getAnd(Input, Mask);
-        }
-        // Do a zext or trunc to get to the dest size.
-        return ConstantExpr::getIntegerCast(Input, DestTy, false);
+        // zext/trunc the inttoptr to pointer size.
+        FoldedValue = ConstantExpr::getIntegerCast(
+            CE->getOperand(0), DL.getIntPtrType(CE->getType()),
+            /*IsSigned=*/false);
+      } else if (auto *GEP = dyn_cast<GEPOperator>(CE)) {
+        // If we have GEP, we can perform the following folds:
+        // (ptrtoint (gep null, x)) -> x
+        // (ptrtoint (gep (gep null, x), y) -> x + y, etc.
+        unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());
+        APInt BaseOffset(BitWidth, 0);
+        auto *Base = cast<Constant>(GEP->stripAndAccumulateConstantOffsets(
+            DL, BaseOffset, /*AllowNonInbounds=*/true));
+        if (Base->isNullValue()) {
+          FoldedValue = ConstantInt::get(CE->getContext(), BaseOffset);
+        }
+      if (FoldedValue) {
+        // Do a zext or trunc to get to the ptrtoint dest size.
+        return ConstantExpr::getIntegerCast(FoldedValue, DestTy,
+                                            /*IsSigned=*/false);
       }
     }
     return ConstantExpr::getCast(Opcode, C, DestTy);
   case Instruction::IntToPtr:
     // If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if
     // the int size is >= the ptr size and the address spaces are the same.
     // This requires knowing the width of a pointer, so it can't be done in
     // ConstantExpr::getCast.
     if (auto *CE = dyn_cast<ConstantExpr>(C)) {
       if (CE->getOpcode() == Instruction::PtrToInt) {
         Constant *SrcPtr = CE->getOperand(0);
         unsigned SrcPtrSize = DL.getPointerTypeSizeInBits(SrcPtr->getType());

llvm/test/Transforms/InstCombine/ptrtoint-nullgep.ll

 ; ALL-NEXT:    ret i64 0
 ;
   ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 0) to i64)
 }
 define i64 @constant_fold_ptrtoint_gep_nonzero() {
 ; LLPARSER-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
 ; LLPARSER-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 1234) to i64)
 ;
-; INTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
-; INTEGRAL-INSTSIMPLIFY-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 1234) to i64)
+; INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
+; INSTSIMPLIFY-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 1234) to i64)
 ;
-; INTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
-; INTEGRAL-INSTCOMBINE-NEXT:    ret i64 4936
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 1234) to i64)
+; INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero() {
+; INSTCOMBINE-NEXT:    ret i64 4936
 ;
   ret i64 ptrtoint (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* null, i64 1234) to i64)
 }
 
 define i64 @constant_fold_ptrtoint_gep_zero_inbounds() {
 ; ALL-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_zero_inbounds() {
 ; ALL-NEXT:    ret i64 0
 ;
   ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 0) to i64)
 }
 
 ; In theory we could fold this to poison/null, but that would break offsetof
 ; implementations that don't use __builtin_offsetof.
 ; TODO: should Clang special case ((INTEGER)&((TYPE *)0)->MEMBER) to emit a non-inbounds GEP?
 define i64 @constant_fold_ptrtoint_gep_nonzero_inbounds() {
 ; LLPARSER-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
 ; LLPARSER-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 1234) to i64)
 ;
-; INTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
-; INTEGRAL-INSTSIMPLIFY-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 1234) to i64)
-;
-; INTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
-; INTEGRAL-INSTCOMBINE-NEXT:    ret i64 4936
+; INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
+; INSTSIMPLIFY-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 1234) to i64)
 ;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 1234) to i64)
+; INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_gep_nonzero_inbounds() {
+; INSTCOMBINE-NEXT:    ret i64 4936
 ;
   ret i64 ptrtoint (i32 addrspace(1)* getelementptr inbounds (i32, i32 addrspace(1)* null, i64 1234) to i64)
 }
 
 ; Check all combinations of inbounds+non-inbounds GEP with the outer GEP having a non-zero offset
 define void @constant_fold_ptrtoint_of_gep_of_nullgep() {
 ; LLPARSER-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
 ; LLPARSER-NEXT:    call void @use_i64(i64 0)
 ; LLPARSER-NEXT:    call void @use_i64(i64 0)
 ; LLPARSER-NEXT:    call void @use_i64(i64 0)
 ; LLPARSER-NEXT:    call void @use_i64(i64 0)
 ; LLPARSER-NEXT:    ret void
 ;
-; INTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTSIMPLIFY-NEXT:    ret void
-;
-; INTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
-; INTEGRAL-INSTCOMBINE-NEXT:    ret void
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 0)
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 0)
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 0)
-; NONINTEGRAL-NEXT:    call void @use_i64(i64 0)
-; NONINTEGRAL-NEXT:    ret void
+; INSTSIMPLIFY-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64))
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
+; INSTSIMPLIFY-NEXT:    call void @use_i64(i64 0)
+; INSTSIMPLIFY-NEXT:    ret void
+;
+; INSTCOMBINE-LABEL: define {{[^@]+}}@constant_fold_ptrtoint_of_gep_of_nullgep() {
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 1234)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
+; INSTCOMBINE-NEXT:    call void @use_i64(i64 0)
+; INSTCOMBINE-NEXT:    ret void
 ;
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 0), i64 1234) to i64))
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 0), i64 1234) to i64))
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 0), i64 1234) to i64))
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 0), i64 1234) to i64))
   ; Same again but this time with the inner GEP using the non-zero offset
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234), i64 0) to i64))
   call void @use_i64(i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234), i64 0) to i64))

 
 define i64 @fold_ptrtoint_nullgep_nonzero() {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero() {
 ; LLPARSER-NEXT:    [[OFFSET:%.*]] = add i64 1234, 0
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[OFFSET]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero() {
-; INTEGRAL-NEXT:    ret i64 1234
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64)
+; CHECK-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero() {
+; CHECK-NEXT:    ret i64 1234
 ;
   %offset = add i64 1234, 0
   %ptr = getelementptr i8, i8 addrspace(1)* null, i64 %offset
   %ret = ptrtoint i8 addrspace(1)* %ptr to i64
   ret i64 %ret
 }
 
 ; Inbounds constant null-GEP with non-zero could be constant-folded to null/poison,
 ; but folding it to the value makes ((INTEGER)&((TYPE *)0)->MEMBER) work.
 define i64 @fold_ptrtoint_nullgep_nonzero_inbounds() {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero_inbounds() {
 ; LLPARSER-NEXT:    [[OFFSET:%.*]] = add i64 1234, 0
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* null, i64 [[OFFSET]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero_inbounds() {
-; INTEGRAL-NEXT:    ret i64 1234
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero_inbounds() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64)
+; CHECK-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_nonzero_inbounds() {
+; CHECK-NEXT:    ret i64 1234
 ;
   %offset = add i64 1234, 0
   %ptr = getelementptr inbounds i8, i8 addrspace(1)* null, i64 %offset
   %ret = ptrtoint i8 addrspace(1)* %ptr to i64
   ret i64 %ret
 }
 
 ; We should be able to fold ptrtoint(gep null, x) to x

 define i64 @fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices(i64 %val) {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
 ; LLPARSER-SAME: (i64 [[VAL:%.*]]) {
 ; LLPARSER-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i32 1
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
-; INTEGRAL-INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
-; INTEGRAL-INSTSIMPLIFY-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
-; INTEGRAL-INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i32 1
-; INTEGRAL-INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; INTEGRAL-INSTSIMPLIFY-NEXT:    ret i64 [[RET]]
-;
-; INTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
-; INTEGRAL-INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
-; INTEGRAL-INSTCOMBINE-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
-; INTEGRAL-INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i64 1
-; INTEGRAL-INSTCOMBINE-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; INTEGRAL-INSTCOMBINE-NEXT:    ret i64 [[RET]]
-;
-; NONINTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
-; NONINTEGRAL-INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i32 1
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    ret i64 [[RET]]
-;
-; NONINTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
-; NONINTEGRAL-INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i64 1
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; NONINTEGRAL-INSTCOMBINE-NEXT:    ret i64 [[RET]]
+; INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
+; INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
+; INSTSIMPLIFY-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
+; INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i32 1
+; INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
+; INSTSIMPLIFY-NEXT:    ret i64 [[RET]]
+;
+; INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_known_nonzero_inbounds_multiple_indices
+; INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
+; INSTCOMBINE-NEXT:    [[NON_ZERO_OFFSET:%.*]] = or i64 [[VAL]], 1
+; INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 [[NON_ZERO_OFFSET]], i64 1
+; INSTCOMBINE-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
+; INSTCOMBINE-NEXT:    ret i64 [[RET]]
 ;
   %non_zero_offset = or i64 %val, 1
   %ptr = getelementptr inbounds [2 x i8], [2 x i8] addrspace(1)* null, i64 %non_zero_offset, i32 1
   %ret = ptrtoint i8 addrspace(1)* %ptr to i64
   ret i64 %ret
 }
 
 ; We can't fold non-i8 GEPs in InstSimplify since that would require adding new arithmetic.

 ; ptrtoint type does not match index type so requires requite a new trunc instruction
 define i32 @fold_ptrtoint_nullgep_variable_trunc(i64 %val) {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
 ; LLPARSER-SAME: (i64 [[VAL:%.*]]) {
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i32
 ; LLPARSER-NEXT:    ret i32 [[RET]]
 ;
-; INTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
-; INTEGRAL-INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
-; INTEGRAL-INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
-; INTEGRAL-INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i32
-; INTEGRAL-INSTSIMPLIFY-NEXT:    ret i32 [[RET]]
-;
-; INTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
-; INTEGRAL-INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
-; INTEGRAL-INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
-; INTEGRAL-INSTCOMBINE-NEXT:    [[TMP1:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; INTEGRAL-INSTCOMBINE-NEXT:    [[RET:%.*]] = trunc i64 [[TMP1]] to i32
-; INTEGRAL-INSTCOMBINE-NEXT:    ret i32 [[RET]]
-;
-; NONINTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
-; NONINTEGRAL-INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i32
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    ret i32 [[RET]]
-;
-; NONINTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
-; NONINTEGRAL-INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[TMP1:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
-; NONINTEGRAL-INSTCOMBINE-NEXT:    [[RET:%.*]] = trunc i64 [[TMP1]] to i32
-; NONINTEGRAL-INSTCOMBINE-NEXT:    ret i32 [[RET]]
+; INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
+; INSTSIMPLIFY-SAME: (i64 [[VAL:%.*]]) {
+; INSTSIMPLIFY-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
+; INSTSIMPLIFY-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i32
+; INSTSIMPLIFY-NEXT:    ret i32 [[RET]]
+;
+; INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_nullgep_variable_trunc
+; INSTCOMBINE-SAME: (i64 [[VAL:%.*]]) {
+; INSTCOMBINE-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[VAL]]
+; INSTCOMBINE-NEXT:    [[TMP1:%.*]] = ptrtoint i8 addrspace(1)* [[PTR]] to i64
+; INSTCOMBINE-NEXT:    [[RET:%.*]] = trunc i64 [[TMP1]] to i32
+; INSTCOMBINE-NEXT:    ret i32 [[RET]]
 ;
   %ptr = getelementptr i8, i8 addrspace(1)* null, i64 %val
   %ret = ptrtoint i8 addrspace(1)* %ptr to i32
   ret i32 %ret
 }
 
 ; For the following three tests, we could fold the result to poison/null since there is at least
 ; one inbounds GEP on null with a non-zero offset.
 define i64 @fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
 ; LLPARSER-NEXT:    [[NONZERO_OFFSET:%.*]] = add i64 1234, 0
 ; LLPARSER-NEXT:    [[ZERO_OFFSET:%.*]] = sub i64 [[NONZERO_OFFSET]], 1234
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* null, i64 [[NONZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[PTR2:%.*]] = getelementptr i8, i8 addrspace(1)* [[PTR]], i64 [[ZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR2]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
-; INTEGRAL-NEXT:    ret i64 1234
-;
-; NONINTEGRAL-INSTSIMPLIFY-LABEL: define {{[^@]+}}@fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
-; NONINTEGRAL-INSTSIMPLIFY-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64)
-;
-; NONINTEGRAL-INSTCOMBINE-LABEL: define {{[^@]+}}@fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
-; NONINTEGRAL-INSTCOMBINE-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr (i8, i8 addrspace(1)* null, i64 1234) to i64)
+; CHECK-LABEL: define {{[^@]+}}@fold_ptrtoint_zero_nullgep_of_nonzero_inbounds_nullgep() {
+; CHECK-NEXT:    ret i64 1234
 ;
   %nonzero_offset = add i64 1234, 0
   %zero_offset = sub i64 %nonzero_offset, 1234
   %ptr = getelementptr inbounds i8, i8 addrspace(1)* null, i64 %nonzero_offset
   %ptr2 = getelementptr i8, i8 addrspace(1)* %ptr, i64 %zero_offset
   %ret = ptrtoint i8 addrspace(1)* %ptr2 to i64
   ret i64 %ret
 }
 
 define i64 @fold_ptrtoint_nonzero_inbounds_nullgep_of_zero_noninbounds_nullgep() {
 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_nonzero_inbounds_nullgep_of_zero_noninbounds_nullgep() {
 ; LLPARSER-NEXT:    [[NONZERO_OFFSET:%.*]] = add i64 1234, 0
 ; LLPARSER-NEXT:    [[ZERO_OFFSET:%.*]] = sub i64 [[NONZERO_OFFSET]], 1234
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr i8, i8 addrspace(1)* null, i64 [[ZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i64 [[NONZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR2]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nonzero_inbounds_nullgep_of_zero_noninbounds_nullgep() {
-; INTEGRAL-NEXT:    ret i64 1234
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_nonzero_inbounds_nullgep_of_zero_noninbounds_nullgep() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64)
+; CHECK-LABEL: define {{[^@]+}}@fold_ptrtoint_nonzero_inbounds_nullgep_of_zero_noninbounds_nullgep() {
+; CHECK-NEXT:    ret i64 1234
 ;
   %nonzero_offset = add i64 1234, 0
   %zero_offset = sub i64 %nonzero_offset, 1234
   %ptr = getelementptr i8, i8 addrspace(1)* null, i64 %zero_offset
   %ptr2 = getelementptr inbounds i8, i8 addrspace(1)* %ptr, i64 %nonzero_offset
   %ret = ptrtoint i8 addrspace(1)* %ptr2 to i64
   ret i64 %ret
 }

 ; LLPARSER-LABEL: define {{[^@]+}}@fold_ptrtoint_inbounds_nullgep_of_nonzero_inbounds_nullgep() {
 ; LLPARSER-NEXT:    [[NONZERO_OFFSET:%.*]] = add i64 1234, 0
 ; LLPARSER-NEXT:    [[ZERO_OFFSET:%.*]] = sub i64 [[NONZERO_OFFSET]], 1234
 ; LLPARSER-NEXT:    [[PTR:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* null, i64 [[NONZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[PTR]], i64 [[ZERO_OFFSET]]
 ; LLPARSER-NEXT:    [[RET:%.*]] = ptrtoint i8 addrspace(1)* [[PTR2]] to i64
 ; LLPARSER-NEXT:    ret i64 [[RET]]
 ;
-; INTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_inbounds_nullgep_of_nonzero_inbounds_nullgep() {
-; INTEGRAL-NEXT:    ret i64 1234
-;
-; NONINTEGRAL-LABEL: define {{[^@]+}}@fold_ptrtoint_inbounds_nullgep_of_nonzero_inbounds_nullgep() {
-; NONINTEGRAL-NEXT:    ret i64 ptrtoint (i8 addrspace(1)* getelementptr inbounds (i8, i8 addrspace(1)* null, i64 1234) to i64)
+; CHECK-LABEL: define {{[^@]+}}@fold_ptrtoint_inbounds_nullgep_of_nonzero_inbounds_nullgep() {
+; CHECK-NEXT:    ret i64 1234
 ;
   %nonzero_offset = add i64 1234, 0
   %zero_offset = sub i64 %nonzero_offset, 1234
   %ptr = getelementptr inbounds i8, i8 addrspace(1)* null, i64 %nonzero_offset
   %ptr2 = getelementptr inbounds i8, i8 addrspace(1)* %ptr, i64 %zero_offset
   %ret = ptrtoint i8 addrspace(1)* %ptr2 to i64
   ret i64 %ret
 }