Update all auto-diff locations that handle pointers to treat user pointers as regular values

saipraveenb25 · saipraveenb25 · commit e61a0c08eb05 · 2025-02-24T17:57:34.000-05:00
diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp
@@ -1777,7 +1777,7 @@ void insertTempVarForMutableParams(IRModule* module, IRFunc* func)
 
     for (auto param : params)
     {
-        auto ptrType = as<IRPtrTypeBase>(param->getDataType());
+        auto ptrType = asRelevantPtrType(param->getDataType());
         auto tempVar = builder.emitVar(ptrType->getValueType());
         param->replaceUsesWith(tempVar);
         mapParamToTempVar[param] = tempVar;
@@ -2245,7 +2245,7 @@ InstPair ForwardDiffTranscriber::transcribeFuncParam(
                 builder->emitDifferentialPairGetPrimal(diffPairParam),
                 builder->emitDifferentialPairGetDifferential(diffType, diffPairParam));
         }
-        else if (auto pairPtrType = as<IRPtrTypeBase>(diffPairType))
+        else if (auto pairPtrType = asRelevantPtrType(diffPairType))
         {
             auto ptrInnerPairType = as<IRDifferentialPairTypeBase>(pairPtrType->getValueType());
             // Make a local copy of the parameter for primal and diff parts.
diff --git a/source/slang/slang-ir-autodiff-primal-hoist.cpp b/source/slang/slang-ir-autodiff-primal-hoist.cpp
@@ -1174,7 +1174,7 @@ IRVar* emitIndexedLocalVar(
     SourceLoc location)
 {
     // Cannot store pointers. Case should have been handled by now.
-    SLANG_RELEASE_ASSERT(!as<IRPtrTypeBase>(baseType));
+    SLANG_RELEASE_ASSERT(!asRelevantPtrType(baseType));
 
     // Cannot store types. Case should have been handled by now.
     SLANG_RELEASE_ASSERT(!as<IRTypeType>(baseType));
@@ -1656,7 +1656,7 @@ RefPtr<HoistedPrimalsInfo> ensurePrimalAvailability(
                             return true;
                         }
                         else if (
-                            as<IRPtrTypeBase>(instToStore->getDataType()) &&
+                            asRelevantPtrType(instToStore->getDataType()) &&
                             !isDifferentialOrRecomputeBlock(defBlock))
                         {
                             return true;
diff --git a/source/slang/slang-ir-autodiff-rev.cpp b/source/slang/slang-ir-autodiff-rev.cpp
@@ -370,7 +370,7 @@ IRType* BackwardDiffTranscriberBase::transcribeParamTypeForPropagateFunc(
     auto diffPairType = tryGetDiffPairType(builder, paramType);
     if (diffPairType)
     {
-        if (!as<IRPtrTypeBase>(diffPairType) && !as<IRDifferentialPtrPairType>(diffPairType))
+        if (!asRelevantPtrType(diffPairType) && !as<IRDifferentialPtrPairType>(diffPairType))
             return builder->getInOutType(diffPairType);
         return diffPairType;
     }
@@ -514,7 +514,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF
             {
                 // As long as the primal parameter is not an out or constref type,
                 // we need to fetch the primal value from the parameter.
-                if (as<IRPtrTypeBase>(propagateParamType))
+                if (asRelevantPtrType(propagateParamType))
                 {
                     primalArg = builder.emitLoad(param);
                 }
@@ -544,7 +544,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF
         }
         else
         {
-            auto primalPtrType = as<IRPtrTypeBase>(primalParamType);
+            auto primalPtrType = asRelevantPtrType(primalParamType);
             SLANG_RELEASE_ASSERT(primalPtrType);
             auto primalValueType = primalPtrType->getValueType();
             auto var = builder.emitVar(primalValueType);
diff --git a/source/slang/slang-ir-autodiff-transcriber-base.cpp b/source/slang/slang-ir-autodiff-transcriber-base.cpp
@@ -291,7 +291,7 @@ IRType* AutoDiffTranscriberBase::_differentiateTypeImpl(IRBuilder* builder, IRTy
     if (isNoDiffType(origType))
         return nullptr;
 
-    if (auto ptrType = as<IRPtrTypeBase>(origType))
+    if (auto ptrType = asRelevantPtrType(origType))
         return builder->getPtrType(
             origType->getOp(),
             differentiateType(builder, ptrType->getValueType()));
@@ -556,7 +556,7 @@ IRType* AutoDiffTranscriberBase::tryGetDiffPairType(IRBuilder* builder, IRType*
     if (isNoDiffType(originalType))
         return nullptr;
 
-    if (auto origPtrType = as<IRPtrTypeBase>(originalType))
+    if (auto origPtrType = asRelevantPtrType(originalType))
     {
         if (auto diffPairValueType = tryGetDiffPairType(builder, origPtrType->getValueType()))
             return builder->getPtrType(originalType->getOp(), diffPairValueType);
diff --git a/source/slang/slang-ir-autodiff-transpose.h b/source/slang/slang-ir-autodiff-transpose.h
@@ -619,7 +619,7 @@ struct DiffTransposePass
                     if (isDifferentialInst(varInst) && tryGetPrimalTypeFromDiffInst(varInst))
                     {
                         if (auto ptrPrimalType =
-                                as<IRPtrTypeBase>(tryGetPrimalTypeFromDiffInst(varInst)))
+                                asRelevantPtrType(tryGetPrimalTypeFromDiffInst(varInst)))
                         {
                             varInst->insertAtEnd(firstRevDiffBlock);
 
@@ -1119,7 +1119,7 @@ struct DiffTransposePass
 
         auto getDiffPairType = [](IRType* type)
         {
-            if (auto ptrType = as<IRPtrTypeBase>(type))
+            if (auto ptrType = asRelevantPtrType(type))
                 type = ptrType->getValueType();
             return as<IRDifferentialPairType>(type);
         };
@@ -1168,7 +1168,7 @@ struct DiffTransposePass
                 argRequiresLoad.add(false);
                 writebacks.add(DiffValWriteBack{instPair->getDiff(), tempVar});
             }
-            else if (!as<IRPtrTypeBase>(arg->getDataType()) && getDiffPairType(arg->getDataType()))
+            else if (!asRelevantPtrType(arg->getDataType()) && getDiffPairType(arg->getDataType()))
             {
                 // Normal differentiable input parameter will become an inout DiffPair parameter
                 // in the propagate func. The split logic has already prepared the initial value
@@ -1241,7 +1241,6 @@ struct DiffTransposePass
             argRequiresLoad.add(false);
         }
 
-
         auto revFnType =
             this->autodiffContext->transcriberSet.propagateTranscriber->differentiateFunctionType(
                 builder,
diff --git a/source/slang/slang-ir-autodiff-unzip.cpp b/source/slang/slang-ir-autodiff-unzip.cpp
@@ -332,8 +332,8 @@ bool isIntermediateContextType(IRInst* type)
     case kIROp_Specialize:
         return isIntermediateContextType(as<IRSpecialize>(type)->getBase());
     default:
-        if (as<IRPtrTypeBase>(type))
-            return isIntermediateContextType(as<IRPtrTypeBase>(type)->getValueType());
+        if (auto ptrType = asRelevantPtrType(type))
+            return isIntermediateContextType(ptrType->getValueType());
         return false;
     }
 }
diff --git a/source/slang/slang-ir-autodiff-unzip.h b/source/slang/slang-ir-autodiff-unzip.h
@@ -75,16 +75,15 @@ struct DiffUnzipPass
              primalParam = primalParam->getNextParam())
         {
             auto type = primalParam->getFullType();
-            if (auto ptrType = as<IRPtrTypeBase>(type))
+            if (auto ptrType = asRelevantPtrType(type))
             {
                 type = ptrType->getValueType();
             }
             if (auto pairType = as<IRDifferentialPairType>(type))
             {
                 IRInst* diffType = diffTypeContext.getDiffTypeFromPairType(builder, pairType);
-                if (as<IRPtrTypeBase>(primalParam->getFullType()))
-                    diffType =
-                        builder->getPtrType(primalParam->getFullType()->getOp(), (IRType*)diffType);
+                if (auto ptrType = asRelevantPtrType(primalParam->getFullType()))
+                    diffType = builder->getPtrType(ptrType->getOp(), (IRType*)diffType);
                 auto primalRef = builder->emitPrimalParamRef(primalParam);
                 auto diffRef = builder->emitDiffParamRef((IRType*)diffType, primalParam);
                 builder->markInstAsDifferential(diffRef, pairType->getValueType());
diff --git a/source/slang/slang-ir-autodiff.cpp b/source/slang/slang-ir-autodiff.cpp
@@ -135,7 +135,7 @@ bool isNoDiffType(IRType* paramType)
 
             paramType = attrType->getBaseType();
         }
-        else if (auto ptrType = as<IRPtrTypeBase>(paramType))
+        else if (auto ptrType = asRelevantPtrType(paramType))
         {
             paramType = ptrType->getValueType();
         }
@@ -184,7 +184,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(
     IRStructKey* key)
 {
     IRInst* pairType = nullptr;
-    if (auto basePtrType = as<IRPtrTypeBase>(baseInst->getDataType()))
+    if (auto basePtrType = asRelevantPtrType(baseInst->getDataType()))
     {
         auto loweredType = lowerDiffPairType(builder, basePtrType->getValueType());
 
@@ -203,7 +203,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(
             baseInst,
             key));
     }
-    else if (auto ptrType = as<IRPtrTypeBase>(pairType))
+    else if (auto ptrType = asRelevantPtrType(pairType))
     {
         if (auto ptrInnerSpecializedType = as<IRSpecialize>(ptrType->getValueType()))
         {
@@ -240,7 +240,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(
                 baseInst,
                 key));
         }
-        else if (auto genericPtrType = as<IRPtrTypeBase>(genericType))
+        else if (auto genericPtrType = asRelevantPtrType(genericType))
         {
             if (auto genericPairStructType = as<IRStructType>(genericPtrType->getValueType()))
             {
@@ -1646,7 +1646,7 @@ IRType* DifferentiableTypeConformanceContext::differentiateType(
     IRBuilder* builder,
     IRInst* primalType)
 {
-    if (auto ptrType = as<IRPtrTypeBase>(primalType))
+    if (auto ptrType = asRelevantPtrType(primalType))
         return builder->getPtrType(
             primalType->getOp(),
             differentiateType(builder, ptrType->getValueType()));
diff --git a/source/slang/slang-ir-autodiff.h b/source/slang/slang-ir-autodiff.h
@@ -604,7 +604,7 @@ inline bool isRelevantDifferentialPair(IRType* type)
     {
         return true;
     }
-    else if (auto argPtrType = as<IRPtrTypeBase>(type))
+    else if (auto argPtrType = asRelevantPtrType(type))
     {
         if (as<IRDifferentialPairType>(argPtrType->getValueType()))
         {
diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp
@@ -1528,14 +1528,24 @@ bool isOne(IRInst* inst)
     }
 }
 
+IRPtrTypeBase* asRelevantPtrType(IRInst* inst)
+{
+    if (auto ptrType = as<IRPtrTypeBase>(inst))
+    {
+        if (ptrType->getAddressSpace() != AddressSpace::UserPointer)
+            return ptrType;
+    }
+    return nullptr;
+}
+
 IRPtrTypeBase* isMutablePointerType(IRInst* inst)
 {
     switch (inst->getOp())
     {
     case kIROp_ConstRefType:
         return nullptr;
     default:
-        return as<IRPtrTypeBase>(inst);
+        return asRelevantPtrType(inst);
     }
 }
 
diff --git a/source/slang/slang-ir-util.h b/source/slang/slang-ir-util.h
@@ -271,6 +271,10 @@ bool isZero(IRInst* inst);
 
 bool isOne(IRInst* inst);
 
+// Casts inst to IRPtrTypeBase, excluding UserPointer address space.
+IRPtrTypeBase* asRelevantPtrType(IRInst* inst);
+
+// Returns the pointer type if it is pointer type that is not a const ref or a user pointer.
 IRPtrTypeBase* isMutablePointerType(IRInst* inst);
 
 void initializeScratchData(IRInst* inst);

Original file line number	Diff line number	Diff line change
`@@ -1777,7 +1777,7 @@ void insertTempVarForMutableParams(IRModule* module, IRFunc* func)`
`1777`	`1777`
`1778`	`1778`	`for (auto param : params)`
`1779`	`1779`	`{`
`1780`		`- auto ptrType = as<IRPtrTypeBase>(param->getDataType());`
	`1780`	`+ auto ptrType = asRelevantPtrType(param->getDataType());`
`1781`	`1781`	`auto tempVar = builder.emitVar(ptrType->getValueType());`
`1782`	`1782`	`param->replaceUsesWith(tempVar);`
`1783`	`1783`	`mapParamToTempVar[param] = tempVar;`
`@@ -2245,7 +2245,7 @@ InstPair ForwardDiffTranscriber::transcribeFuncParam(`
`2245`	`2245`	`builder->emitDifferentialPairGetPrimal(diffPairParam),`
`2246`	`2246`	`builder->emitDifferentialPairGetDifferential(diffType, diffPairParam));`
`2247`	`2247`	`}`
`2248`		`- else if (auto pairPtrType = as<IRPtrTypeBase>(diffPairType))`
	`2248`	`+ else if (auto pairPtrType = asRelevantPtrType(diffPairType))`
`2249`	`2249`	`{`
`2250`	`2250`	`auto ptrInnerPairType = as<IRDifferentialPairTypeBase>(pairPtrType->getValueType());`
`2251`	`2251`	`// Make a local copy of the parameter for primal and diff parts.`
Original file line number	Diff line number	Diff line change
`@@ -1174,7 +1174,7 @@ IRVar* emitIndexedLocalVar(`
`1174`	`1174`	`SourceLoc location)`
`1175`	`1175`	`{`
`1176`	`1176`	`// Cannot store pointers. Case should have been handled by now.`
`1177`		`- SLANG_RELEASE_ASSERT(!as<IRPtrTypeBase>(baseType));`
	`1177`	`+ SLANG_RELEASE_ASSERT(!asRelevantPtrType(baseType));`
`1178`	`1178`
`1179`	`1179`	`// Cannot store types. Case should have been handled by now.`
`1180`	`1180`	`SLANG_RELEASE_ASSERT(!as<IRTypeType>(baseType));`
`@@ -1656,7 +1656,7 @@ RefPtr<HoistedPrimalsInfo> ensurePrimalAvailability(`
`1656`	`1656`	`return true;`
`1657`	`1657`	`}`
`1658`	`1658`	`else if (`
`1659`		`- as<IRPtrTypeBase>(instToStore->getDataType()) &&`
	`1659`	`+ asRelevantPtrType(instToStore->getDataType()) &&`
`1660`	`1660`	`!isDifferentialOrRecomputeBlock(defBlock))`
`1661`	`1661`	`{`
`1662`	`1662`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -370,7 +370,7 @@ IRType* BackwardDiffTranscriberBase::transcribeParamTypeForPropagateFunc(`
`370`	`370`	`auto diffPairType = tryGetDiffPairType(builder, paramType);`
`371`	`371`	`if (diffPairType)`
`372`	`372`	`{`
`373`		`- if (!as<IRPtrTypeBase>(diffPairType) && !as<IRDifferentialPtrPairType>(diffPairType))`
	`373`	`+ if (!asRelevantPtrType(diffPairType) && !as<IRDifferentialPtrPairType>(diffPairType))`
`374`	`374`	`return builder->getInOutType(diffPairType);`
`375`	`375`	`return diffPairType;`
`376`	`376`	`}`
`@@ -514,7 +514,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF`
`514`	`514`	`{`
`515`	`515`	`// As long as the primal parameter is not an out or constref type,`
`516`	`516`	`// we need to fetch the primal value from the parameter.`
`517`		`- if (as<IRPtrTypeBase>(propagateParamType))`
	`517`	`+ if (asRelevantPtrType(propagateParamType))`
`518`	`518`	`{`
`519`	`519`	`primalArg = builder.emitLoad(param);`
`520`	`520`	`}`
`@@ -544,7 +544,7 @@ InstPair BackwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRF`
`544`	`544`	`}`
`545`	`545`	`else`
`546`	`546`	`{`
`547`		`- auto primalPtrType = as<IRPtrTypeBase>(primalParamType);`
	`547`	`+ auto primalPtrType = asRelevantPtrType(primalParamType);`
`548`	`548`	`SLANG_RELEASE_ASSERT(primalPtrType);`
`549`	`549`	`auto primalValueType = primalPtrType->getValueType();`
`550`	`550`	`auto var = builder.emitVar(primalValueType);`
Original file line number	Diff line number	Diff line change
`@@ -619,7 +619,7 @@ struct DiffTransposePass`
`619`	`619`	`if (isDifferentialInst(varInst) && tryGetPrimalTypeFromDiffInst(varInst))`
`620`	`620`	`{`
`621`	`621`	`if (auto ptrPrimalType =`
`622`		`- as<IRPtrTypeBase>(tryGetPrimalTypeFromDiffInst(varInst)))`
	`622`	`+ asRelevantPtrType(tryGetPrimalTypeFromDiffInst(varInst)))`
`623`	`623`	`{`
`624`	`624`	`varInst->insertAtEnd(firstRevDiffBlock);`
`625`	`625`
`@@ -1119,7 +1119,7 @@ struct DiffTransposePass`
`1119`	`1119`
`1120`	`1120`	`auto getDiffPairType = [](IRType* type)`
`1121`	`1121`	`{`
`1122`		`- if (auto ptrType = as<IRPtrTypeBase>(type))`
	`1122`	`+ if (auto ptrType = asRelevantPtrType(type))`
`1123`	`1123`	`type = ptrType->getValueType();`
`1124`	`1124`	`return as<IRDifferentialPairType>(type);`
`1125`	`1125`	`};`
`@@ -1168,7 +1168,7 @@ struct DiffTransposePass`
`1168`	`1168`	`argRequiresLoad.add(false);`
`1169`	`1169`	`writebacks.add(DiffValWriteBack{instPair->getDiff(), tempVar});`
`1170`	`1170`	`}`
`1171`		`- else if (!as<IRPtrTypeBase>(arg->getDataType()) && getDiffPairType(arg->getDataType()))`
	`1171`	`+ else if (!asRelevantPtrType(arg->getDataType()) && getDiffPairType(arg->getDataType()))`
`1172`	`1172`	`{`
`1173`	`1173`	`// Normal differentiable input parameter will become an inout DiffPair parameter`
`1174`	`1174`	`// in the propagate func. The split logic has already prepared the initial value`
`@@ -1241,7 +1241,6 @@ struct DiffTransposePass`
`1241`	`1241`	`argRequiresLoad.add(false);`
`1242`	`1242`	`}`
`1243`	`1243`
`1244`		`-`
`1245`	`1244`	`auto revFnType =`
`1246`	`1245`	`this->autodiffContext->transcriberSet.propagateTranscriber->differentiateFunctionType(`
`1247`	`1246`	`builder,`
Original file line number	Diff line number	Diff line change
`@@ -332,8 +332,8 @@ bool isIntermediateContextType(IRInst* type)`
`332`	`332`	`case kIROp_Specialize:`
`333`	`333`	`return isIntermediateContextType(as<IRSpecialize>(type)->getBase());`
`334`	`334`	`default:`
`335`		`- if (as<IRPtrTypeBase>(type))`
`336`		`- return isIntermediateContextType(as<IRPtrTypeBase>(type)->getValueType());`
	`335`	`+ if (auto ptrType = asRelevantPtrType(type))`
	`336`	`+ return isIntermediateContextType(ptrType->getValueType());`
`337`	`337`	`return false;`
`338`	`338`	`}`
`339`	`339`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,16 +75,15 @@ struct DiffUnzipPass`
`75`	`75`	`primalParam = primalParam->getNextParam())`
`76`	`76`	`{`
`77`	`77`	`auto type = primalParam->getFullType();`
`78`		`- if (auto ptrType = as<IRPtrTypeBase>(type))`
	`78`	`+ if (auto ptrType = asRelevantPtrType(type))`
`79`	`79`	`{`
`80`	`80`	`type = ptrType->getValueType();`
`81`	`81`	`}`
`82`	`82`	`if (auto pairType = as<IRDifferentialPairType>(type))`
`83`	`83`	`{`
`84`	`84`	`IRInst* diffType = diffTypeContext.getDiffTypeFromPairType(builder, pairType);`
`85`		`- if (as<IRPtrTypeBase>(primalParam->getFullType()))`
`86`		`- diffType =`
`87`		`- builder->getPtrType(primalParam->getFullType()->getOp(), (IRType*)diffType);`
	`85`	`+ if (auto ptrType = asRelevantPtrType(primalParam->getFullType()))`
	`86`	`+ diffType = builder->getPtrType(ptrType->getOp(), (IRType*)diffType);`
`88`	`87`	`auto primalRef = builder->emitPrimalParamRef(primalParam);`
`89`	`88`	`auto diffRef = builder->emitDiffParamRef((IRType*)diffType, primalParam);`
`90`	`89`	`builder->markInstAsDifferential(diffRef, pairType->getValueType());`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ bool isNoDiffType(IRType* paramType)`
`135`	`135`
`136`	`136`	`paramType = attrType->getBaseType();`
`137`	`137`	`}`
`138`		`- else if (auto ptrType = as<IRPtrTypeBase>(paramType))`
	`138`	`+ else if (auto ptrType = asRelevantPtrType(paramType))`
`139`	`139`	`{`
`140`	`140`	`paramType = ptrType->getValueType();`
`141`	`141`	`}`
`@@ -184,7 +184,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(`
`184`	`184`	`IRStructKey* key)`
`185`	`185`	`{`
`186`	`186`	`IRInst* pairType = nullptr;`
`187`		`- if (auto basePtrType = as<IRPtrTypeBase>(baseInst->getDataType()))`
	`187`	`+ if (auto basePtrType = asRelevantPtrType(baseInst->getDataType()))`
`188`	`188`	`{`
`189`	`189`	`auto loweredType = lowerDiffPairType(builder, basePtrType->getValueType());`
`190`	`190`
`@@ -203,7 +203,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(`
`203`	`203`	`baseInst,`
`204`	`204`	`key));`
`205`	`205`	`}`
`206`		`- else if (auto ptrType = as<IRPtrTypeBase>(pairType))`
	`206`	`+ else if (auto ptrType = asRelevantPtrType(pairType))`
`207`	`207`	`{`
`208`	`208`	`if (auto ptrInnerSpecializedType = as<IRSpecialize>(ptrType->getValueType()))`
`209`	`209`	`{`
`@@ -240,7 +240,7 @@ IRInst* DifferentialPairTypeBuilder::emitFieldAccessor(`
`240`	`240`	`baseInst,`
`241`	`241`	`key));`
`242`	`242`	`}`
`243`		`- else if (auto genericPtrType = as<IRPtrTypeBase>(genericType))`
	`243`	`+ else if (auto genericPtrType = asRelevantPtrType(genericType))`
`244`	`244`	`{`
`245`	`245`	`if (auto genericPairStructType = as<IRStructType>(genericPtrType->getValueType()))`
`246`	`246`	`{`
`@@ -1646,7 +1646,7 @@ IRType* DifferentiableTypeConformanceContext::differentiateType(`
`1646`	`1646`	`IRBuilder* builder,`
`1647`	`1647`	`IRInst* primalType)`
`1648`	`1648`	`{`
`1649`		`- if (auto ptrType = as<IRPtrTypeBase>(primalType))`
	`1649`	`+ if (auto ptrType = asRelevantPtrType(primalType))`
`1650`	`1650`	`return builder->getPtrType(`
`1651`	`1651`	`primalType->getOp(),`
`1652`	`1652`	`differentiateType(builder, ptrType->getValueType()));`
Original file line number	Diff line number	Diff line change
`@@ -604,7 +604,7 @@ inline bool isRelevantDifferentialPair(IRType* type)`
`604`	`604`	`{`
`605`	`605`	`return true;`
`606`	`606`	`}`
`607`		`- else if (auto argPtrType = as<IRPtrTypeBase>(type))`
	`607`	`+ else if (auto argPtrType = asRelevantPtrType(type))`
`608`	`608`	`{`
`609`	`609`	`if (as<IRDifferentialPairType>(argPtrType->getValueType()))`
`610`	`610`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1528,14 +1528,24 @@ bool isOne(IRInst* inst)`
`1528`	`1528`	`}`
`1529`	`1529`	`}`
`1530`	`1530`
	`1531`	`+IRPtrTypeBase* asRelevantPtrType(IRInst* inst)`
	`1532`	`+{`
	`1533`	`+ if (auto ptrType = as<IRPtrTypeBase>(inst))`
	`1534`	`+ {`
	`1535`	`+ if (ptrType->getAddressSpace() != AddressSpace::UserPointer)`
	`1536`	`+ return ptrType;`
	`1537`	`+ }`
	`1538`	`+ return nullptr;`
	`1539`	`+}`
	`1540`	`+`
`1531`	`1541`	`IRPtrTypeBase* isMutablePointerType(IRInst* inst)`
`1532`	`1542`	`{`
`1533`	`1543`	`switch (inst->getOp())`
`1534`	`1544`	`{`
`1535`	`1545`	`case kIROp_ConstRefType:`
`1536`	`1546`	`return nullptr;`
`1537`	`1547`	`default:`
`1538`		`- return as<IRPtrTypeBase>(inst);`
	`1548`	`+ return asRelevantPtrType(inst);`
`1539`	`1549`	`}`
`1540`	`1550`	`}`
`1541`	`1551`