Revert "Fix nullptr in generic specialization" and add emitPtrLit instead

Author: juliusikkala

source/slang/slang-ir-clone.cpp

@@ -51,17 +51,27 @@ IRInst* cloneInstAndOperands(IRCloneEnv* env, IRBuilder* builder, IRInst* oldIns
     SLANG_ASSERT(builder);
     SLANG_ASSERT(oldInst);
 
-    // IRConstants contain data other than just the operands, so cloning them
-    // is done separately.
-    IRConstant* oldConstant = as<IRConstant>(oldInst);
-    if (oldConstant)
+    // Pointer literals need to be handled separately, as they carry other data
+    // than just the operands.
+    if (oldInst->getOp() == kIROp_PtrLit)
     {
-        IRConstant* newConstant = builder->getClonedConstantValue(*oldConstant);
-        builder->addInst(newConstant);
-        newConstant->sourceLoc = oldInst->sourceLoc;
-        return newConstant;
+        auto oldPtr = as<IRPtrLit>(oldInst);
+        auto newInst = builder->emitPtrLit(oldPtr->getFullType(), oldPtr->value.ptrVal);
+        newInst->sourceLoc = oldPtr->sourceLoc;
+        return newInst;
     }
 
+    // This logic will not handle any instructions
+    // with special-case data attached, but that only
+    // applies to `IRConstant`s at this point, and those
+    // should only appear at the global scope rather than
+    // in function bodies.
+    //
+    // TODO: It would be easy enough to extend this logic
+    // to handle constants gracefully, if it ever comes up.
+    //
+    SLANG_ASSERT(!as<IRConstant>(oldInst));
+
     // We start by mapping the type of the orignal instruction
     // to its replacement value, if any.
     //

source/slang/slang-ir-insts.h

@@ -3601,7 +3601,6 @@ struct IRBuilder
     IRPtrLit* getNullVoidPtrValue() { return getNullPtrValue(getPtrType(getVoidType())); }
     IRVoidLit* getVoidValue();
     IRInst* getCapabilityValue(CapabilitySet const& caps);
-    IRConstant* getClonedConstantValue(IRConstant& value);
 
     IRBasicType* getBasicType(BaseType baseType);
     IRBasicType* getVoidType();
@@ -4434,6 +4433,8 @@ struct IRBuilder
 
     IRGlobalConstant* emitGlobalConstant(IRType* type, IRInst* val);
 
+    IRConstant* emitPtrLit(IRType* type, void* ptr);
+
     IRInst* emitWaveMaskBallot(IRType* type, IRInst* mask, IRInst* condition);
     IRInst* emitWaveMaskMatch(IRType* type, IRInst* mask, IRInst* value);
 

source/slang/slang-ir.cpp

@@ -2192,7 +2192,71 @@ IRConstant* IRBuilder::_findOrEmitConstant(IRConstant& keyInst)
         return irValue;
     }
 
-    irValue = getClonedConstantValue(keyInst);
+    // Calculate the minimum object size (ie not including the payload of value)
+    const size_t prefixSize = SLANG_OFFSET_OF(IRConstant, value);
+
+    switch (keyInst.getOp())
+    {
+    default:
+        SLANG_UNEXPECTED("missing case for IR constant");
+        break;
+
+    case kIROp_BoolLit:
+    case kIROp_IntLit:
+        {
+            const size_t instSize = prefixSize + sizeof(IRIntegerValue);
+            irValue = static_cast<IRConstant*>(
+                _createInst(instSize, keyInst.getFullType(), keyInst.getOp()));
+            irValue->value.intVal = keyInst.value.intVal;
+            break;
+        }
+    case kIROp_FloatLit:
+        {
+            const size_t instSize = prefixSize + sizeof(IRFloatingPointValue);
+            irValue = static_cast<IRConstant*>(
+                _createInst(instSize, keyInst.getFullType(), keyInst.getOp()));
+            irValue->value.floatVal = keyInst.value.floatVal;
+            break;
+        }
+    case kIROp_PtrLit:
+        {
+            const size_t instSize = prefixSize + sizeof(void*);
+            irValue = static_cast<IRConstant*>(
+                _createInst(instSize, keyInst.getFullType(), keyInst.getOp()));
+            irValue->value.ptrVal = keyInst.value.ptrVal;
+            break;
+        }
+    case kIROp_VoidLit:
+        {
+            const size_t instSize = prefixSize + sizeof(void*);
+            irValue = static_cast<IRConstant*>(
+                _createInst(instSize, keyInst.getFullType(), keyInst.getOp()));
+            irValue->value.ptrVal = keyInst.value.ptrVal;
+            break;
+        }
+    case kIROp_BlobLit:
+    case kIROp_StringLit:
+        {
+            const UnownedStringSlice slice = keyInst.getStringSlice();
+
+            const size_t sliceSize = slice.getLength();
+            const size_t instSize =
+                prefixSize + offsetof(IRConstant::StringValue, chars) + sliceSize;
+
+            irValue = static_cast<IRConstant*>(
+                _createInst(instSize, keyInst.getFullType(), keyInst.getOp()));
+
+            IRConstant::StringValue& dstString = irValue->value.stringVal;
+
+            dstString.numChars = uint32_t(sliceSize);
+            // Turn into pointer to avoid warning of array overrun
+            char* dstChars = dstString.chars;
+            // Copy the chars
+            memcpy(dstChars, slice.begin(), sliceSize);
+
+            break;
+        }
+    }
 
     key.inst = irValue;
     m_dedupContext->getConstantMap().add(key, irValue);
@@ -2405,79 +2469,6 @@ IRInst* IRBuilder::getCapabilityValue(CapabilitySet const& caps)
         conjunctions.getBuffer());
 }
 
-IRConstant* IRBuilder::getClonedConstantValue(IRConstant& value)
-{
-    IRConstant* irValue = nullptr;
-
-    // Calculate the minimum object size (ie not including the payload of value)
-    const size_t prefixSize = SLANG_OFFSET_OF(IRConstant, value);
-
-    switch (value.getOp())
-    {
-    default:
-        SLANG_UNEXPECTED("missing case for IR constant");
-        break;
-
-    case kIROp_BoolLit:
-    case kIROp_IntLit:
-        {
-            const size_t instSize = prefixSize + sizeof(IRIntegerValue);
-            irValue =
-                static_cast<IRConstant*>(_createInst(instSize, value.getFullType(), value.getOp()));
-            irValue->value.intVal = value.value.intVal;
-            break;
-        }
-    case kIROp_FloatLit:
-        {
-            const size_t instSize = prefixSize + sizeof(IRFloatingPointValue);
-            irValue =
-                static_cast<IRConstant*>(_createInst(instSize, value.getFullType(), value.getOp()));
-            irValue->value.floatVal = value.value.floatVal;
-            break;
-        }
-    case kIROp_PtrLit:
-        {
-            const size_t instSize = prefixSize + sizeof(void*);
-            irValue =
-                static_cast<IRConstant*>(_createInst(instSize, value.getFullType(), value.getOp()));
-            irValue->value.ptrVal = value.value.ptrVal;
-            break;
-        }
-    case kIROp_VoidLit:
-        {
-            const size_t instSize = prefixSize + sizeof(void*);
-            irValue =
-                static_cast<IRConstant*>(_createInst(instSize, value.getFullType(), value.getOp()));
-            irValue->value.ptrVal = value.value.ptrVal;
-            break;
-        }
-    case kIROp_BlobLit:
-    case kIROp_StringLit:
-        {
-            const UnownedStringSlice slice = value.getStringSlice();
-
-            const size_t sliceSize = slice.getLength();
-            const size_t instSize =
-                prefixSize + offsetof(IRConstant::StringValue, chars) + sliceSize;
-
-            irValue =
-                static_cast<IRConstant*>(_createInst(instSize, value.getFullType(), value.getOp()));
-
-            IRConstant::StringValue& dstString = irValue->value.stringVal;
-
-            dstString.numChars = uint32_t(sliceSize);
-            // Turn into pointer to avoid warning of array overrun
-            char* dstChars = dstString.chars;
-            // Copy the chars
-            memcpy(dstChars, slice.begin(), sliceSize);
-
-            break;
-        }
-    }
-
-    return irValue;
-}
-
 static void canonicalizeInstOperands(IRBuilder& builder, IROp op, ArrayView<IRInst*> operands)
 {
     // For Array types, we always want to make sure its element count
@@ -5853,6 +5844,16 @@ IRGlobalConstant* IRBuilder::emitGlobalConstant(IRType* type, IRInst* val)
     return inst;
 }
 
+IRConstant* IRBuilder::emitPtrLit(IRType* type, void* ptrVal)
+{
+    const size_t prefixSize = SLANG_OFFSET_OF(IRConstant, value);
+    const size_t instSize = prefixSize + sizeof(void*);
+    auto inst = static_cast<IRConstant*>(_createInst(instSize, type, kIROp_PtrLit));
+    inst->value.ptrVal = ptrVal;
+    addInst(inst);
+    return inst;
+}
+
 IRInst* IRBuilder::emitWaveMaskBallot(IRType* type, IRInst* mask, IRInst* condition)
 {
     auto inst = createInst<IRInst>(this, kIROp_WaveMaskBallot, type, mask, condition);