Overhaul IR lowering of pointer types. (#4710)

* Overhaul IR lowering of pointer types.

* Propagate address space in IRBuilder.

* Fixup.

* Fix.

* Fix.

* Change how Ptr type is printed to text.

* Fix.

40 files changed, 326 insertions, 255 deletions

diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 45b3435eb..c75d4735b 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -679,14 +679,14 @@ struct __none_t
 {
 };
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t = $( (uint64_t)AddressSpace::UserPointer)ULL>
 __magic_type(PtrType)
 __intrinsic_type($(kIROp_PtrType))
 struct Ptr
 {
     __generic<U>
     __intrinsic_op($(kIROp_BitCast))
-    __init(Ptr<U> ptr);
+    __init(Ptr<U, addrSpace> ptr);
 
     __intrinsic_op($(kIROp_CastIntToPtr))
     __init(uint64_t val);
@@ -703,53 +703,47 @@ struct Ptr
 };
 
 __intrinsic_op($(kIROp_Load))
-T __load<T>(Ptr<T> ptr);
+T __load<T, let addrSpace : uint64_t>(Ptr<T, addrSpace> ptr);
 
 __intrinsic_op($(kIROp_Store))
-void __store<T>(Ptr<T> ptr, T val);
-
-__intrinsic_op($(kIROp_GetElementPtr))
-Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int index);
+void __store<T, let addrSpace : uint64_t>(Ptr<T, addrSpace> ptr, T val);
 
 __intrinsic_op($(kIROp_GetElementPtr))
-Ptr<T> __getElementPtr<T>(Ptr<T> ptr, int64_t index);
+Ptr<T, addrSpace> __getElementPtr<T, let addrSpace : uint64_t, TIndex : __BuiltinIntegerType>(Ptr<T, addrSpace> ptr, TIndex index);
 
 __intrinsic_op($(kIROp_GetOffsetPtr))
-Ptr<T> __getOffsetPtr<T>(Ptr<T> ptr, int index);
+Ptr<T, addrSpace> __getOffsetPtr<T, let addrSpace : uint64_t, TIndex : __BuiltinIntegerType>(Ptr<T, addrSpace> ptr, TIndex index);
 
-__intrinsic_op($(kIROp_GetOffsetPtr))
-Ptr<T> __getOffsetPtr<T>(Ptr<T> ptr, int64_t index);
-
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Less))
-bool operator<(Ptr<T> p1, Ptr<T> p2);
+bool operator <(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Leq))
-bool operator<=(Ptr<T> p1, Ptr<T> p2);
+bool operator <=(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Greater))
-bool operator>(Ptr<T> p1, Ptr<T> p2);
+bool operator>(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Geq))
-bool operator>=(Ptr<T> p1, Ptr<T> p2);
+bool operator >=(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Neq))
-bool operator!=(Ptr<T> p1, Ptr<T> p2);
+bool operator !=(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_Eql))
-bool operator==(Ptr<T> p1, Ptr<T> p2);
+bool operator ==(Ptr<T, addrSpace> p1, Ptr<T, addrSpace> p2);
 
 extension bool : IRangedValue
 {
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __implicit_conversion($(kConversionCost_PtrToBool))
     __intrinsic_op($(kIROp_CastPtrToBool))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
 
     __generic<T : __EnumType>
     __implicit_conversion($(kConversionCost_IntegerTruncate))
@@ -765,9 +759,9 @@ extension bool : IRangedValue
 
 extension uint64_t : IRangedValue
 {
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __intrinsic_op($(kIROp_CastPtrToInt))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
 
     static const uint64_t maxValue = 0xFFFFFFFFFFFFFFFFULL;
     static const uint64_t minValue = 0;
@@ -775,9 +769,9 @@ extension uint64_t : IRangedValue
 
 extension int64_t : IRangedValue
 {
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __intrinsic_op($(kIROp_CastPtrToInt))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
 
     static const int64_t maxValue =  0x7FFFFFFFFFFFFFFFLL;
     static const int64_t minValue = -0x8000000000000000LL;
@@ -785,9 +779,9 @@ extension int64_t : IRangedValue
 
 extension intptr_t : IRangedValue
 {
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __intrinsic_op($(kIROp_CastPtrToInt))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
     static const intptr_t maxValue = $(SLANG_PROCESSOR_X86_64?"0x7FFFFFFFFFFFFFFFz":"0x7FFFFFFFz");
     static const intptr_t minValue = $(SLANG_PROCESSOR_X86_64?"0x8000000000000000z":"0x80000000z");
     static const int size = $(SLANG_PROCESSOR_X86_64?"8":"4");
@@ -795,9 +789,9 @@ extension intptr_t : IRangedValue
 
 extension uintptr_t : IRangedValue
 {
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __intrinsic_op($(kIROp_CastPtrToInt))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
     static const uintptr_t maxValue = $(SLANG_PROCESSOR_X86_64?"0xFFFFFFFFFFFFFFFFz":"0xFFFFFFFFz");
     static const uintptr_t minValue = 0z;
     static const int size = $(SLANG_PROCESSOR_X86_64?"8":"4");
@@ -827,6 +821,8 @@ __intrinsic_type($(kIROp_ConstRefType))
 struct ConstRef
 {};
 
+typealias __Addr<T> = Ptr<T, $( (uint64_t)AddressSpace::Generic)ULL>;
+
 __generic<T>
 __magic_type(OptionalType)
 __intrinsic_type($(kIROp_OptionalType))
@@ -969,10 +965,10 @@ extension Ptr<void>
     [__unsafeForceInlineEarly]
     __init(NativeString nativeStr) { this = nativeStr.getBuffer(); }
 
-    __generic<T>
+    __generic<T, let addrSpace : uint64_t>
     __intrinsic_op(0)
     __implicit_conversion($(kConversionCost_PtrToVoidPtr))
-    __init(Ptr<T> ptr);
+    __init(Ptr<T, addrSpace> ptr);
 
     __generic<T>
     __intrinsic_op(0)
@@ -1628,21 +1624,28 @@ for (auto op : intrinsicUnaryOps)
 
 }}}}
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op(0)
-__prefix Ref<T> operator*(Ptr<T> value);
+[require(cpp_cuda_spirv)]
+__prefix Ref<T> operator*(Ptr<T, addrSpace> value);
 
 __generic<T>
 __intrinsic_op(0)
-__prefix Ptr<T> operator&(__ref T value);
+[require(cpp_cuda_spirv)]
+__prefix Ptr<T, $( (uint64_t)AddressSpace::UserPointer)ULL> operator&(__ref T value);
 
 __generic<T>
+__intrinsic_op(0)
+[require(cpp_cuda_spirv)]
+__Addr<T> __get_addr( __ref T value);
+
+__generic<T, let addrSpace : uint64_t>
 __intrinsic_op($(kIROp_GetOffsetPtr))
-Ptr<T> operator+(Ptr<T> value, int64_t offset);
+Ptr<T, addrSpace> operator+(Ptr<T, addrSpace> value, int64_t offset);
 
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 [__unsafeForceInlineEarly]
-Ptr<T> operator-(Ptr<T> value, int64_t offset)
+Ptr<T, addrSpace> operator -(Ptr<T, addrSpace> value, int64_t offset)
 {
     return __getOffsetPtr(value, -offset);
 }
@@ -1707,9 +1710,9 @@ matrix<T,R,C> operator$(op.name)(in out matrix<T,R,C,L> value)
 {$(fixity.bodyPrefix) value = value $(op.binOp) T(1); return $(fixity.returnVal); }
 
 $(fixity.qual)
-__generic<T>
+__generic<T, let addrSpace : uint64_t>
 [__unsafeForceInlineEarly]
-Ptr<T> operator$(op.name)(in out Ptr<T> value)
+Ptr<T, addrSpace> operator$(op.name)(in out Ptr<T, addrSpace> value)
 {$(fixity.bodyPrefix) value = value $(op.binOp) 1; return $(fixity.returnVal); }
 
 ${{{{
@@ -2500,8 +2503,8 @@ __intrinsic_op($(kIROp_TreatAsDynamicUniform))
 T asDynamicUniform<T>(T v);
 
 __generic<T>
-__intrinsic_op($(kIROp_GetLegalizedSPIRVGlobalParamAddr))
-Ptr<T> __getLegalizedSPIRVGlobalParamAddr(T val);
+__intrinsic_op( $(kIROp_GetLegalizedSPIRVGlobalParamAddr))
+__Addr<T> __getLegalizedSPIRVGlobalParamAddr(T val);
 
 __intrinsic_op($(kIROp_RequireComputeDerivative))
 void __requireComputeDerivative();
diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index 1a112e1a9..0539097eb 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -17568,11 +17568,11 @@ Ref<T> __hitObjectAttributes<T>()
     return t;
 }
 [ForceInline]
-Ptr<T> __allocHitObjectAttributes<T>()
+__Addr<T> __allocHitObjectAttributes<T>()
 {
-    [__vulkanHitObjectAttributes]   
+    [__vulkanHitObjectAttributes]
     static T t;
-    return &t;
+    return __get_addr(t);
 }
 
 // Next is the custom intrinsic that will compute the hitObjectAttributes location
@@ -17840,7 +17840,7 @@ struct HitObject
         case spirv:
             {
                 // Save the attributes
-                Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
+                __Addr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
 
                 *attr = attributes;
 
@@ -17914,7 +17914,7 @@ struct HitObject
         case spirv:
         {
             // Save the attributes
-            Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
+            __Addr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
 
             *attr = attributes;
 
@@ -18004,7 +18004,7 @@ struct HitObject
         case spirv:
         {
             // Save the attributes
-            Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
+            __Addr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
             *attr = attributes;
             let origin = Ray.Origin;
             let direction = Ray.Direction;
@@ -18071,7 +18071,7 @@ struct HitObject
         case spirv:
         {
             // Save the attributes
-            Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
+            __Addr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
             *attr = attributes;
             let origin = Ray.Origin;
             let direction = Ray.Direction;
@@ -18618,7 +18618,7 @@ struct HitObject
             }
         case spirv:
             {
-                Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
+                __Addr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
                 spirv_asm 
                 {
                     OpExtension "SPV_NV_shader_invocation_reorder";
diff --git a/source/slang/slang-ast-builder.cpp b/source/slang/slang-ast-builder.cpp
index a672c1b7e..ce4c32c3a 100644
--- a/source/slang/slang-ast-builder.cpp
+++ b/source/slang/slang-ast-builder.cpp
@@ -290,9 +290,9 @@ Type* ASTBuilder::getSpecializedBuiltinType(ArrayView<Val*> genericArgs, const c
     return rsType;
 }
 
-PtrType* ASTBuilder::getPtrType(Type* valueType)
+PtrType* ASTBuilder::getPtrType(Type* valueType, AddressSpace addrSpace)
 {
-    return dynamicCast<PtrType>(getPtrType(valueType, "PtrType"));
+    return dynamicCast<PtrType>(getPtrType(valueType, addrSpace, "PtrType"));
 }
 
 // Construct the type `Out<valueType>`
@@ -306,9 +306,9 @@ InOutType* ASTBuilder::getInOutType(Type* valueType)
     return dynamicCast<InOutType>(getPtrType(valueType, "InOutType"));
 }
 
-RefType* ASTBuilder::getRefType(Type* valueType)
+RefType* ASTBuilder::getRefType(Type* valueType, AddressSpace addrSpace)
 {
-    return dynamicCast<RefType>(getPtrType(valueType, "RefType"));
+    return dynamicCast<RefType>(getPtrType(valueType, addrSpace, "RefType"));
 }
 
 ConstRefType* ASTBuilder::getConstRefType(Type* valueType)
@@ -327,6 +327,12 @@ PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, char const* ptrTypeName)
     return as<PtrTypeBase>(getSpecializedBuiltinType(valueType, ptrTypeName));
 }
 
+PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, AddressSpace addrSpace, char const* ptrTypeName)
+{
+    Val* args[] = { valueType, getIntVal(getUInt64Type(), (IntegerLiteralValue)addrSpace) };
+    return as<PtrTypeBase>(getSpecializedBuiltinType(makeArrayView(args), ptrTypeName));
+}
+
 ArrayExpressionType* ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount)
 {
     if (!elementCount)
diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h
index 5b4ec5538..52858a6b1 100644
--- a/source/slang/slang-ast-builder.h
+++ b/source/slang/slang-ast-builder.h
@@ -6,7 +6,7 @@
 
 #include "slang-ast-support-types.h"
 #include "slang-ast-all.h"
-
+#include "slang-ir.h"
 #include "../core/slang-type-traits.h"
 #include "../core/slang-memory-arena.h"
 
@@ -439,7 +439,7 @@ public:
     Type* getDiffInterfaceType() { return m_sharedASTBuilder->getDiffInterfaceType(); }
         // Construct the type `Ptr<valueType>`, where `Ptr`
         // is looked up as a builtin type.
-    PtrType* getPtrType(Type* valueType);
+    PtrType* getPtrType(Type* valueType, AddressSpace addrSpace);
 
         // Construct the type `Out<valueType>`
     OutType* getOutType(Type* valueType);
@@ -448,7 +448,7 @@ public:
     InOutType* getInOutType(Type* valueType);
 
         // Construct the type `Ref<valueType>`
-    RefType* getRefType(Type* valueType);
+    RefType* getRefType(Type* valueType, AddressSpace addrSpace);
 
         // Construct the type `ConstRef<valueType>`
     ConstRefType* getConstRefType(Type* valueType);
@@ -459,6 +459,7 @@ public:
         // Construct a pointer type like `Ptr<valueType>`, but where
         // the actual type name for the pointer type is given by `ptrTypeName`
     PtrTypeBase* getPtrType(Type* valueType, char const* ptrTypeName);
+    PtrTypeBase* getPtrType(Type* valueType, AddressSpace addrSpace, char const* ptrTypeName);
 
     ArrayExpressionType* getArrayType(Type* elementType, IntVal* elementCount);
 
diff --git a/source/slang/slang-ast-type.cpp b/source/slang/slang-ast-type.cpp
index 47cd68b9e..44585ee30 100644
--- a/source/slang/slang-ast-type.cpp
+++ b/source/slang/slang-ast-type.cpp
@@ -352,6 +352,66 @@ Type* NativeRefType::getValueType()
     return as<Type>(_getGenericTypeArg(this, 0));
 }
 
+Val* PtrTypeBase::getAddressSpace()
+{
+    return _getGenericTypeArg(this, 1);
+}
+
+AddressSpace tryGetAddressSpaceValue(Val* addrSpaceVal)
+{
+    AddressSpace addrSpace = AddressSpace::Generic;
+
+    if (auto cintVal = as<ConstantIntVal>(addrSpaceVal))
+    {
+        addrSpace = (AddressSpace)(cintVal->getValue());
+    }
+    return addrSpace;
+}
+
+void maybePrintAddrSpaceOperand(StringBuilder& out, AddressSpace addrSpace)
+{
+    switch (addrSpace)
+    {
+    case AddressSpace::Generic:
+    case AddressSpace::UserPointer:
+        break;
+    case AddressSpace::GroupShared:
+        out << toSlice(", groupshared");
+        break;
+    case AddressSpace::Global:
+        out << toSlice(", global");
+        break;
+    case AddressSpace::ThreadLocal:
+        out << toSlice(", threadlocal");
+        break;
+    case AddressSpace::Uniform:
+        out << toSlice(", uniform");
+        break;
+    default:
+        break;
+    }
+}
+
+void PtrType::_toTextOverride(StringBuilder& out)
+{
+    auto addrSpace = tryGetAddressSpaceValue(getAddressSpace());
+    if (addrSpace == AddressSpace::Generic)
+        out << toSlice("Addr<") << getValueType();
+    else
+        out << toSlice("Ptr<") << getValueType();
+    maybePrintAddrSpaceOperand(out, addrSpace);
+    out << toSlice(">");
+}
+
+void RefType::_toTextOverride(StringBuilder& out)
+{
+    out << toSlice("Ref<") << getValueType();
+    auto addressSpaceVal = getAddressSpace();
+    maybePrintAddrSpaceOperand(out, tryGetAddressSpaceValue(addressSpaceVal));
+    out << toSlice(">");
+}
+
+
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! NamedExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void NamedExpressionType::_toTextOverride(StringBuilder& out)
diff --git a/source/slang/slang-ast-type.h b/source/slang/slang-ast-type.h
index 0d1a89860..945d051ba 100644
--- a/source/slang/slang-ast-type.h
+++ b/source/slang/slang-ast-type.h
@@ -539,6 +539,8 @@ class PtrTypeBase : public BuiltinType
 
     // Get the type of the pointed-to value.
     Type* getValueType();
+
+    Val* getAddressSpace();
 };
 
 class NoneType : public BuiltinType
@@ -555,6 +557,8 @@ class NullPtrType : public BuiltinType
 class PtrType : public PtrTypeBase 
 {
     SLANG_AST_CLASS(PtrType)
+
+    void _toTextOverride(StringBuilder& out);
 };
 
 // A GPU pointer type into global memory.
@@ -599,6 +603,7 @@ class RefTypeBase : public ParamDirectionType
 class RefType : public RefTypeBase
 {
     SLANG_AST_CLASS(RefType)
+    void _toTextOverride(StringBuilder& out);
 };
 
 // The type for an `constref` parameter, e.g., `constref T`
diff --git a/source/slang/slang-capabilities.capdef b/source/slang/slang-capabilities.capdef
index b13571d18..59e79a07a 100644
--- a/source/slang/slang-capabilities.capdef
+++ b/source/slang/slang-capabilities.capdef
@@ -137,6 +137,7 @@ alias any_gfx_target = hlsl | metal | glsl | spirv;
 alias any_cpp_target = cpp | cuda;
 
 alias cpp_cuda = cpp | cuda;
+alias cpp_cuda_spirv = cpp | cuda | spirv;
 alias cpp_cuda_glsl_spirv = cpp | cuda | glsl | spirv;
 alias cpp_cuda_glsl_hlsl = cpp | cuda | glsl | hlsl;
 alias cpp_cuda_glsl_hlsl_spirv = cpp | cuda | glsl | hlsl | spirv;
diff --git a/source/slang/slang-check-conversion.cpp b/source/slang/slang-check-conversion.cpp
index 111f4e465..00625d5f4 100644
--- a/source/slang/slang-check-conversion.cpp
+++ b/source/slang/slang-check-conversion.cpp
@@ -1024,7 +1024,6 @@ namespace Slang
                 return false;
             if (as<RefType>(toType) && !fromExpr->type.isLeftValue)
                 return false;
-            
             ConversionCost subCost = kConversionCost_GetRef;
 
             MakeRefExpr* refExpr = nullptr;
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index fd03e5e87..96e0a95d0 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -4425,7 +4425,7 @@ namespace Slang
         expr->base = CheckProperType(expr->base);
         if (as<ErrorType>(expr->base.type))
             expr->type = expr->base.type;
-        auto ptrType = m_astBuilder->getPtrType(expr->base.type);
+        auto ptrType = m_astBuilder->getPtrType(expr->base.type, AddressSpace::UserPointer);
         expr->type = m_astBuilder->getTypeType(ptrType);
         return expr;
     }
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index 5c508a541..bf478a17d 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -885,7 +885,7 @@ DIAGNOSTIC(99999, Internal, internalCompilerError, "Slang internal compiler erro
 DIAGNOSTIC(99999, Error, compilationAborted, "Slang compilation aborted due to internal error")
 DIAGNOSTIC(99999, Error, compilationAbortedDueToException, "Slang compilation aborted due to an exception of $0: $1")
 DIAGNOSTIC(99999, Internal, serialDebugVerificationFailed, "Verification of serial debug information failed.")
-DIAGNOSTIC(99999, Internal, spirvValidationFailed, "Validation of generated SPIR-V failed.")
+DIAGNOSTIC(99999, Internal, spirvValidationFailed, "Validation of generated SPIR-V failed. SPIRV generated: \n$0")
 
 DIAGNOSTIC(99999, Internal, noBlocksOrIntrinsic, "no blocks found for function definition, is there a '$0' intrinsic missing?")
 
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index 7ce2c7900..dd5ef8c51 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -1814,7 +1814,7 @@ void CLikeSourceEmitter::emitRateQualifiers(IRInst* value)
     const auto rate = value->getRate();
     if (rate)
     {
-        emitRateQualifiersAndAddressSpaceImpl(rate, -1);
+        emitRateQualifiersAndAddressSpaceImpl(rate, AddressSpace::Generic);
     }
 }
 
@@ -1822,8 +1822,8 @@ void CLikeSourceEmitter::emitRateQualifiersAndAddressSpace(IRInst* value)
 {
     const auto rate = value->getRate();
     const auto ptrTy = composeGetters<IRPtrTypeBase>(value, &IRInst::getDataType);
-    const auto addressSpace = ptrTy ? ptrTy->getAddressSpace() : -1;
-    if (rate || addressSpace != -1)
+    const auto addressSpace = ptrTy ? ptrTy->getAddressSpace() : AddressSpace::Generic;
+    if (rate || addressSpace != AddressSpace::Generic)
     {
         emitRateQualifiersAndAddressSpaceImpl(rate, addressSpace);
     }
diff --git a/source/slang/slang-emit-c-like.h b/source/slang/slang-emit-c-like.h
index 07cb4a0bc..c866456a2 100644
--- a/source/slang/slang-emit-c-like.h
+++ b/source/slang/slang-emit-c-like.h
@@ -488,7 +488,7 @@ public:
 
     virtual void beforeComputeEmitActions(IRModule* module) { SLANG_UNUSED(module); };
 
-    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace) { SLANG_UNUSED(rate); SLANG_UNUSED(addressSpace); }
+    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace) { SLANG_UNUSED(rate); SLANG_UNUSED(addressSpace); }
     virtual void emitSemanticsImpl(IRInst* inst, bool allowOffsetLayout) { SLANG_UNUSED(inst); SLANG_UNUSED(allowOffsetLayout); }
     virtual void emitSimpleFuncParamImpl(IRParam* param);
     virtual void emitSimpleFuncParamsImpl(IRFunc* func);
diff --git a/source/slang/slang-emit-cuda.cpp b/source/slang/slang-emit-cuda.cpp
index f4b45b7aa..ab7ee8f58 100644
--- a/source/slang/slang-emit-cuda.cpp
+++ b/source/slang/slang-emit-cuda.cpp
@@ -738,7 +738,7 @@ void CUDASourceEmitter::emitSimpleTypeImpl(IRType* type)
     }
 }
 
-void CUDASourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, [[maybe_unused]] IRIntegerValue addressSpace)
+void CUDASourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, [[maybe_unused]] AddressSpace addressSpace)
 {
     if (as<IRGroupSharedRate>(rate))
     {
diff --git a/source/slang/slang-emit-cuda.h b/source/slang/slang-emit-cuda.h
index 5d76c4ef3..ac7a33302 100644
--- a/source/slang/slang-emit-cuda.h
+++ b/source/slang/slang-emit-cuda.h
@@ -67,7 +67,7 @@ protected:
     virtual void emitParameterGroupImpl(IRGlobalParam* varDecl, IRUniformParameterGroupType* type) SLANG_OVERRIDE;
     virtual void emitEntryPointAttributesImpl(IRFunc* irFunc, IREntryPointDecoration* entryPointDecor) SLANG_OVERRIDE;
 
-    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace) SLANG_OVERRIDE;
+    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace) SLANG_OVERRIDE;
     virtual void emitSemanticsImpl(IRInst* inst, bool allowOffsetLayout) SLANG_OVERRIDE;
     virtual void emitSimpleFuncImpl(IRFunc* func) SLANG_OVERRIDE;
     virtual void emitSimpleFuncParamsImpl(IRFunc* func) SLANG_OVERRIDE;
diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp
index eea672938..0fb868342 100644
--- a/source/slang/slang-emit-glsl.cpp
+++ b/source/slang/slang-emit-glsl.cpp
@@ -2638,9 +2638,9 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type)
     SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled type");
 }
 
-void GLSLSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace)
+void GLSLSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace)
 {
-    if(addressSpace == SpvStorageClassTaskPayloadWorkgroupEXT)
+    if(addressSpace == (AddressSpace)SpvStorageClassTaskPayloadWorkgroupEXT)
     {
         m_writer->emit("taskPayloadSharedEXT ");
     }
diff --git a/source/slang/slang-emit-glsl.h b/source/slang/slang-emit-glsl.h
index efd3ded75..1911749ec 100644
--- a/source/slang/slang-emit-glsl.h
+++ b/source/slang/slang-emit-glsl.h
@@ -33,7 +33,7 @@ protected:
 
     virtual void emitFrontMatterImpl(TargetRequest* targetReq) SLANG_OVERRIDE;
 
-    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace) SLANG_OVERRIDE;
+    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace) SLANG_OVERRIDE;
     virtual void emitInterpolationModifiersImpl(IRInst* varInst, IRType* valueType, IRVarLayout* layout) SLANG_OVERRIDE;
     virtual void emitPackOffsetModifier(IRInst* varInst, IRType* valueType, IRPackOffsetDecoration* decoration) SLANG_OVERRIDE;
 
diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp
index 4d3830969..d3757f534 100644
--- a/source/slang/slang-emit-hlsl.cpp
+++ b/source/slang/slang-emit-hlsl.cpp
@@ -1096,7 +1096,7 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type)
     }
 }
 
-void HLSLSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, [[maybe_unused]] IRIntegerValue addressSpace)
+void HLSLSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, [[maybe_unused]] AddressSpace addressSpace)
 {
     if (as<IRGroupSharedRate>(rate))
     {
diff --git a/source/slang/slang-emit-hlsl.h b/source/slang/slang-emit-hlsl.h
index abc673a3d..2137a6d3d 100644
--- a/source/slang/slang-emit-hlsl.h
+++ b/source/slang/slang-emit-hlsl.h
@@ -35,7 +35,7 @@ protected:
     
     virtual void emitFrontMatterImpl(TargetRequest* targetReq) SLANG_OVERRIDE;
 
-    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace) SLANG_OVERRIDE;
+    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace) SLANG_OVERRIDE;
     virtual void emitSemanticsImpl(IRInst* inst, bool allowOffsets) SLANG_OVERRIDE;
     virtual void emitSimpleFuncParamImpl(IRParam* param) SLANG_OVERRIDE;
     virtual void emitInterpolationModifiersImpl(IRInst* varInst, IRType* valueType, IRVarLayout* layout) SLANG_OVERRIDE;
diff --git a/source/slang/slang-emit-metal.cpp b/source/slang/slang-emit-metal.cpp
index e7df29e0c..302e2b6b7 100644
--- a/source/slang/slang-emit-metal.cpp
+++ b/source/slang/slang-emit-metal.cpp
@@ -984,7 +984,7 @@ void MetalSourceEmitter::emitPackOffsetModifier(IRInst* varInst, IRType* valueTy
     // We emit packoffset as a semantic in `emitSemantic`, so nothing to do here.
 }
 
-void MetalSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace)
+void MetalSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace)
 {
     if (as<IRGroupSharedRate>(rate))
     {
@@ -992,7 +992,7 @@ void MetalSourceEmitter::emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRI
         return;
     }
 
-    switch ((AddressSpace)addressSpace)
+    switch (addressSpace)
     {
     case AddressSpace::GroupShared:
         m_writer->emit("threadgroup ");
diff --git a/source/slang/slang-emit-metal.h b/source/slang/slang-emit-metal.h
index 32557bf27..6460b076a 100644
--- a/source/slang/slang-emit-metal.h
+++ b/source/slang/slang-emit-metal.h
@@ -31,7 +31,7 @@ protected:
     
     virtual void emitFrontMatterImpl(TargetRequest* targetReq) SLANG_OVERRIDE;
 
-    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, IRIntegerValue addressSpace) SLANG_OVERRIDE;
+    virtual void emitRateQualifiersAndAddressSpaceImpl(IRRate* rate, AddressSpace addressSpace) SLANG_OVERRIDE;
     virtual void emitSemanticsImpl(IRInst* inst, bool allowOffsets) SLANG_OVERRIDE;
     virtual void emitSimpleFuncParamImpl(IRParam* param) SLANG_OVERRIDE;
     virtual void emitPostDeclarationAttributesForType(IRInst* type) SLANG_OVERRIDE;
diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp
index f5bb21c00..cb9eb0ae9 100644
--- a/source/slang/slang-emit-spirv.cpp
+++ b/source/slang/slang-emit-spirv.cpp
@@ -1108,7 +1108,17 @@ struct SPIRVEmitContext
 
         // If we have seen this before, return the memoized instruction
         if (SpvInst** memoized = m_spvTypeInsts.tryGetValue(key))
+        {
+            // There could be another different slang IR inst that translates to
+            // the same spir-v inst.
+            // For example, both Ptr<T> and Ref<T> translates to the same pointer
+            // type in spirv.
+            // In this case we need to make sure we also
+            // register `inst` to map it to the memoized spir-v inst.
+            if (irInst)
+                m_mapIRInstToSpvInst.addIfNotExists(irInst, *memoized);
             return *memoized;
+        }
 
         // Otherwise, we can construct our instruction and record the result
         InstConstructScope scopeInst(this, opcode, irInst);
@@ -1213,6 +1223,19 @@ struct SPIRVEmitContext
         return m_NonSemanticDebugPrintfExtInst;
     }
 
+    SpvStorageClass addressSpaceToStorageClass(AddressSpace addrSpace)
+    {
+        switch (addrSpace)
+        {
+        case AddressSpace::Generic:
+            return SpvStorageClassMax;
+        case AddressSpace::UserPointer:
+            return SpvStorageClassPhysicalStorageBuffer;
+        default:
+            return (SpvStorageClass)addrSpace;
+        }
+    }
+
     // Now that we've gotten the core infrastructure out of the way,
     // let's start looking at emitting some instructions that make
     // up a SPIR-V module.
@@ -1398,7 +1421,7 @@ struct SPIRVEmitContext
                 auto ptrType = as<IRPtrTypeBase>(inst);
                 SLANG_ASSERT(ptrType);
                 if (ptrType->hasAddressSpace())
-                    storageClass = (SpvStorageClass)ptrType->getAddressSpace();
+                    storageClass = addressSpaceToStorageClass(ptrType->getAddressSpace());
                 if (storageClass == SpvStorageClassStorageBuffer)
                     ensureExtensionDeclaration(UnownedStringSlice("SPV_KHR_storage_buffer_storage_class"));
                 if (storageClass == SpvStorageClassPhysicalStorageBuffer)
@@ -1411,14 +1434,24 @@ struct SPIRVEmitContext
                     && as<IRStructType>(valueType)
                     && storageClass == SpvStorageClassPhysicalStorageBuffer);
                 SpvId valueTypeId;
-                if (useForwardDeclaration)
+                if (as<IRVoidType>(valueType))
                 {
-                    valueTypeId = getIRInstSpvID(valueType);
+                    // Emit void* as uint*.
+                    IRBuilder builder(valueType);
+                    builder.setInsertBefore(valueType);
+                    valueTypeId = getID(ensureInst(builder.getUIntType()));
                 }
                 else
                 {
-                    auto spvValueType = ensureInst(valueType);
-                    valueTypeId = getID(spvValueType);
+                    if (useForwardDeclaration)
+                    {
+                        valueTypeId = getIRInstSpvID(valueType);
+                    }
+                    else
+                    {
+                        auto spvValueType = ensureInst(valueType);
+                        valueTypeId = getID(spvValueType);
+                    }
                 }
 
                 auto resultSpvType = emitOpTypePointer(
@@ -3339,7 +3372,7 @@ struct SPIRVEmitContext
                                     if (auto ptrType = as<IRPtrTypeBase>(globalInst->getDataType()))
                                     {
                                         auto addrSpace = ptrType->getAddressSpace();
-                                        if (addrSpace != SpvStorageClassInput && addrSpace != SpvStorageClassOutput)
+                                        if (addrSpace != AddressSpace(SpvStorageClassInput) && addrSpace != AddressSpace(SpvStorageClassOutput))
                                             continue;
                                     }
                                 }
@@ -4042,7 +4075,7 @@ struct SPIRVEmitContext
         if (!ptrType)
             return;
         auto addrSpace = ptrType->getAddressSpace();
-        if (addrSpace == SpvStorageClassInput)
+        if (addrSpace == AddressSpace(SpvStorageClassInput))
         {
             if (isIntegralScalarOrCompositeType(ptrType->getValueType()))
             {
@@ -4333,10 +4366,10 @@ struct SPIRVEmitContext
 
     void maybeEmitPointerDecoration(SpvInst* varInst, IRInst* inst)
     {
-        auto ptrType = as<IRPtrType>(inst->getDataType());
+        auto ptrType = as<IRPtrType>(unwrapArray(inst->getDataType()));
         if (!ptrType)
             return;
-        if (ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        if (addressSpaceToStorageClass(ptrType->getAddressSpace()) == SpvStorageClassPhysicalStorageBuffer)
         {
             // If inst has a pointer type with PhysicalStorageBuffer address space,
             // emit AliasedPointer decoration.
@@ -4351,10 +4384,10 @@ struct SPIRVEmitContext
         {
             // If the pointee type is a pointer with StorageBuffer address space,
             // we also want to emit AliasedPointer decoration.
-            ptrType = as<IRPtrType>(ptrType->getValueType());
+            ptrType = as<IRPtrType>(unwrapArray(ptrType->getValueType()));
             if (!ptrType)
                 return;
-            if (ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+            if (addressSpaceToStorageClass(ptrType->getAddressSpace()) == SpvStorageClassPhysicalStorageBuffer)
             {
                 emitOpDecorate(
                     getSection(SpvLogicalSectionID::Annotations),
@@ -4996,7 +5029,7 @@ struct SPIRVEmitContext
     SpvInst* emitLoad(SpvInstParent* parent, IRLoad* inst)
     {
         auto ptrType = as<IRPtrTypeBase>(inst->getPtr()->getDataType());
-        if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        if (ptrType && addressSpaceToStorageClass(ptrType->getAddressSpace()) == SpvStorageClassPhysicalStorageBuffer)
         {
             IRSizeAndAlignment sizeAndAlignment;
             getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), ptrType->getValueType(), &sizeAndAlignment);
@@ -5011,7 +5044,7 @@ struct SPIRVEmitContext
     SpvInst* emitStore(SpvInstParent* parent, IRStore* inst)
     {
         auto ptrType = as<IRPtrTypeBase>(inst->getPtr()->getDataType());
-        if (ptrType && ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+        if (ptrType && addressSpaceToStorageClass(ptrType->getAddressSpace()) == SpvStorageClassPhysicalStorageBuffer)
         {
             IRSizeAndAlignment sizeAndAlignment;
             getNaturalSizeAndAlignment(m_targetProgram->getOptionSet(), ptrType->getValueType(), &sizeAndAlignment);
@@ -5077,7 +5110,7 @@ struct SPIRVEmitContext
         return emitOpVectorShuffle(parent, inst, inst->getFullType(), inst->getBase(), inst->getSource(), shuffleIndices.getArrayView());
     }
 
-    IRPtrTypeBase* getPtrTypeWithAddressSpace(IRPtrTypeBase* ptrTypeWithNoAddressSpace, IRIntegerValue addressSpace)
+    IRPtrTypeBase* getPtrTypeWithAddressSpace(IRPtrTypeBase* ptrTypeWithNoAddressSpace, AddressSpace addressSpace)
     {
         // If it's already ok, return as is
         if(ptrTypeWithNoAddressSpace->getAddressSpace() == addressSpace)
@@ -5104,7 +5137,7 @@ struct SPIRVEmitContext
             parent,
             inst,
             // Make sure the resulting pointer has the correct storage class
-            getPtrTypeWithAddressSpace(cast<IRPtrTypeBase>(inst->getDataType()), storageClass),
+            getPtrTypeWithAddressSpace(cast<IRPtrTypeBase>(inst->getDataType()), AddressSpace(storageClass)),
             inst->getOperand(0),
             makeArray(emitIntConstant(0, builder.getIntType()), ensureInst(inst->getOperand(1)))
         );
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 9e21ccbfd..03d1b932c 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -1718,9 +1718,13 @@ SlangResult emitSPIRVForEntryPointsDirectly(
             {
                 if (SLANG_FAILED(compiler->validate((uint32_t*)spirv.getBuffer(), int(spirv.getCount()/4))))
                 {
+                    String err;
+                    String dis;
+                    disassembleSPIRV(spirv, err, dis);
                     codeGenContext->getSink()->diagnoseWithoutSourceView(
                         SourceLoc{},
-                        Diagnostics::spirvValidationFailed
+                        Diagnostics::spirvValidationFailed,
+                        dis
                     );
                 }
             }
diff --git a/source/slang/slang-ir-any-value-marshalling.cpp b/source/slang/slang-ir-any-value-marshalling.cpp
index 13059a84a..f09294aa9 100644
--- a/source/slang/slang-ir-any-value-marshalling.cpp
+++ b/source/slang/slang-ir-any-value-marshalling.cpp
@@ -145,13 +145,10 @@ namespace Slang
             case kIROp_VectorType:
             {
                 auto vectorType = static_cast<IRVectorType*>(dataType);
-                auto elementType = vectorType->getElementType();
                 auto elementCount = getIntVal(vectorType->getElementCount());
-                auto elementPtrType = builder->getPtrType(elementType);
                 for (IRIntegerValue i = 0; i < elementCount; i++)
                 {
                     auto elementAddr = builder->emitElementAddress(
-                        elementPtrType,
                         concreteTypedVar,
                         builder->getIntValue(builder->getIntType(), i));
                     emitMarshallingCode(builder, context, elementAddr);
@@ -161,20 +158,16 @@ namespace Slang
             case kIROp_MatrixType:
             {
                 auto matrixType = static_cast<IRMatrixType*>(dataType);
-                auto elementType = matrixType->getElementType();
                 auto colCount = getIntVal(matrixType->getColumnCount());
                 auto rowCount = getIntVal(matrixType->getRowCount());
-                auto rowVecType = builder->getVectorType(elementType, matrixType->getRowCount());
                 for (IRIntegerValue i = 0; i < colCount; i++)
                 {
                     auto col = builder->emitElementAddress(
-                        builder->getPtrType(rowVecType),
                         concreteTypedVar,
                         builder->getIntValue(builder->getIntType(), i));
                     for (IRIntegerValue j = 0; j < rowCount; j++)
                     {
                         auto element = builder->emitElementAddress(
-                            builder->getPtrType(elementType),
                             col,
                             builder->getIntValue(builder->getIntType(), j));
                         emitMarshallingCode(builder, context, element);
@@ -198,11 +191,9 @@ namespace Slang
             case kIROp_ArrayType:
             {
                 auto arrayType = cast<IRArrayType>(dataType);
-                auto elementPtrType = builder->getPtrType(arrayType->getElementType());
                 for (IRIntegerValue i = 0; i < getIntVal(arrayType->getElementCount()); i++)
                 {
                     auto fieldAddr = builder->emitElementAddress(
-                        elementPtrType,
                         concreteTypedVar,
                         builder->getIntValue(builder->getIntType(), i));
                     emitMarshallingCode(builder, context, fieldAddr);
diff --git a/source/slang/slang-ir-autodiff-primal-hoist.cpp b/source/slang/slang-ir-autodiff-primal-hoist.cpp
index 511055713..9fe4ec70b 100644
--- a/source/slang/slang-ir-autodiff-primal-hoist.cpp
+++ b/source/slang/slang-ir-autodiff-primal-hoist.cpp
@@ -1117,14 +1117,9 @@ IRInst* emitIndexedStoreAddressForVar(
     const List<IndexTrackingInfo>& defBlockIndices)
 {
     IRInst* storeAddr = localVar;
-    IRType* currType = as<IRPtrTypeBase>(localVar->getDataType())->getValueType();
-
     for (auto& index : defBlockIndices)
     {
-        currType = as<IRArrayType>(currType)->getElementType();
-
         storeAddr = builder->emitElementAddress(
-            builder->getPtrType(currType),
             storeAddr, 
             index.primalCountParam);
     }
@@ -1141,11 +1136,9 @@ IRInst* emitIndexedLoadAddressForVar(
     const List<IndexTrackingInfo>& useBlockIndices)
 {
     IRInst* loadAddr = localVar;
-    IRType* currType = as<IRPtrTypeBase>(localVar->getDataType())->getValueType();
 
     for (auto index : defBlockIndices)
     {
-        currType = as<IRArrayType>(currType)->getElementType();
         if (useBlockIndices.contains(index))
         {
             // If the use-block is under the same region, use the 
@@ -1154,7 +1147,6 @@ IRInst* emitIndexedLoadAddressForVar(
             auto diffCounterCurrValue = index.diffCountParam;
 
             loadAddr = builder->emitElementAddress(
-                builder->getPtrType(currType),
                 loadAddr, 
                 diffCounterCurrValue);
         }
@@ -1173,7 +1165,6 @@ IRInst* emitIndexedLoadAddressForVar(
                     builder->getIntValue(builder->getIntType(), 1));
 
             loadAddr = builder->emitElementAddress(
-                builder->getPtrType(currType),
                 loadAddr, 
                 primalCounterLastValue);
         }
diff --git a/source/slang/slang-ir-composite-reg-to-mem.cpp b/source/slang/slang-ir-composite-reg-to-mem.cpp
index 243a0e2b0..512683938 100644
--- a/source/slang/slang-ir-composite-reg-to-mem.cpp
+++ b/source/slang/slang-ir-composite-reg-to-mem.cpp
@@ -36,7 +36,6 @@ namespace Slang
                     if (getElementUser->getOperands() == use)
                     {
                         newAddr = builder.emitElementAddress(
-                            builder.getPtrType(user->getFullType()),
                             addr,
                             getElementUser->getIndex());
                     }
diff --git a/source/slang/slang-ir-explicit-global-context.cpp b/source/slang/slang-ir-explicit-global-context.cpp
index 9d3f09712..56fd62883 100644
--- a/source/slang/slang-ir-explicit-global-context.cpp
+++ b/source/slang/slang-ir-explicit-global-context.cpp
@@ -258,7 +258,7 @@ struct IntroduceExplicitGlobalContextPass
         if (kind == GlobalObjectKind::GlobalVar)
         {
             auto ptrType = as<IRPtrTypeBase>(type);
-            if (ptrType->getAddressSpace() == (IRIntegerValue)AddressSpace::GroupShared)
+            if (ptrType->getAddressSpace() == AddressSpace::GroupShared)
             {
                 fieldDataType = ptrType;
                 needDereference = true;
diff --git a/source/slang/slang-ir-glsl-liveness.cpp b/source/slang/slang-ir-glsl-liveness.cpp
index af64df4f4..64d41490a 100644
--- a/source/slang/slang-ir-glsl-liveness.cpp
+++ b/source/slang/slang-ir-glsl-liveness.cpp
@@ -133,7 +133,7 @@ void GLSLLivenessContext::_replaceMarker(IRLiveRangeMarker* markerInst)
 
         IRType* paramTypes[] = 
         {
-            m_builder.getRefType(referencedType),       ///< Use a reference to the referenced type
+            m_builder.getRefType(referencedType, AddressSpace::Generic),       ///< Use a reference to the referenced type
             m_spirvIntLiteralType,                      ///< The size type
         };
 
diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h
index a5493d6ea..3aa7d1f64 100644
--- a/source/slang/slang-ir-insts.h
+++ b/source/slang/slang-ir-insts.h
@@ -3490,10 +3490,11 @@ public:
     IRPtrType*  getPtrType(IRType* valueType);
     IROutType*  getOutType(IRType* valueType);
     IRInOutType*  getInOutType(IRType* valueType);
-    IRRefType*  getRefType(IRType* valueType);
+    IRRefType*  getRefType(IRType* valueType, AddressSpace addrSpace);
     IRConstRefType* getConstRefType(IRType* valueType);
     IRPtrTypeBase*  getPtrType(IROp op, IRType* valueType);
     IRPtrType* getPtrType(IROp op, IRType* valueType, IRIntegerValue addressSpace);
+    IRPtrType* getPtrType(IROp op, IRType* valueType, IRInst* addressSpace);
     IRPtrType* getPtrType(IROp op, IRType* valueType, AddressSpace addressSpace) { return getPtrType(op, valueType, (IRIntegerValue)addressSpace); }
     IRPtrType* getPtrType(IRType* valueType, AddressSpace addressSpace) { return getPtrType(kIROp_PtrType, valueType, (IRIntegerValue)addressSpace); }
 
diff --git a/source/slang/slang-ir-lower-buffer-element-type.cpp b/source/slang/slang-ir-lower-buffer-element-type.cpp
index 5eefc121e..cc24a0e81 100644
--- a/source/slang/slang-ir-lower-buffer-element-type.cpp
+++ b/source/slang/slang-ir-lower-buffer-element-type.cpp
@@ -578,7 +578,7 @@ namespace Slang
                 {
                     if (auto ptrType = as<IRPtrType>(globalInst))
                     {
-                        if (ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBuffer)
+                        if (ptrType->getAddressSpace() == AddressSpace::UserPointer)
                             elementType = ptrType->getValueType();
                     }
                 }
diff --git a/source/slang/slang-ir-simplify-for-emit.cpp b/source/slang/slang-ir-simplify-for-emit.cpp
index 7fd609011..953d9f68a 100644
--- a/source/slang/slang-ir-simplify-for-emit.cpp
+++ b/source/slang/slang-ir-simplify-for-emit.cpp
@@ -73,7 +73,6 @@ struct SimplifyForEmitContext : public InstPassBase
                 for (UInt i = 0; i < makeArray->getOperandCount(); i++)
                 {
                     auto elementAddr = builder.emitElementAddress(
-                        builder.getPtrType(arrayType->getElementType()),
                         store->getPtr(),
                         builder.getIntValue(builder.getIntType(), (IRIntegerValue)i));
                     builder.emitStore(elementAddr, makeArray->getOperand(i));
@@ -107,7 +106,6 @@ struct SimplifyForEmitContext : public InstPassBase
                 for (IRIntegerValue i = 0; i < arraySize->getValue(); i++)
                 {
                     auto elementAddr = builder.emitElementAddress(
-                        builder.getPtrType(arrayType->getElementType()),
                         store->getPtr(),
                         builder.getIntValue(builder.getIntType(), i));
                     builder.emitStore(elementAddr, makeArray->getOperand(0));
diff --git a/source/slang/slang-ir-specialize-address-space.cpp b/source/slang/slang-ir-specialize-address-space.cpp
index 1d899e240..24eee3d76 100644
--- a/source/slang/slang-ir-specialize-address-space.cpp
+++ b/source/slang/slang-ir-specialize-address-space.cpp
@@ -331,9 +331,12 @@ namespace Slang
                 auto ptrType = as<IRPtrTypeBase>(inst->getDataType());
                 if (ptrType)
                 {
-                    IRBuilder builder(inst);
-                    auto newType = builder.getPtrType(ptrType->getOp(), ptrType->getValueType(), addrSpace);
-                    setDataType(inst, newType);
+                    if (ptrType->getAddressSpace() != addrSpace)
+                    {
+                        IRBuilder builder(inst);
+                        auto newType = builder.getPtrType(ptrType->getOp(), ptrType->getValueType(), addrSpace);
+                        setDataType(inst, newType);
+                    }
                 }
             }
         }
diff --git a/source/slang/slang-ir-specialize-address-space.h b/source/slang/slang-ir-specialize-address-space.h
index 300b6129c..61b191cf2 100644
--- a/source/slang/slang-ir-specialize-address-space.h
+++ b/source/slang/slang-ir-specialize-address-space.h
@@ -1,11 +1,13 @@
 // slang-ir-specialize-address-space.h
 #pragma once
 
+#include <cinttypes>
+
 namespace Slang
 {
     struct IRModule;
     struct IRInst;
-    enum class AddressSpace;
+    enum class AddressSpace : uint64_t;
 
     struct AddressSpaceSpecializationContext
     {
diff --git a/source/slang/slang-ir-specialize.cpp b/source/slang/slang-ir-specialize.cpp
index 5713b9639..5c9e1ad24 100644
--- a/source/slang/slang-ir-specialize.cpp
+++ b/source/slang/slang-ir-specialize.cpp
@@ -1996,9 +1996,6 @@ struct SpecializationContext
             auto index = inst->getIndex();
 
             auto val = wrapInst->getWrappedValue();
-            auto ptrType = cast<IRPtrTypeBase>(val->getDataType());
-            auto arrayType = cast<IRArrayTypeBase>(ptrType->getValueType());
-            auto elementType = arrayType->getElementType();
 
             auto resultType = inst->getFullType();
 
@@ -2013,8 +2010,7 @@ struct SpecializationContext
                 slotOperands.add(wrapInst->getSlotOperand(ii));
             }
 
-            auto elementPtrType = builder.getPtrType(ptrType->getOp(), elementType);
-            auto newElementAddr = builder.emitElementAddress(elementPtrType, val, index);
+            auto newElementAddr = builder.emitElementAddress(val, index);
 
             auto newWrapExistentialInst = builder.emitWrapExistential(
                 resultType, newElementAddr, slotOperandCount, slotOperands.getArrayView().getBuffer());
diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp
index 27a186ee9..528fe2331 100644
--- a/source/slang/slang-ir-spirv-legalize.cpp
+++ b/source/slang/slang-ir-spirv-legalize.cpp
@@ -783,7 +783,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             IRBuilder builder(inst);
             builder.setInsertBefore(inst);
             auto newPtrType = builder.getPtrType(
-                oldPtrType->getOp(), translateToStorageBufferPointer(oldPtrType->getValueType()), SpvStorageClassFunction);
+                oldPtrType->getOp(), oldPtrType->getValueType(), SpvStorageClassFunction);
             inst->setFullType(newPtrType);
             addUsersToWorkList(inst);
         }
@@ -800,12 +800,12 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             return;
         if (!oldPtrType->hasAddressSpace())
         {
-            SpvStorageClass addressSpace = (SpvStorageClass)-1;
+            AddressSpace addressSpace = AddressSpace::Generic;
 
             if (block == func->getFirstBlock())
             {
                 // A pointer typed function parameter should always be in the storage buffer address space.
-                addressSpace = SpvStorageClassPhysicalStorageBuffer;
+                addressSpace = AddressSpace::UserPointer;
             }
             else
             {
@@ -816,19 +816,19 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                     auto argPtrType = as<IRPtrType>(arg->getDataType());
                     if (argPtrType->hasAddressSpace())
                     {
-                        if (addressSpace == (SpvStorageClass)-1)
-                            addressSpace = (SpvStorageClass)argPtrType->getAddressSpace();
+                        if (addressSpace == AddressSpace::Generic)
+                            addressSpace = argPtrType->getAddressSpace();
                         else if (addressSpace != argPtrType->getAddressSpace())
                             m_sharedContext->m_sink->diagnose(inst, Diagnostics::inconsistentPointerAddressSpace, inst);
                     }
                 }
             }
-            if (addressSpace != (SpvStorageClass)-1)
+            if (addressSpace != AddressSpace::Generic)
             {
                 IRBuilder builder(inst);
                 builder.setInsertBefore(inst);
                 auto newPtrType = builder.getPtrType(
-                    oldPtrType->getOp(), translateToStorageBufferPointer(oldPtrType->getValueType()), SpvStorageClassPhysicalStorageBuffer);
+                    oldPtrType->getOp(), oldPtrType->getValueType(), AddressSpace::UserPointer);
                 inst->setFullType(newPtrType);
                 addUsersToWorkList(inst);
             }
@@ -842,7 +842,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             return;
 
         // Update the pointer value type with storage-buffer-address-space-decorated types.
-        auto newPtrValueType = translateToStorageBufferPointer(oldPtrType->getValueType());
+        auto newPtrValueType = oldPtrType->getValueType();
         if (newPtrValueType != oldPtrType->getValueType())
         {
             IRBuilder builder(inst);
@@ -900,7 +900,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         IRBuilder builder(m_sharedContext->m_irModule);
         builder.setInsertBefore(inst);
         auto newPtrType =
-            builder.getPtrType(oldPtrType->getOp(), translateToStorageBufferPointer(oldPtrType->getValueType()), storageClass);
+            builder.getPtrType(oldPtrType->getOp(), oldPtrType->getValueType(), storageClass);
         inst->setFullType(newPtrType);
         addUsersToWorkList(inst);
         return;
@@ -923,7 +923,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 IRBuilder builder(m_sharedContext->m_irModule);
                 builder.setInsertBefore(inst);
                 auto qualPtrType = builder.getPtrType(
-                    ptrType->getOp(), translateToStorageBufferPointer(ptrType->getValueType()), snippet->resultStorageClass);
+                    ptrType->getOp(), ptrType->getValueType(), snippet->resultStorageClass);
                 List<IRInst*> args;
                 for (UInt i = 0; i < inst->getArgCount(); i++)
                     args.add(inst->getArg(i));
@@ -1011,7 +1011,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             }
 
             // If we reach here, we need to allocate a temp var.
-            auto tempVar = builder.emitVar(translateToStorageBufferPointer(ptrType->getValueType()));
+            auto tempVar = builder.emitVar(ptrType->getValueType());
             auto load = builder.emitLoad(arg);
             builder.emitStore(tempVar, load);
             newArgs.add(tempVar);
@@ -1021,7 +1021,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         if (writeBacks.getCount())
         {
             auto newCall = builder.emitCallInst(
-                translateToStorageBufferPointer(inst->getFullType()),
+                inst->getFullType(),
                 inst->getCallee(),
                 newArgs);
             for (auto wb : writeBacks)
@@ -1033,15 +1033,6 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             inst->removeAndDeallocate();
             addUsersToWorkList(newCall);
         }
-        else
-        {
-            // If we reach here, we have determined that all arguments passed as a pointer
-            // are actual memory objects, so they can be passed in as-is.
-            // We still need to make sure the callee is specialized to the address-space
-            // of the arguments, this is done in a separate specialization pass.
-
-            translatePtrResultType(inst);
-        }
     }
 
     Dictionary<IRInst*, IRInst*> m_mapArrayValueToVar;
@@ -1074,7 +1065,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 builder.setInsertBefore(inst);
             else
                 setInsertAfterOrdinaryInst(&builder, x);
-            y = builder.emitVar(translateToStorageBufferPointer(x->getDataType()), SpvStorageClassFunction);
+            y = builder.emitVar(x->getDataType(), SpvStorageClassFunction);
             builder.emitStore(y, x);
             if (x->getParent()->getOp() != kIROp_Module)
                 m_mapArrayValueToVar.set(x, y);
@@ -1101,7 +1092,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 builder.setInsertBefore(gepInst);
                 auto newPtrType = builder.getPtrType(
                     oldResultType->getOp(),
-                    translateToStorageBufferPointer(oldResultType->getValueType()),
+                    oldResultType->getValueType(),
                     ptrType->getAddressSpace());
                 IRInst* args[2] = { base, index };
                 auto newInst =
@@ -1154,7 +1145,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
             IRBuilder builder(offsetPtrInst);
             builder.setInsertBefore(offsetPtrInst);
             auto newResultType = builder.getPtrType(resultPtrType->getOp(),
-                translateToStorageBufferPointer(resultPtrType->getValueType()),
+                resultPtrType->getValueType(),
                 ptrOperandType->getAddressSpace());
             auto newInst = builder.replaceOperand(&offsetPtrInst->typeUse, newResultType);
             addUsersToWorkList(newInst);
@@ -1174,7 +1165,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         builder.setInsertBefore(loadInst);
         IRInst* args[] = { sb, index };
         auto addrInst = builder.emitIntrinsicInst(
-            builder.getPtrType(kIROp_PtrType, translateToStorageBufferPointer(loadInst->getFullType()), getStorageBufferStorageClass()),
+            builder.getPtrType(kIROp_PtrType, loadInst->getFullType(), getStorageBufferStorageClass()),
             kIROp_RWStructuredBufferGetElementPtr,
             2,
             args);
@@ -1357,7 +1348,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
                 return;
             auto oldResultType = as<IRPtrTypeBase>(inst->getDataType());
             auto oldValueType = oldResultType->getValueType();
-            auto newValueType = translateToStorageBufferPointer(oldValueType);
+            auto newValueType = oldValueType;
             
             if (oldValueType != newValueType || oldResultType->getAddressSpace() != ptrType->getAddressSpace())
             {
@@ -1381,7 +1372,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         auto ptrType = as<IRPtrType>(inst->getDataType());
         if (!ptrType)
             return;
-        auto newPtrType = translateToStorageBufferPointer(ptrType);
+        auto newPtrType = ptrType;
         if (newPtrType == ptrType)
             return;
         IRBuilder builder(inst);
@@ -1890,79 +1881,19 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         addToWorkList(branch->getOperand(0));
     }
 
-    // If type is pointer type and does not have an address space, make it a
-    // storage buffer pointer.
-    IRType* translateToStorageBufferPointer(IRType* type)
-    {
-        if (auto ptrType = as<IRPtrType>(type))
-        {
-            auto oldValueType = ptrType->getValueType();
-            auto newValueType = translateToStorageBufferPointer(oldValueType);
-            if (oldValueType != newValueType || !ptrType->hasAddressSpace())
-            {
-                IRBuilder builder(m_module);
-                IRIntegerValue addressSpace = (ptrType->hasAddressSpace() ? ptrType->getAddressSpace() : IRIntegerValue(SpvStorageClassPhysicalStorageBuffer));
-                return builder.getPtrType(ptrType->getOp(), newValueType, addressSpace);
-            }
-            return ptrType;
-        }
-        else if (auto arrayTypeBase = as<IRArrayTypeBase>(type))
-        {
-            auto oldValueType = arrayTypeBase->getElementType();
-            auto newValueType = translateToStorageBufferPointer(oldValueType);
-            if (oldValueType != newValueType)
-            {
-                IRBuilder builder(m_module);
-                return builder.getArrayTypeBase(arrayTypeBase->getOp(), newValueType, arrayTypeBase->getElementCount());
-            }
-            return arrayTypeBase;
-        }
-        return type;
-    }
-
-    void translatePtrResultType(IRInst* inst)
-    {
-        auto ptrType = as<IRPtrType>(inst->getDataType());
-        if (!ptrType)
-        {
-            if (auto refType = as<IRRefType>(inst->getDataType()))
-            {
-                // Functions that return ref type should be treated as returning a pointer.
-                IRBuilder builder(inst);
-                ptrType = builder.getPtrType(refType->getValueType());
-            }
-        }
-        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 newPtrType = 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 newFieldType = translateToStorageBufferPointer(field->getFieldType());
+        auto newFieldType = field->getFieldType();
         if (newFieldType != field->getFieldType())
             field->setFieldType(newFieldType);
     }
@@ -2095,17 +2026,9 @@ 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;
@@ -2261,7 +2184,14 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         {
             // Don't assign address space to additional insts, since we should have
             // already assigned address space to them in earlier stages of legalization.
-            auto type = unwrapAttributedType(inst->getDataType());
+            auto type = inst->getDataType();
+            for (;;)
+            {
+                auto newType = (IRType*)unwrapAttributedType(type);
+                newType = unwrapArray(newType);
+                if (newType == type) break;
+                type = newType;
+            }
             if (!type)
                 return AddressSpace::Generic;
             return getAddressSpaceFromVarType(type);
diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp
index ba7376c46..bb05a1c29 100644
--- a/source/slang/slang-ir.cpp
+++ b/source/slang/slang-ir.cpp
@@ -2813,9 +2813,9 @@ namespace Slang
         return (IRInOutType*) getPtrType(kIROp_InOutType, valueType);
     }
 
-    IRRefType* IRBuilder::getRefType(IRType* valueType)
+    IRRefType* IRBuilder::getRefType(IRType* valueType, AddressSpace addrSpace)
     {
-        return (IRRefType*) getPtrType(kIROp_RefType, valueType);
+        return (IRRefType*) getPtrType(kIROp_RefType, valueType, addrSpace);
     }
 
     IRConstRefType* IRBuilder::getConstRefType(IRType* valueType)
@@ -2840,8 +2840,13 @@ namespace Slang
 
     IRPtrType* IRBuilder::getPtrType(IROp op, IRType* valueType, IRIntegerValue addressSpace)
     {
-        IRInst* operands[] = {valueType, getIntValue(getIntType(), addressSpace)};
-        return (IRPtrType*)getType(op, 2, operands);
+        return (IRPtrType*)getPtrType(op, valueType, getIntValue(getUInt64Type(), addressSpace));
+    }
+
+    IRPtrType* IRBuilder::getPtrType(IROp op, IRType* valueType, IRInst* addressSpace)
+    {
+        IRInst* operands[] = { valueType, addressSpace };
+        return (IRPtrType*)getType(op, addressSpace ? 2 : 1, operands);
     }
 
     IRTextureTypeBase* IRBuilder::getTextureType(IRType* elementType, IRInst* shape, IRInst* isArray, IRInst* isMS, IRInst* sampleCount, IRInst* access, IRInst* isShadow, IRInst* isCombined, IRInst* format)
@@ -4881,11 +4886,30 @@ namespace Slang
         return inst;
     }
 
+    IRType* maybePropagateAddressSpace(IRBuilder* builder, IRInst* basePtr, IRType* type)
+    {
+        if (auto basePtrType = as<IRPtrTypeBase>(basePtr->getDataType()))
+        {
+            if (auto resultPtrType = as<IRPtrTypeBase>(type))
+            {
+                if (basePtrType->getAddressSpace() != resultPtrType->getAddressSpace())
+                {
+                    type = builder->getPtrType(
+                        resultPtrType->getOp(), resultPtrType->getValueType(), basePtrType->getAddressSpace());
+                }
+            }
+        }
+        return type;
+    }
+
     IRInst* IRBuilder::emitFieldAddress(
         IRType* type,
         IRInst* base,
         IRInst* field)
     {
+        // Propagate pointer address space if it is available on base.
+        type = maybePropagateAddressSpace(this, base, type);
+
         auto inst = createInst<IRFieldAddress>(
             this,
             kIROp_FieldAddress,
@@ -4982,6 +5006,9 @@ namespace Slang
         IRInst*    basePtr,
         IRInst*    index)
     {
+        // Propagate pointer address space if it is available on base.
+        type = maybePropagateAddressSpace(this, basePtr, type);
+
         auto inst = createInst<IRFieldAddress>(
             this,
             kIROp_GetElementPtr,
@@ -5004,9 +5031,20 @@ namespace Slang
         IRInst* basePtr,
         IRInst* index)
     {
+        AddressSpace addrSpace = AddressSpace::Generic;
+        IRInst* valueType = nullptr;
+        auto basePtrType = unwrapAttributedType(basePtr->getDataType());
+        if (auto ptrType = as<IRPtrTypeBase>(basePtrType))
+        {
+            addrSpace = ptrType->getAddressSpace();
+            valueType = ptrType->getValueType();
+        }
+        else if (auto ptrLikeType = as<IRPointerLikeType>(basePtrType))
+        {
+            valueType = ptrLikeType->getElementType();
+        }
         IRType* type = nullptr;
-        auto basePtrType = as<IRPtrTypeBase>(basePtr->getDataType());
-        auto valueType = unwrapAttributedType(basePtrType->getValueType());
+        valueType = unwrapAttributedType(valueType);
         if (auto arrayType = as<IRArrayTypeBase>(valueType))
         {
             type = arrayType->getElementType();
@@ -5028,7 +5066,7 @@ namespace Slang
         auto inst = createInst<IRGetElementPtr>(
             this,
             kIROp_GetElementPtr,
-            getPtrType(type),
+            getPtrType(kIROp_PtrType, type, addrSpace),
             basePtr,
             index);
 
@@ -5058,7 +5096,7 @@ namespace Slang
                     }
                 }
                 SLANG_RELEASE_ASSERT(resultType);
-                basePtr = emitFieldAddress(getPtrType(resultType), basePtr, structKey);
+                basePtr = emitFieldAddress(getPtrType(kIROp_PtrType, resultType, basePtrType->getAddressSpace()), basePtr, structKey);
             }
             else
             {
diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h
index 9a773a891..cb8e83df8 100644
--- a/source/slang/slang-ir.h
+++ b/source/slang/slang-ir.h
@@ -39,17 +39,6 @@ struct  IRModule;
 struct  IRStructField;
 struct  IRStructKey;
 
-enum class AddressSpace
-{
-    Generic = 0x7fffffff,
-    ThreadLocal = 1,
-    Global = 2,
-    GroupShared = 3,
-    Uniform = 4,
-    // specific address space for payload data in metal
-    MetalObjectData = 5,
-};
-
 typedef unsigned int IROpFlags;
 enum : IROpFlags
 {
@@ -1710,11 +1699,11 @@ struct IRPtrTypeBase : IRType
 {
     IRType* getValueType() { return (IRType*)getOperand(0); }
 
-    bool hasAddressSpace() { return getOperandCount() > 1; }
+    bool hasAddressSpace() { return getOperandCount() > 1 && getAddressSpace() != AddressSpace::Generic; }
 
-    IRIntegerValue getAddressSpace()
+    AddressSpace getAddressSpace()
     {
-        return getOperandCount() > 1 ? static_cast<IRIntLit*>(getOperand(1))->getValue() : -1;
+        return getOperandCount() > 1 ? (AddressSpace)static_cast<IRIntLit*>(getOperand(1))->getValue() : AddressSpace::Generic;
     }
 
     IR_PARENT_ISA(PtrTypeBase)
diff --git a/source/slang/slang-legalize-types.cpp b/source/slang/slang-legalize-types.cpp
index 393b34e68..66c0044b6 100644
--- a/source/slang/slang-legalize-types.cpp
+++ b/source/slang/slang-legalize-types.cpp
@@ -209,8 +209,8 @@ bool isPointerToResourceType(IRType* type)
 {
     while (auto ptrType = as<IRPtrTypeBase>(type))
     {
-        if (ptrType->getAddressSpace() == SpvStorageClassStorageBuffer ||
-            ptrType->getAddressSpace() == SpvStorageClassPhysicalStorageBufferEXT)
+        if (ptrType->getAddressSpace() == AddressSpace(SpvStorageClassStorageBuffer) ||
+            ptrType->getAddressSpace() == AddressSpace::UserPointer)
             return true;
         type = ptrType->getValueType();
     }
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index d3770753c..74aa0a0ee 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -1855,8 +1855,16 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower
         auto astValueType = type->getValueType();
 
         IRType* irValueType = lowerType(context, astValueType);
-
-        return getBuilder()->getPtrType(irValueType);
+        IRInst* addrSpace = nullptr;
+        if (auto astAddrSpace = type->getAddressSpace())
+        {
+            addrSpace = getSimpleVal(context, lowerVal(context, astAddrSpace));
+        }
+        else
+        {
+            addrSpace = getBuilder()->getIntValue(getBuilder()->getUInt64Type(), (IRIntegerValue)AddressSpace::Generic);
+        }
+        return getBuilder()->getPtrType(kIROp_PtrType, irValueType, addrSpace);
     }
 
     IRType* visitDeclRefType(DeclRefType* type)
@@ -3138,7 +3146,7 @@ void _lowerFuncDeclBaseTypeInfo(
             irParamType = builder->getInOutType(irParamType);
             break;
         case kParameterDirection_Ref:
-            irParamType = builder->getRefType(irParamType);
+            irParamType = builder->getRefType(irParamType, AddressSpace::Generic);
             break;
         case kParameterDirection_ConstRef:
             irParamType = builder->getConstRefType(irParamType);
@@ -4972,7 +4980,6 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo>
         case LoweredValInfo::Flavor::Ptr:
             return LoweredValInfo::ptr(
                 builder->emitElementAddress(
-                    context->irBuilder->getPtrType(type),
                     baseVal.val,
                     indexVal));
 
diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp
index 0b92d07af..d6efb47b3 100644
--- a/source/slang/slang-syntax.cpp
+++ b/source/slang/slang-syntax.cpp
@@ -706,7 +706,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt
             auto paramType = getParamType(astBuilder, paramDeclRef);
             if( paramDecl->findModifier<RefModifier>() )
             {
-                paramType = astBuilder->getRefType(paramType);
+                paramType = astBuilder->getRefType(paramType, AddressSpace::Generic);
             }
             else if (paramDecl->findModifier<ConstRefModifier>())
             {
diff --git a/source/slang/slang-type-system-shared.h b/source/slang/slang-type-system-shared.h
index 2f467a05a..404c84cf4 100644
--- a/source/slang/slang-type-system-shared.h
+++ b/source/slang/slang-type-system-shared.h
@@ -58,6 +58,20 @@ FOREACH_BASE_TYPE(DEFINE_BASE_TYPE)
     const int kStdlibTextureIsShadowParameterIndex = 6;
     const int kStdlibTextureIsCombinedParameterIndex = 7;
     const int kStdlibTextureFormatParameterIndex = 8;
+
+    enum class AddressSpace : uint64_t
+    {
+        Generic = 0x7fffffff,
+        ThreadLocal = 1,
+        Global = 2,
+        GroupShared = 3,
+        Uniform = 4,
+        // specific address space for payload data in metal
+        MetalObjectData = 5,
+
+        // Default address space for a user-defined pointer
+        UserPointer = 0x100000001ULL,
+    };
 }
 
 #endif