Support pointers in SPIRV. (#3561)

* Support pointers in SPIRV.

* Fix test.

* Enhance test.

* Fix test.

* Cleanup.

25 files changed, 705 insertions, 58 deletions

diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index f3ab38582..1e1ef061e 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -719,19 +719,7 @@ struct Ptr
 
     __subscript(int index) -> T
     {
-        [__unsafeForceInlineEarly]
-        get
-        {
-            return __load(__getElementPtr(this, index));
-        }
-
-        [__unsafeForceInlineEarly]
-        set(T newValue)
-        {
-            __store(__getElementPtr(this, index), newValue);
-        }
-
-        __intrinsic_op($(kIROp_GetElementPtr))
+        __intrinsic_op($(kIROp_GetOffsetPtr))
         ref;
     }
 };
@@ -748,6 +736,12 @@ Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int index);
 __intrinsic_op($(kIROp_GetElementPtr))
 Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int64_t index);
 
+__intrinsic_op($(kIROp_GetOffsetPtr))
+Ptr<T> __getOffsetPtr<T>(Ptr<T> ptr, int index);
+
+__intrinsic_op($(kIROp_GetOffsetPtr))
+Ptr<T> __getOffsetPtr<T>(Ptr<T> ptr, int64_t index);
+
 __generic<T>
 __intrinsic_op($(kIROp_Less))
 bool operator<(Ptr<T> p1, Ptr<T> p2);
@@ -1543,14 +1537,14 @@ __intrinsic_op(0)
 __prefix Ptr<T> operator&(__ref T value);
 
 __generic<T>
-__intrinsic_op($(kIROp_GetElementPtr))
+__intrinsic_op($(kIROp_GetOffsetPtr))
 Ptr<T> operator+(Ptr<T> value, int64_t offset);
 
 __generic<T>
 [__unsafeForceInlineEarly]
 Ptr<T> operator-(Ptr<T> value, int64_t offset)
 {
-    return __getElementPtr(value, -offset);
+    return __getOffsetPtr(value, -offset);
 }
 
 __generic<T : IArithmetic>
diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index 8183c2030..156ecc194 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -13164,12 +13164,6 @@ struct ConstBufferPointer
         }
     }
 
-    __subscript(int index) -> T
-    {
-        [ForceInline]
-        get {return ConstBufferPointer<T>.fromUInt(toUInt() + __naturalStrideOf<T>() * index).get(); }
-    }
-
     __glsl_version(450)
     __glsl_extension(GL_EXT_shader_explicit_arithmetic_types_int64)
     __glsl_extension(GL_EXT_buffer_reference)
@@ -13221,4 +13215,10 @@ struct ConstBufferPointer
             };
         }
     }
+
+    __subscript(int index)->T
+    {
+        [ForceInline]
+        get { return ConstBufferPointer<T>.fromUInt(toUInt() + __naturalStrideOf<T>() * index).get(); }
+    }
 }
diff --git a/source/slang/slang-ast-iterator.h b/source/slang/slang-ast-iterator.h
index e2d0638e0..fc6f321e3 100644
--- a/source/slang/slang-ast-iterator.h
+++ b/source/slang/slang-ast-iterator.h
@@ -52,6 +52,10 @@ struct ASTIterator
         {
             iterator->maybeDispatchCallback(expr);
         }
+        void visitOpenRefExpr(OpenRefExpr* expr)
+        {
+            dispatchIfNotNull(expr->innerExpr);
+        }
         void visitFloatingPointLiteralExpr(FloatingPointLiteralExpr* expr)
         {
             iterator->maybeDispatchCallback(expr);
diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h
index 882e26078..c1984910c 100644
--- a/source/slang/slang-ast-support-types.h
+++ b/source/slang/slang-ast-support-types.h
@@ -109,6 +109,7 @@ namespace Slang
         kConversionCost_InRangeIntLitSignedToUnsignedConversion = 32,
         kConversionCost_InRangeIntLitUnsignedToSignedConversion = 81,
 
+        kConversionCost_MutablePtrToConstPtr = 20,
 
         // Conversions based on explicit sub-typing relationships are the cheapest
         //
diff --git a/source/slang/slang-ast-type.h b/source/slang/slang-ast-type.h
index 1d2ebc566..d47e3a496 100644
--- a/source/slang/slang-ast-type.h
+++ b/source/slang/slang-ast-type.h
@@ -535,7 +535,8 @@ class PtrType : public PtrTypeBase
     SLANG_AST_CLASS(PtrType)
 };
 
-// A GPU pointer type that for general readonly memory access.
+// A GPU pointer type into global memory.
+
 class ConstBufferPointerType : public PtrTypeBase
 {
     SLANG_AST_CLASS(ConstBufferPointerType)
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index f9adcc91a..2f4906826 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -479,7 +479,10 @@ namespace Slang
         derefExpr->base = base;
         derefExpr->type = QualType(elementType);
 
-        derefExpr->type.isLeftValue = base->type.isLeftValue;
+        if (as<PtrType>(base->type))
+            derefExpr->type.isLeftValue = true;
+        else
+            derefExpr->type.isLeftValue = base->type.isLeftValue;
 
         return derefExpr;
     }
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index 62bc73c90..9b599ae2e 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -782,6 +782,8 @@ DIAGNOSTIC(57001, Warning, spirvOptFailed, "spirv-opt failed. $0")
 DIAGNOSTIC(58001, Error, entryPointMustReturnVoidWhenGlobalOutputPresent, "entry point must return 'void' when global output variables are present.")
 DIAGNOSTIC(58002, Error, unhandledGLSLSSBOType, "Unhandled GLSL Shader Storage Buffer Object contents, unsized arrays as a final parameter must be the only parameter")
 
+DIAGNOSTIC(58003, Error, inconsistentPointerAddressSpace, "'$0': use of pointer with inconsistent address space.")
+
 //
 // 8xxxx - Issues specific to a particular library/technology/platform/etc.
 //
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index 05c525965..1c01478ed 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -2055,6 +2055,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
     case kIROp_MatrixReshape:
     case kIROp_CastPtrToInt:
     case kIROp_CastIntToPtr:
+    case kIROp_PtrCast:
     {
         // Simple constructor call
         auto prec = getInfo(EmitOp::Prefix);
@@ -2345,6 +2346,15 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
         m_writer->emit(".detach()");
         break;
     }
+    case kIROp_GetOffsetPtr:
+    {
+        auto prec = getInfo(EmitOp::Add);
+        needClose = maybeEmitParens(outerPrec, prec);
+        emitOperand(inst->getOperand(0), leftSide(outerPrec, prec));
+        m_writer->emit(" + ");
+        emitOperand(inst->getOperand(1), rightSide(prec, outerPrec));
+        break;
+    }
     case kIROp_GetElement:
     case kIROp_GetElementPtr:
     case kIROp_ImageSubscript:
@@ -4097,7 +4107,8 @@ void CLikeSourceEmitter::ensureGlobalInst(ComputeEmitActionsContext* ctx, IRInst
     }
     if (as<IRBasicType>(inst))
         return;
-
+    if (as<IRPtrLit>(inst))
+        return;
     // Certain inst ops will always emit as definition.
     switch (inst->getOp())
     {
diff --git a/source/slang/slang-emit-spirv-ops.h b/source/slang/slang-emit-spirv-ops.h
index 891372fa6..32f47b3ef 100644
--- a/source/slang/slang-emit-spirv-ops.h
+++ b/source/slang/slang-emit-spirv-ops.h
@@ -362,6 +362,20 @@ SpvInst* emitOpTypeStruct(IRInst* inst, const Ts& member0TypeMember1TypeEtc)
     );
 }
 
+// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpTypeForwardPointer
+template<typename T>
+SpvInst* emitOpTypeForwardPointer(const T& type, SpvStorageClass storageClass)
+{
+    static_assert(isSingular<T>);
+    return emitInst(
+        getSection(SpvLogicalSectionID::ConstantsAndTypes),
+        nullptr,
+        SpvOpTypeForwardPointer,
+        type,
+        storageClass
+    );
+}
+
 // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpTypePointer
 template<typename T>
 SpvInst* emitOpTypePointer(IRInst* inst, SpvStorageClass storageClass, const T& type)
@@ -623,6 +637,23 @@ SpvInst* emitOpAccessChain(
     return emitInst(parent, inst, SpvOpAccessChain, idResultType, kResultID, base, indexes);
 }
 
+
+// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpPtrAccessChain
+template<typename T1, typename T2, typename T3>
+SpvInst* emitOpPtrAccessChain(
+    SpvInstParent* parent,
+    IRInst* inst,
+    const T1& idResultType,
+    const T2& base,
+    const T3& element
+)
+{
+    static_assert(isSingular<T1>);
+    static_assert(isSingular<T2>);
+    static_assert(isSingular<T3>);
+    return emitInst(parent, inst, SpvOpPtrAccessChain, idResultType, kResultID, base, element);
+}
+
 // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpDecorate
 template<typename T>
 SpvInst* emitOpDecorate(
diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp
index 6e1e58755..d5d00e417 100644
--- a/source/slang/slang-emit-spirv.cpp
+++ b/source/slang/slang-emit-spirv.cpp
@@ -135,7 +135,6 @@ public:
         /// Dump all children, recursively, to a flattened list of SPIR-V words
     void dumpTo(List<SpvWord>& ioWords);
 
-private:
         /// The first child, if any.
     SpvInst* m_firstChild = nullptr;
 
@@ -145,7 +144,7 @@ private:
         /// while if it is non-empty it points to the `nextSibling` field
         /// of the last instruction.
         ///
-    SpvInst** m_link = &m_firstChild;
+    SpvInst* m_lastChild = nullptr;
 };
 
 // A SPIR-V instruction is then (in the general case) a potential
@@ -198,9 +197,13 @@ struct SpvInst : SpvInstParent
     // We will store the instructions in a given `SpvInstParent`
     // using an intrusive linked list.
 
+    SpvInstParent* parent = nullptr;
+
         /// The next instruction in the same `SpvInstParent`
     SpvInst* nextSibling = nullptr;
 
+    SpvInst* prevSibling = nullptr;
+    
         /// The result <id> produced by this instruction, or zero if it has no result.
     SpvWord id = 0;
 
@@ -235,6 +238,43 @@ struct SpvInst : SpvInstParent
         //
         SpvInstParent::dumpTo(ioWords);
     }
+
+    void removeFromParent()
+    {
+        auto oldParent = parent;
+
+        // If we don't currently have a parent, then
+        // we are doing fine.
+        if (!oldParent)
+            return;
+
+        auto pp = prevSibling;
+        auto nn = nextSibling;
+
+        if (pp)
+        {
+            SLANG_ASSERT(pp->parent == oldParent);
+            pp->nextSibling = nn;
+        }
+        else
+        {
+            oldParent->m_firstChild = nn;
+        }
+
+        if (nn)
+        {
+            SLANG_ASSERT(nn->parent == oldParent);
+            nn->prevSibling = pp;
+        }
+        else
+        {
+            oldParent->m_lastChild = pp;
+        }
+
+        prevSibling = nullptr;
+        nextSibling = nullptr;
+        parent = nullptr;
+    }
 };
 
     /// A logical section of a SPIR-V module
@@ -248,15 +288,22 @@ struct SpvLogicalSection : SpvInstParent
 void SpvInstParent::addInst(SpvInst* inst)
 {
     SLANG_ASSERT(inst);
+    SLANG_ASSERT(!inst->nextSibling);
+
+    if (m_firstChild == nullptr)
+    {
+        m_firstChild = m_lastChild = inst;
+        return;
+    }
 
     // The user shouldn't be trying to add multiple instructions at once.
     // If they really want that then they probably wanted to give `inst`
     // some children.
     //
-    SLANG_ASSERT(!inst->nextSibling);
-
-    *m_link = inst;
-    m_link = &inst->nextSibling;
+    m_lastChild->nextSibling = inst;
+    inst->prevSibling = m_lastChild;
+    inst->parent = this;
+    m_lastChild = inst;
 }
 
 void SpvInstParent::dumpTo(List<SpvWord>& ioWords)
@@ -429,6 +476,11 @@ struct SPIRVEmitContext
         /// The next destination `<id>` to allocate.
     SpvWord m_nextID = 1;
 
+    OrderedHashSet<IRPtrTypeBase*> m_forwardDeclaredPointers;
+
+        // A hash set to prevent redecorating the same spv inst.
+    HashSet<SpvId> m_decoratedSpvInsts;
+
     SpvAddressingModel m_addressingMode = SpvAddressingModelLogical;
 
     // We will store the logical sections of the SPIR-V module
@@ -1244,6 +1296,17 @@ struct SPIRVEmitContext
         return m_targetRequest->getHLSLToVulkanLayoutOptions()->shouldEmitSPIRVReflectionInfo();
     }
 
+    void requireVariablePointers()
+    {
+        if (m_addressingMode == SpvAddressingModelPhysicalStorageBuffer64)
+            return;
+        ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_variable_pointers"));
+        requireSPIRVCapability(SpvCapabilityVariablePointers);
+        ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_physical_storage_buffer"));
+        requireSPIRVCapability(SpvCapabilityPhysicalStorageBufferAddresses);
+        m_addressingMode = SpvAddressingModelPhysicalStorageBuffer64;
+    }
+
     // Next, let's look at emitting some of the instructions
     // that can occur at global scope.
 
@@ -1312,11 +1375,41 @@ struct SPIRVEmitContext
                     storageClass = (SpvStorageClass)ptrType->getAddressSpace();
                 if (storageClass == SpvStorageClassStorageBuffer)
                     ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_storage_buffer_storage_class"));
-                return emitOpTypePointer(
+                if (storageClass == SpvStorageClassPhysicalStorageBuffer)
+                {
+                    requireVariablePointers();
+                }
+                auto valueType = ptrType->getValueType();
+                // If we haven't emitted the inner type yet, we need to emit a forward declaration.
+                bool useForwardDeclaration = (!m_mapIRInstToSpvInst.containsKey(valueType)
+                    && as<IRStructType>(valueType)
+                    && storageClass == SpvStorageClassPhysicalStorageBuffer);
+                auto resultSpvType = emitOpTypePointer(
                     inst,
                     storageClass,
-                    inst->getOperand(0)
+                    useForwardDeclaration? getIRInstSpvID(valueType) : getID(ensureInst(valueType))
                 );
+                if (useForwardDeclaration)
+                {
+                    // After everything has been emitted, we will move the pointer definition to the end
+                    // of the Types & Constants section.
+                    if (m_forwardDeclaredPointers.add(ptrType))
+                        emitOpTypeForwardPointer(resultSpvType, storageClass);
+                }
+                if (storageClass == SpvStorageClassPhysicalStorageBuffer)
+                {
+                    if (m_decoratedSpvInsts.add(getID(resultSpvType)))
+                    {
+                        IRSizeAndAlignment sizeAndAlignment;
+                        getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment);
+                        emitOpDecorateArrayStride(
+                            getSection(SpvLogicalSectionID::Annotations),
+                            nullptr,
+                            resultSpvType,
+                            SpvLiteralInteger::from32((uint32_t)sizeAndAlignment.getStride()));
+                    }
+                }
+                return resultSpvType;
             }
         case kIROp_ConstantBufferType:
             SLANG_UNEXPECTED("Constant buffer type remaining in spirv emit");
@@ -1404,11 +1497,7 @@ struct SPIRVEmitContext
             return emitOpTypeHitObject(inst);
 
         case kIROp_HLSLConstBufferPointerType:
-            ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_variable_pointers"));
-            requireSPIRVCapability(SpvCapabilityVariablePointers);
-            ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_physical_storage_buffer"));
-            requireSPIRVCapability(SpvCapabilityPhysicalStorageBufferAddresses);
-            m_addressingMode = SpvAddressingModelPhysicalStorageBuffer64;
+            requireVariablePointers();
             return emitOpTypePointer(inst, SpvStorageClassPhysicalStorageBuffer, inst->getOperand(0));
 
         case kIROp_FuncType:
@@ -1446,6 +1535,7 @@ struct SPIRVEmitContext
         case kIROp_IntLit:
         case kIROp_FloatLit:
         case kIROp_StringLit:
+        case kIROp_PtrLit:
         {
             return emitLit(inst);
         }
@@ -1978,6 +2068,7 @@ struct SPIRVEmitContext
             param->getDataType(),
             storageClass
         );
+        maybeEmitPointerDecoration(varInst, param);
         if (auto layout = getVarLayout(param))
             emitVarLayout(param, varInst, layout);
         maybeEmitName(varInst, param);
@@ -2001,6 +2092,7 @@ struct SPIRVEmitContext
             globalVar->getDataType(),
             storageClass
         );
+        maybeEmitPointerDecoration(varInst, globalVar);
         if(layout)
             emitVarLayout(globalVar, varInst, layout);
         maybeEmitName(varInst, globalVar);
@@ -2274,6 +2366,8 @@ struct SPIRVEmitContext
             return emitFieldExtract(parent, as<IRFieldExtract>(inst));
         case kIROp_GetElementPtr:
             return emitGetElementPtr(parent, as<IRGetElementPtr>(inst));
+        case kIROp_GetOffsetPtr:
+            return emitGetOffsetPtr(parent, inst);
         case kIROp_GetElement:
             return emitGetElement(parent, as<IRGetElement>(inst));
         case kIROp_MakeStruct:
@@ -2306,6 +2400,13 @@ struct SPIRVEmitContext
             return emitIntToFloatCast(parent, as<IRCastIntToFloat>(inst));
         case kIROp_CastFloatToInt:
             return emitFloatToIntCast(parent, as<IRCastFloatToInt>(inst));
+        case kIROp_CastPtrToInt:
+            return emitCastPtrToInt(parent, inst);
+        case kIROp_CastPtrToBool:
+            return emitCastPtrToBool(parent, inst);
+        case kIROp_CastIntToPtr:
+            return emitCastIntToPtr(parent, inst);
+        case kIROp_PtrCast:
         case kIROp_BitCast:
             return emitOpBitcast(
                 parent,
@@ -3403,10 +3504,27 @@ struct SPIRVEmitContext
         return nullptr;
     }
 
+    void maybeEmitPointerDecoration(SpvInst* varInst, IRInst* inst)
+    {
+        auto ptrType = as<IRPtrType>(inst->getDataType());
+        if (!ptrType)
+            return;
+        if (ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        {
+            emitOpDecorate(
+                getSection(SpvLogicalSectionID::Annotations),
+                nullptr,
+                varInst,
+                (as<IRVar>(inst) ? SpvDecorationAliasedPointer : SpvDecorationAliased)
+            );
+        }
+    }
+
     SpvInst* emitParam(SpvInstParent* parent, IRInst* inst)
     {
         auto paramSpvInst = emitOpFunctionParameter(parent, inst, inst->getFullType());
         maybeEmitName(paramSpvInst, inst);
+        maybeEmitPointerDecoration(paramSpvInst, inst);
         return paramSpvInst;
     }
 
@@ -3421,6 +3539,7 @@ struct SPIRVEmitContext
         }
         auto varSpvInst = emitOpVariable(parent, inst, inst->getFullType(), storageClass);
         maybeEmitName(varSpvInst, inst);
+        maybeEmitPointerDecoration(varSpvInst, inst);
         return varSpvInst;
     }
 
@@ -3962,6 +4081,11 @@ struct SPIRVEmitContext
         );
     }
 
+    SpvInst* emitGetOffsetPtr(SpvInstParent* parent, IRInst* inst)
+    {
+        return emitOpPtrAccessChain(parent, inst, inst->getDataType(), inst->getOperand(0), inst->getOperand(1));
+    }
+
     SpvInst* emitGetElementPtr(SpvInstParent* parent, IRGetElementPtr* inst)
     {
         IRBuilder builder(m_irModule);
@@ -4025,12 +4149,32 @@ struct SPIRVEmitContext
 
     SpvInst* emitLoad(SpvInstParent* parent, IRLoad* inst)
     {
-        return emitOpLoad(parent, inst, inst->getDataType(), inst->getPtr());
+        auto ptrType = as<IRPtrTypeBase>(inst->getPtr()->getDataType());
+        if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        {
+            IRSizeAndAlignment sizeAndAlignment;
+            getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment);
+            return emitOpLoadAligned(parent, inst, inst->getDataType(), inst->getPtr(), SpvLiteralInteger::from32(sizeAndAlignment.alignment));
+        }
+        else
+        {
+            return emitOpLoad(parent, inst, inst->getDataType(), inst->getPtr());
+        }
     }
 
     SpvInst* emitStore(SpvInstParent* parent, IRStore* inst)
     {
-        return emitOpStore(parent, inst, inst->getPtr(), inst->getVal());
+        auto ptrType = as<IRPtrTypeBase>(inst->getPtr()->getDataType());
+        if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        {
+            IRSizeAndAlignment sizeAndAlignment;
+            getNaturalSizeAndAlignment(m_targetRequest, ptrType->getValueType(), &sizeAndAlignment);
+            return emitOpStoreAligned(parent, inst, inst->getPtr(), inst->getVal(), SpvLiteralInteger::from32(sizeAndAlignment.alignment));
+        }
+        else
+        {
+            return emitOpStore(parent, inst, inst->getPtr(), inst->getVal());
+        }
     }
 
     SpvInst* emitSwizzledStore(SpvInstParent* parent, IRSwizzledStore* inst)
@@ -4322,6 +4466,23 @@ struct SPIRVEmitContext
             : emitOpConvertFToU(parent, inst, toTypeV, inst->getOperand(0));
     }
 
+    SpvInst* emitCastPtrToInt(SpvInstParent* parent, IRInst* inst)
+    {
+        return emitInst(parent, inst, SpvOpConvertPtrToU, inst->getFullType(), kResultID, inst->getOperand(0));
+    }
+
+    SpvInst* emitCastPtrToBool(SpvInstParent* parent, IRInst* inst)
+    {
+        IRBuilder builder(inst);
+        auto uintVal = emitInst(parent, nullptr, SpvOpConvertPtrToU, builder.getUInt64Type(), kResultID, inst->getOperand(0));
+        return emitOpINotEqual(parent, inst, kResultID, uintVal, builder.getIntValue(builder.getUInt64Type(), 0));
+    }
+
+    SpvInst* emitCastIntToPtr(SpvInstParent* parent, IRInst* inst)
+    {
+        return emitInst(parent, inst, SpvOpConvertUToPtr, inst->getFullType(), kResultID, inst->getOperand(0));
+    }
+
     template<typename T, typename Ts>
     SpvInst* emitCompositeConstruct(
         SpvInstParent* parent,
@@ -5124,6 +5285,16 @@ SlangResult emitSPIRVFromIR(
     {
         context.ensureInst(irEntryPoint);
     }
+
+    // Move forward delcared pointers to the end.
+    for (auto ptrType : context.m_forwardDeclaredPointers)
+    {
+        auto spvPtrType = context.m_mapIRInstToSpvInst[ptrType];
+        auto parent = spvPtrType->parent;
+        spvPtrType->removeFromParent();
+        parent->addInst(spvPtrType);
+    }
+
     context.emitFrontMatter();
 
     context.emitPhysicalLayout();
diff --git a/source/slang/slang-ir-constexpr.cpp b/source/slang/slang-ir-constexpr.cpp
index 63ca32650..7a93a312c 100644
--- a/source/slang/slang-ir-constexpr.cpp
+++ b/source/slang/slang-ir-constexpr.cpp
@@ -112,6 +112,7 @@ bool opCanBeConstExpr(IROp op)
     case kIROp_CastIntToPtr:
     case kIROp_CastPtrToInt:
     case kIROp_CastPtrToBool:
+    case kIROp_PtrCast:
     case kIROp_Reinterpret:
     case kIROp_BitCast:
     case kIROp_MakeTuple:
diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h
index e183058ac..0c962b7a4 100644
--- a/source/slang/slang-ir-inst-defs.h
+++ b/source/slang/slang-ir-inst-defs.h
@@ -386,6 +386,8 @@ INST(FieldAddress, get_field_addr, 2, 0)
 
 INST(GetElement, getElement, 2, 0)
 INST(GetElementPtr, getElementPtr, 2, 0)
+// Pointer offset: computes pBase + offset_in_elements
+INST(GetOffsetPtr, getOffsetPtr, 2, 0) 
 INST(GetAddr, getAddr, 1, 0)
 
 // Get an unowned NativeString from a String.
@@ -1011,6 +1013,7 @@ INST(CastPtrToBool, CastPtrToBool, 1, 0)
 INST(CastPtrToInt, CastPtrToInt, 1, 0)
 INST(CastIntToPtr, CastIntToPtr, 1, 0)
 INST(CastToVoid, castToVoid, 1, 0)
+INST(PtrCast, PtrCast, 1, 0)
 
 INST(SizeOf,                            sizeOf,                     1, 0)
 INST(AlignOf,                           alignOf,                    1, 0)
diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h
index 6e3821c18..82d891459 100644
--- a/source/slang/slang-ir-insts.h
+++ b/source/slang/slang-ir-insts.h
@@ -2216,7 +2216,6 @@ struct IRFieldAddress : IRInst
     IRInst* getBase() { return base.get(); }
     IRInst* getField() { return field.get(); }
     IR_LEAF_ISA(FieldAddress)
-
 };
 
 struct IRGetElement : IRInst
@@ -4065,6 +4064,8 @@ public:
         IRInst* sizedType);
 
     IRInst* emitCastPtrToBool(IRInst* val);
+    IRInst* emitCastPtrToInt(IRInst* val);
+    IRInst* emitCastIntToPtr(IRType* ptrType, IRInst* val);
 
     IRGlobalConstant* emitGlobalConstant(
         IRType* type);
diff --git a/source/slang/slang-ir-link.cpp b/source/slang/slang-ir-link.cpp
index 36769cc34..eb0068657 100644
--- a/source/slang/slang-ir-link.cpp
+++ b/source/slang/slang-ir-link.cpp
@@ -276,7 +276,7 @@ IRInst* IRSpecContext::maybeCloneValue(IRInst* originalValue)
         {
             IRConstant* c = (IRConstant*)originalValue;
             SLANG_RELEASE_ASSERT(c->value.ptrVal == nullptr);
-            return builder->getNullVoidPtrValue();
+            return builder->getNullPtrValue(cloneType(this, c->getFullType()));
         }
         break;
 
diff --git a/source/slang/slang-ir-liveness.cpp b/source/slang/slang-ir-liveness.cpp
index 9cd4462af..28cd64a08 100644
--- a/source/slang/slang-ir-liveness.cpp
+++ b/source/slang/slang-ir-liveness.cpp
@@ -1029,6 +1029,7 @@ bool LivenessContext::_isAccessTerminator(IRTerminatorInst* terminator)
         case kIROp_CastIntToPtr:
         case kIROp_CastPtrToInt:
         case kIROp_CastPtrToBool:
+        case kIROp_PtrCast:
             val = val->getOperand(0);
             break;
         }
diff --git a/source/slang/slang-ir-peephole.cpp b/source/slang/slang-ir-peephole.cpp
index fb67c6842..39a137490 100644
--- a/source/slang/slang-ir-peephole.cpp
+++ b/source/slang/slang-ir-peephole.cpp
@@ -581,7 +581,7 @@ struct PeepholeContext : InstPassBase
                 auto ptr = inst->getOperand(0);
                 IRBuilder builder(module);
                 builder.setInsertBefore(inst);
-                auto neq = builder.emitNeq(ptr, builder.getNullVoidPtrValue());
+                auto neq = builder.emitNeq(ptr, builder.getNullPtrValue(ptr->getDataType()));
                 inst->replaceUsesWith(neq);
                 maybeRemoveOldInst(inst);
                 changed = true;
diff --git a/source/slang/slang-ir-specialize.cpp b/source/slang/slang-ir-specialize.cpp
index b82daa9a4..60001661c 100644
--- a/source/slang/slang-ir-specialize.cpp
+++ b/source/slang/slang-ir-specialize.cpp
@@ -1995,11 +1995,6 @@ struct SpecializationContext
         {
             return 2;
         }
-        else if (auto ptrType = as<IRPtrTypeBase>(type))
-        {
-            type = ptrType->getValueType();
-            goto top;
-        }
         else if (auto ptrLikeType = as<IRPointerLikeType>(type))
         {
             type = ptrLikeType->getElementType();
diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp
index 1675fe279..474ebc71c 100644
--- a/source/slang/slang-ir-spirv-legalize.cpp
+++ b/source/slang/slang-ir-spirv-legalize.cpp
@@ -741,6 +741,66 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         return result;
     }
 
+    void processVar(IRInst* inst)
+    {
+        auto oldPtrType = as<IRPtrType>(inst->getDataType());
+        if (!oldPtrType->hasAddressSpace())
+        {
+            IRBuilder builder(inst);
+            builder.setInsertBefore(inst);
+            auto newPtrType = builder.getPtrType(
+                oldPtrType->getOp(), oldPtrType->getValueType(), SpvStorageClassFunction);
+            inst->setFullType(newPtrType);
+            addUsersToWorkList(inst);
+        }
+    }
+
+    void processParam(IRInst* inst)
+    {
+        auto block = getBlock(inst);
+        auto func = getParentFunc(block);
+        if (!block || !func)
+            return;
+        auto oldPtrType = as<IRPtrType>(inst->getDataType());
+        if (!oldPtrType)
+            return;
+        if (!oldPtrType->hasAddressSpace())
+        {
+            SpvStorageClass addressSpace = (SpvStorageClass)-1;
+
+            if (block == func->getFirstBlock())
+            {
+                // A pointer typed function parameter should always be in the storage buffer address space.
+                addressSpace = SpvStorageClassPhysicalStorageBuffer;
+            }
+            else
+            {
+                // The address space of a phi inst should always be the same as arguments.
+                auto args = getPhiArgs(inst);
+                for (auto arg : args)
+                {
+                    auto argPtrType = as<IRPtrType>(arg->getDataType());
+                    if (argPtrType->hasAddressSpace())
+                    {
+                        if (addressSpace == (SpvStorageClass)-1)
+                            addressSpace = (SpvStorageClass)argPtrType->getAddressSpace();
+                        else if (addressSpace != argPtrType->getAddressSpace())
+                            m_sharedContext->m_sink->diagnose(inst, Diagnostics::inconsistentPointerAddressSpace, inst);
+                    }
+                }
+            }
+            if (addressSpace != (SpvStorageClass)-1)
+            {
+                IRBuilder builder(inst);
+                builder.setInsertBefore(inst);
+                auto newPtrType = builder.getPtrType(
+                    oldPtrType->getOp(), oldPtrType->getValueType(), SpvStorageClassPhysicalStorageBuffer);
+                inst->setFullType(newPtrType);
+                addUsersToWorkList(inst);
+            }
+        }
+    }
+
     void processGlobalVar(IRInst* inst)
     {
         auto oldPtrType = as<IRPtrTypeBase>(inst->getDataType());
@@ -844,6 +904,16 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         for (UInt i = 0; i < inst->getArgCount(); i++)
         {
             auto arg = inst->getArg(i);
+            auto paramType = funcType->getParamType(i);
+            if (as<IRPtrType>(paramType))
+            {
+                // If the parameter has an explicit pointer type,
+                // then we know the user is using the variable pointer
+                // capability to pass a true pointer.
+                // In this case we should not rewrite the call.
+                newArgs.add(arg);
+                continue;
+            }
             auto ptrType = as<IRPtrTypeBase>(arg->getDataType());
             if (!as<IRPtrTypeBase>(arg->getDataType()))
             {
@@ -898,7 +968,10 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         SLANG_ASSERT((UInt)newArgs.getCount() == inst->getArgCount());
         if (writeBacks.getCount())
         {
-            auto newCall = builder.emitCallInst(inst->getFullType(), inst->getCallee(), newArgs);
+            auto newCall = builder.emitCallInst(
+                translateToStorageBufferPointer(inst->getFullType()),
+                inst->getCallee(),
+                newArgs);
             for (auto wb : writeBacks)
             {
                 auto newVal = builder.emitLoad(wb.tempVar);
@@ -908,6 +981,10 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             inst->removeAndDeallocate();
             addUsersToWorkList(newCall);
         }
+        else
+        {
+            translatePtrResultType(inst);
+        }
     }
 
     Dictionary<IRInst*, IRInst*> m_mapArrayValueToVar;
@@ -989,6 +1066,28 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         processGetElementPtrImpl(gepInst, gepInst->getBase(), gepInst->getIndex());
     }
 
+    void processGetOffsetPtr(IRInst* offsetPtrInst)
+    {
+        auto ptrOperandType = as<IRPtrType>(offsetPtrInst->getOperand(0)->getDataType());
+        if (!ptrOperandType)
+            return;
+        if (!ptrOperandType->hasAddressSpace())
+            return;
+        auto resultPtrType = as<IRPtrType>(offsetPtrInst->getDataType());
+        if (!resultPtrType)
+            return;
+        if (resultPtrType->getAddressSpace() != ptrOperandType->getAddressSpace())
+        {
+            IRBuilder builder(offsetPtrInst);
+            builder.setInsertBefore(offsetPtrInst);
+            auto newResultType = builder.getPtrType(resultPtrType->getOp(),
+                resultPtrType->getValueType(),
+                ptrOperandType->getAddressSpace());
+            auto newInst = builder.replaceOperand(&offsetPtrInst->typeUse, newResultType);
+            addUsersToWorkList(newInst);
+        }
+    }
+
     void processStructuredBufferLoad(IRInst* loadInst)
     {
         auto sb = loadInst->getOperand(0);
@@ -1060,13 +1159,16 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             if (!ptrType->hasAddressSpace())
                 return;
             auto oldResultType = as<IRPtrTypeBase>(inst->getDataType());
-            if (oldResultType->getAddressSpace() != ptrType->getAddressSpace())
+            auto oldValueType = oldResultType->getValueType();
+            auto newValueType = translateToStorageBufferPointer(oldValueType);
+            
+            if (oldValueType != newValueType || oldResultType->getAddressSpace() != ptrType->getAddressSpace())
             {
                 IRBuilder builder(m_sharedContext->m_irModule);
                 builder.setInsertBefore(inst);
                 auto newPtrType = builder.getPtrType(
                     oldResultType->getOp(),
-                    oldResultType->getValueType(),
+                    newValueType,
                     ptrType->getAddressSpace());
                 auto newInst =
                     builder.emitFieldAddress(newPtrType, inst->getBase(), inst->getField());
@@ -1077,6 +1179,19 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         }
     }
 
+    void processFieldExtract(IRFieldExtract* inst)
+    {
+        auto ptrType = as<IRPtrType>(inst->getDataType());
+        if (!ptrType)
+            return;
+        auto newPtrType = translateToStorageBufferPointer(ptrType);
+        if (newPtrType == ptrType)
+            return;
+        IRBuilder builder(inst);
+        auto newInst = builder.replaceOperand(&inst->typeUse, newPtrType);
+        addUsersToWorkList(newInst);
+    }
+
     void duplicateMergeBlockIfNeeded(IRUse* breakBlockUse)
     {
         auto breakBlock = as<IRBlock>(breakBlockUse->get());
@@ -1106,7 +1221,6 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
 
     void processLoop(IRLoop* loop)
     {
-
         // 2.11.1. Rules for Structured Control-flow Declarations
         // Structured control flow declarations must satisfy the following
         // rules:
@@ -1186,6 +1300,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
 
                 // Insert a new continue block at the end of the loop
                 const auto newContinueBlock = builder.emitBlock();
+                addToWorkList(newContinueBlock);
+
                 newContinueBlock->insertBefore(loop->getBreakBlock());
 
                 // This block simply branches to the loop header, forwarding
@@ -1204,10 +1320,12 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 loop->block.set(t);
 
                 // Branch to the target in our new continue block
-                builder.emitBranch(t, ps.getCount(), ps.getBuffer());
+                auto branch = builder.emitBranch(t, ps.getCount(), ps.getBuffer());
+                addToWorkList(branch);
             }
         }
         duplicateMergeBlockIfNeeded(&loop->breakBlock);
+        addToWorkList(loop->getTargetBlock());
     }
 
     void processIfElse(IRIfElse* inst)
@@ -1223,6 +1341,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             auto newBlock = builder.emitBlock();
             builder.emitBranch(inst->getAfterBlock());
             inst->trueBlock.set(newBlock);
+            addToWorkList(newBlock);
         }
         if (inst->getFalseBlock() == inst->getAfterBlock())
         {
@@ -1230,6 +1349,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             auto newBlock = builder.emitBlock();
             builder.emitBranch(inst->getAfterBlock());
             inst->falseBlock.set(newBlock);
+            addToWorkList(newBlock);
         }
     }
 
@@ -1246,6 +1366,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             auto newBlock = builder.emitBlock();
             builder.emitBranch(inst->getBreakLabel());
             inst->defaultLabel.set(newBlock);
+            addToWorkList(newBlock);
         }
         for (UInt i = 0; i < inst->getCaseCount(); i++)
         {
@@ -1255,6 +1376,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 auto newBlock = builder.emitBlock();
                 builder.emitBranch(inst->getBreakLabel());
                 inst->getCaseLabelUse(i)->set(newBlock);
+                addToWorkList(newBlock);
             }
         }
     }
@@ -1386,6 +1508,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         case kIROp_FieldAddress:
         case kIROp_GetElement:
         case kIROp_GetElementPtr:
+        case kIROp_GetOffsetPtr:
         case kIROp_UpdateElement:
         case kIROp_MakeTuple:
         case kIROp_GetTupleElement:
@@ -1407,6 +1530,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         case kIROp_CastFloatToInt:
         case kIROp_CastIntToFloat:
         case kIROp_CastIntToPtr:
+        case kIROp_PtrCast:
         case kIROp_CastPtrToBool:
         case kIROp_CastPtrToInt:
         case kIROp_BitAnd:
@@ -1467,7 +1591,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             cloneEnv.mapOldValToNew[inst] = result;
             return result;
         }
-        
+
         // If the global value is inlinable, we make all its operands avaialble locally, and then copy it
         // to the local scope.
         ShortList<IRInst*> args;
@@ -1482,21 +1606,123 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         return result;
     }
 
-    void processWorkList()
+    void processBranch(IRInst* branch)
+    {
+        addToWorkList(branch->getOperand(0));
+    }
+
+    IRType* translateToStorageBufferPointer(IRType* pointerType)
+    {
+        auto ptrType = as<IRPtrType>(pointerType);
+        if (!ptrType)
+            return pointerType;
+        auto oldValueType = ptrType->getValueType();
+        auto newValueType = translateToStorageBufferPointer(oldValueType);
+        if (oldValueType != newValueType || !ptrType->hasAddressSpace())
+        {
+            IRBuilder builder(m_module);
+            return builder.getPtrType(ptrType->getOp(), newValueType, SpvStorageClassPhysicalStorageBuffer);
+        }
+        return ptrType;
+    }
+
+    void translatePtrResultType(IRInst* inst)
+    {
+        auto ptrType = as<IRPtrType>(inst->getDataType());
+        auto newPtrType = translateToStorageBufferPointer(ptrType);
+        if (newPtrType == ptrType)
+            return;
+        IRBuilder builder(inst);
+        auto newInst = builder.replaceOperand(&inst->typeUse, newPtrType);
+        addUsersToWorkList(newInst);
+    }
+
+    void processPtrLit(IRInst* inst)
     {
+        IRBuilder builder(inst);
+        builder.setInsertBefore(inst);
+        auto newPtrType = translateToStorageBufferPointer(as<IRPtrType>(inst->getFullType()));
+        auto newInst = builder.emitCastIntToPtr(newPtrType, builder.getIntValue(builder.getUInt64Type(), 0));
+        inst->replaceUsesWith(newInst);
+        addUsersToWorkList(newInst);
+    }
 
+    void processPtrCast(IRInst* cast)
+    {
+        translatePtrResultType(cast);
+    }
+
+    void processLoad(IRInst* inst)
+    {
+        translatePtrResultType(inst);
+    }
+
+    void processStructField(IRStructField* field)
+    {
+        auto ptrType = as<IRPtrTypeBase>(field->getFieldType());
+        if (!ptrType)
+            return;
+        if (ptrType->hasAddressSpace())
+            return;
+        IRBuilder builder(field);
+        auto newPtrType = builder.getPtrType(
+            ptrType->getOp(),
+            ptrType->getValueType(),
+            SpvStorageClassPhysicalStorageBuffer);
+        field->setFieldType(newPtrType);
+    }
+
+    void processComparison(IRInst* inst)
+    {
+        auto operand0 = inst->getOperand(0);
+        if (as<IRPtrType>(operand0->getDataType()))
+        {
+            // If we are doing pointer comparison, convert the operands into uints first.
+            IRBuilder builder(inst);
+            builder.setInsertBefore(inst);
+            auto castToUInt = [&](IRInst* operand)
+                {
+                    if (as<IRPtrLit>(operand))
+                        return builder.getIntValue(builder.getUInt64Type(), 0);
+                    else
+                        return builder.emitCastPtrToInt(operand);
+                };
+            auto newOperand0 = castToUInt(operand0);
+            SLANG_ASSERT(as<IRPtrType>(inst->getOperand(1)->getDataType()));
+            auto newOperand1 = castToUInt(inst->getOperand(1));
+            inst = builder.replaceOperand(inst->getOperands(), newOperand0);
+            inst = builder.replaceOperand(inst->getOperands() + 1, newOperand1);
+        }
+    }
+
+    void processWorkList()
+    {
         while (workList.getCount() != 0)
         {
             IRInst* inst = workList.getLast();
             workList.removeLast();
+
+            // Skip if inst has already been removed.
+            if (!inst->parent)
+                continue;
+
             switch (inst->getOp())
             {
+            case kIROp_StructField:
+                processStructField(as<IRStructField>(inst));
+                break;
             case kIROp_GlobalParam:
                 processGlobalParam(as<IRGlobalParam>(inst));
                 break;
             case kIROp_GlobalVar:
                 processGlobalVar(as<IRGlobalVar>(inst));
                 break;
+            case kIROp_Var:
+                processVar(as<IRVar>(inst));
+                break;
+            case kIROp_Param:
+                processParam(as<IRParam>(inst));
+                break;
             case kIROp_Call:
                 processCall(as<IRCall>(inst));
                 break;
@@ -1506,9 +1732,15 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             case kIROp_GetElementPtr:
                 processGetElementPtr(as<IRGetElementPtr>(inst));
                 break;
+            case kIROp_GetOffsetPtr:
+                processGetOffsetPtr(inst);
+                break;
             case kIROp_FieldAddress:
                 processFieldAddress(as<IRFieldAddress>(inst));
                 break;
+            case kIROp_FieldExtract:
+                processFieldExtract(as<IRFieldExtract>(inst));
+                break;
             case kIROp_ImageSubscript:
                 processImageSubscript(as<IRImageSubscript>(inst));
                 break;
@@ -1533,7 +1765,14 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             case kIROp_Switch:
                 processSwitch(as<IRSwitch>(inst));
                 break;
-
+            case kIROp_Less:
+            case kIROp_Leq:
+            case kIROp_Eql:
+            case kIROp_Geq:
+            case kIROp_Greater:
+            case kIROp_Neq:
+                processComparison(inst);
+                break;
             case kIROp_MakeVectorFromScalar:
             case kIROp_MakeUInt64:
             case kIROp_MakeVector:
@@ -1551,6 +1790,20 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             case kIROp_MakeOptionalNone:
                 processConstructor(inst);
                 break;
+            case kIROp_BitCast:
+            case kIROp_PtrCast:
+            case kIROp_CastIntToPtr:
+                processPtrCast(inst);
+                break;
+            case kIROp_PtrLit:
+                processPtrLit(inst);
+                break;
+            case kIROp_Load:
+                processLoad(inst);
+                break;
+            case kIROp_unconditionalBranch:
+                processBranch(inst);
+                break;
             case kIROp_SPIRVAsm:
                 processSPIRVAsm(as<IRSPIRVAsm>(inst));
                 break;
@@ -1584,7 +1837,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
 
     void processModule()
     {
-        convertCompositeTypeParametersToPointers(m_module);
+        //convertCompositeTypeParametersToPointers(m_module);
 
         // Process global params before anything else, so we don't generate inefficient
         // array marhalling code for array-typed global params.
@@ -1631,6 +1884,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             t->replaceUsesWith(lowered);
         }
 
+        // Inline global values that can't represented by SPIRV constant inst
+        // to their use sites.
         List<IRUse*> globalInstUsesToInline;
 
         for (auto globalInst : m_module->getGlobalInsts())
@@ -1666,6 +1921,63 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             if (val != use->get())
                 builder.replaceOperand(use, val);
         }
+
+        // Some legalization processing may change the function parameter types,
+        // so we need to update the function types to match that.
+        updateFunctionTypes();
+    }
+
+    void updateFunctionTypes()
+    {
+        IRBuilder builder(m_module);
+        for (auto globalInst : m_module->getGlobalInsts())
+        {
+            auto func = as<IRFunc>(globalInst);
+            if (!func)
+                continue;
+            auto firstBlock = func->getFirstBlock();
+            if (!firstBlock)
+                continue;
+
+            builder.setInsertBefore(func);
+            auto type = func->getDataType();
+            auto oldFuncType = as<IRFuncType>(type);
+            auto resultType = oldFuncType->getResultType();
+            List<IRType*> newOperands;
+            for (auto block : func->getBlocks())
+            {
+                for (auto inst : block->getChildren())
+                {
+                    if (auto retInst = as<IRReturn>(inst))
+                    {
+                        resultType = retInst->getVal()->getFullType();
+                        break;
+                    }
+                }
+            }
+            for (auto param : firstBlock->getParams())
+            {
+                newOperands.add(param->getDataType());
+            }
+            bool changed = resultType != oldFuncType->getResultType();
+            if (!changed)
+            {
+                for (UInt i = 0; i < oldFuncType->getParamCount(); i++)
+                {
+                    if (oldFuncType->getParamType(i) != newOperands[i])
+                    {
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+            if (changed)
+            {
+                builder.setInsertBefore(func);
+                auto newFuncType = builder.getFuncType(newOperands, resultType);
+                func->setFullType(newFuncType);
+            }
+        }
     }
 };
 
diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp
index d859f86a6..f514fea1d 100644
--- a/source/slang/slang-ir-util.cpp
+++ b/source/slang/slang-ir-util.cpp
@@ -1030,6 +1030,26 @@ IRInst* getInstInBlock(IRInst* inst)
     return getInstInBlock(inst->getParent());
 }
 
+ShortList<IRInst*> getPhiArgs(IRInst* phiParam)
+{
+    ShortList<IRInst*> result;
+    auto block = cast<IRBlock>(phiParam->getParent());
+    UInt paramIndex = 0;
+    for (auto p = block->getFirstParam(); p; p = p->getNextParam())
+    {
+        if (p == phiParam)
+            break;
+        paramIndex++;
+    }
+    for (auto predBlock : block->getPredecessors())
+    {
+        auto termInst = as<IRUnconditionalBranch>(predBlock->getTerminator());
+        SLANG_ASSERT(paramIndex < termInst->getArgCount());
+        result.add(termInst->getArg(paramIndex));
+    }
+    return result;
+}
+
 void removePhiArgs(IRInst* phiParam)
 {
     auto block = cast<IRBlock>(phiParam->getParent());
diff --git a/source/slang/slang-ir-util.h b/source/slang/slang-ir-util.h
index c76898aa2..c290f9392 100644
--- a/source/slang/slang-ir-util.h
+++ b/source/slang/slang-ir-util.h
@@ -221,6 +221,8 @@ IRInst* getInstInBlock(IRInst* inst);
 
 void removePhiArgs(IRInst* phiParam);
 
+ShortList<IRInst*> getPhiArgs(IRInst* phiParam);
+
 int getParamIndexInBlock(IRParam* paramInst);
 
 bool isGlobalOrUnknownMutableAddress(IRGlobalValueWithCode* parentFunc, IRInst* inst);
diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp
index 94de28089..035b2aade 100644
--- a/source/slang/slang-ir.cpp
+++ b/source/slang/slang-ir.cpp
@@ -17,7 +17,14 @@ namespace Slang
 
     SourceLoc const& getDiagnosticPos(IRInst* inst)
     {
-        return inst->sourceLoc;
+        while (inst)
+        {
+            if (inst->sourceLoc.isValid())
+                return inst->sourceLoc;
+            inst = inst->parent;
+        }
+        static SourceLoc invalid = SourceLoc();
+        return invalid;
     }
 
     void printDiagnosticArg(StringBuilder& sb, IRInst* irObject)
@@ -4900,7 +4907,7 @@ namespace Slang
         IRType* type = nullptr;
         auto basePtrType = as<IRPtrTypeBase>(basePtr->getDataType());
         auto valueType = unwrapAttributedType(basePtrType->getValueType());
-        if (auto arrayType = as<IRArrayType>(valueType))
+        if (auto arrayType = as<IRArrayTypeBase>(valueType))
         {
             type = arrayType->getElementType();
         }
@@ -5507,6 +5514,28 @@ namespace Slang
         return inst;
     }
 
+    IRInst* IRBuilder::emitCastPtrToInt(IRInst* val)
+    {
+        auto inst = createInst<IRInst>(
+            this,
+            kIROp_CastPtrToInt,
+            getUInt64Type(),
+            val);
+        addInst(inst);
+        return inst;
+    }
+
+    IRInst* IRBuilder::emitCastIntToPtr(IRType* ptrType, IRInst* val)
+    {
+        auto inst = createInst<IRInst>(
+            this,
+            kIROp_CastIntToPtr,
+            ptrType,
+            val);
+        addInst(inst);
+        return inst;
+    }
+
     IRGlobalConstant* IRBuilder::emitGlobalConstant(
         IRType* type)
     {
@@ -7873,6 +7902,7 @@ namespace Slang
         case kIROp_FieldAddress:
         case kIROp_GetElement:
         case kIROp_GetElementPtr:
+        case kIROp_GetOffsetPtr:
         case kIROp_UpdateElement:
         case kIROp_MeshOutputRef:
         case kIROp_MakeVectorFromScalar:
@@ -7910,6 +7940,7 @@ namespace Slang
         case kIROp_FloatCast:
         case kIROp_CastPtrToInt:
         case kIROp_CastIntToPtr:
+        case kIROp_PtrCast:
         case kIROp_AllocObj:
         case kIROp_PackAnyValue:
         case kIROp_UnpackAnyValue:
@@ -8319,6 +8350,7 @@ namespace Slang
         case kIROp_FieldAddress:
         case kIROp_GetElement:
         case kIROp_GetElementPtr:
+        case kIROp_GetOffsetPtr:
         case kIROp_UpdateElement:
         case kIROp_Specialize:
         case kIROp_LookupWitness:
@@ -8347,6 +8379,7 @@ namespace Slang
         case kIROp_CastIntToPtr:
         case kIROp_CastPtrToBool:
         case kIROp_CastPtrToInt:
+        case kIROp_PtrCast:
         case kIROp_BitAnd:
         case kIROp_BitNot:
         case kIROp_BitOr:
diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h
index 0766bb168..bbb9dfeeb 100644
--- a/source/slang/slang-ir.h
+++ b/source/slang/slang-ir.h
@@ -1813,6 +1813,10 @@ struct IRStructField : IRInst
         //
         return (IRType*) getOperand(1);
     }
+    void setFieldType(IRType* type)
+    {
+        setOperand(1, type);
+    }
 
     IR_LEAF_ISA(StructField)
 };
diff --git a/source/slang/slang-language-server-ast-lookup.cpp b/source/slang/slang-language-server-ast-lookup.cpp
index 3da4f8554..13db8af18 100644
--- a/source/slang/slang-language-server-ast-lookup.cpp
+++ b/source/slang/slang-language-server-ast-lookup.cpp
@@ -358,6 +358,11 @@ public:
         return dispatchIfNotNull(expr->baseExpression);
     }
 
+    bool visitOpenRefExpr(OpenRefExpr* expr)
+    {
+        return dispatchIfNotNull(expr->innerExpr);
+    }
+
     bool visitInitializerListExpr(InitializerListExpr* expr)
     {
         for (auto arg : expr->args)
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index 4e8c9b340..f5d743bb1 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -4264,6 +4264,10 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo>
             return LoweredValInfo::simple(
                 getBuilder()->emitMakeArrayFromElement(irType, irDefaultElement));
         }
+        else if (auto ptrType = as<PtrType>(type))
+        {
+            return LoweredValInfo::simple(getBuilder()->getNullPtrValue(irType));
+        }
         else if (auto declRefType = as<DeclRefType>(type))
         {
             DeclRef<Decl> declRef = declRefType->getDeclRef();
diff --git a/tests/spirv/pointer.slang b/tests/spirv/pointer.slang
new file mode 100644
index 000000000..cb2d56f66
--- /dev/null
+++ b/tests/spirv/pointer.slang
@@ -0,0 +1,48 @@
+//TEST:SIMPLE(filecheck=CHECK): -target spirv -entry main -stage compute -emit-spirv-directly
+
+
+struct PP
+{
+    int data;
+    int data2;
+}
+struct Data
+{
+    int data;
+    PP* pNext;
+};
+
+void funcThatTakesPointer(PP* p)
+{
+    p.data = 2;
+}
+int* funcThatReturnsPointer(PP* p)
+{
+    return &p.data;
+}
+
+// CHECK: OpEntryPoint
+
+StructuredBuffer<Data> buffer;
+RWStructuredBuffer<int> output;
+void main(int id : SV_DispatchThreadID)
+{
+    output[0] = buffer[0].pNext.data;
+    let pData = &(buffer[0].pNext.data);
+    // CHECK: OpPtrAccessChain
+    int* pData1 = pData + 1;
+    *pData1 = 3;
+    *(int2*)pData = int2(1, 2);
+    pData1[-1] = 2;
+    buffer[0].pNext[1] = {5};
+    // CHECK: OpConvertPtrToU
+    // CHECK: OpINotEqual
+    if (pData1)
+    {
+        *(funcThatReturnsPointer(buffer[0].pNext)) = 4;
+    }
+    if (pData1 > pData)
+    {
+        funcThatTakesPointer(buffer[0].pNext);
+    }
+}