[CBP] Pointer frontend changes + groupshared pointer support (#7848)

Resolves #7628
Resolves: #8197

Primary Goals:
1. Add `Access` to pointer
2. AddressSpace::GroupShared support for pointers (SPIR-V)
3. Add `__getAddress()` to replace `&`
* `&` is not updated to `require(cpu)` since slangpy uses `&`. This
means we must: (1) merge PR; (2) replace `&` with `__getAddress()`; (3)
add `require(cpu)` to `&`

Changes:
* Added to `Ptr` the `Access` generic argument & logic (for
`Access::Read`).
* Moved the generic argument `AddressSpace` from `Ptr` to the end of the
type.
* Added pointer casting support between any `Ptr` as long as the
`AddressSpace` is the same
* Disallow globallycoherent T* and coherent T*
* Disallow const T*, T const*, and const T*
* Fixed .natvis display of `ConstantValue` `ValOperandNode`
* Support generic resolution of type-casted integers
* Added `VariablePointer` emitting for spirv + other minor logic needed
for groupshared pointers

Breaking Changes:
* Anyone using the `AddressSpace` of `Ptr` will now have to account for
the `Access` argument
* we disallow various syntax paired with `Ptr` and `T*`

---------

Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>

1 files changed, 48 insertions, 11 deletions

diff --git a/source/slang/slang-ast-type.cpp b/source/slang/slang-ast-type.cpp
index 8a224b305..53f6626d7 100644
--- a/source/slang/slang-ast-type.cpp
+++ b/source/slang/slang-ast-type.cpp
@@ -439,11 +439,28 @@ Type* NativeRefType::getValueType()
     return as<Type>(_getGenericTypeArg(this, 0));
 }
 
-Val* PtrTypeBase::getAddressSpace()
+
+Val* PtrTypeBase::getAccessQualifier()
 {
     return _getGenericTypeArg(this, 1);
 }
 
+Val* PtrTypeBase::getAddressSpace()
+{
+    return _getGenericTypeArg(this, 2);
+}
+
+AccessQualifier tryGetAccessQualifierValue(Val* val)
+{
+    AccessQualifier accessQualifier = AccessQualifier::ReadWrite;
+
+    if (auto cintVal = as<ConstantIntVal>(val))
+    {
+        accessQualifier = (AccessQualifier)(cintVal->getValue());
+    }
+    return accessQualifier;
+}
+
 AddressSpace tryGetAddressSpaceValue(Val* addrSpaceVal)
 {
     AddressSpace addrSpace = AddressSpace::Generic;
@@ -460,19 +477,38 @@ void maybePrintAddrSpaceOperand(StringBuilder& out, AddressSpace addrSpace)
     switch (addrSpace)
     {
     case AddressSpace::Generic:
+        out << toSlice(", AddressSpace::Generic");
+        break;
     case AddressSpace::UserPointer:
+        // We expose UserPointer as Device to users
+        out << toSlice(", AddressSpace::Device");
         break;
     case AddressSpace::GroupShared:
-        out << toSlice(", groupshared");
+        out << toSlice(", AddressSpace::GroupShared");
         break;
     case AddressSpace::Global:
-        out << toSlice(", global");
+        out << toSlice(", AddressSpace::Global");
         break;
     case AddressSpace::ThreadLocal:
-        out << toSlice(", threadlocal");
+        out << toSlice(", AddressSpace::ThreadLocal");
         break;
     case AddressSpace::Uniform:
-        out << toSlice(", uniform");
+        out << toSlice(", AddressSpace::Uniform");
+        break;
+    default:
+        break;
+    }
+}
+
+void maybePrintAccessQualifierOperand(StringBuilder& out, AccessQualifier accessQualifier)
+{
+    switch (accessQualifier)
+    {
+    case AccessQualifier::ReadWrite:
+        out << toSlice(", Access::ReadWrite");
+        break;
+    case AccessQualifier::Read:
+        out << toSlice(", Access::Read");
         break;
     default:
         break;
@@ -481,20 +517,21 @@ void maybePrintAddrSpaceOperand(StringBuilder& out, AddressSpace addrSpace)
 
 void PtrType::_toTextOverride(StringBuilder& out)
 {
+    auto accessQualifier = tryGetAccessQualifierValue(getAccessQualifier());
     auto addrSpace = tryGetAddressSpaceValue(getAddressSpace());
-    if (addrSpace == AddressSpace::Generic)
-        out << toSlice("Addr<") << getValueType();
-    else
-        out << toSlice("Ptr<") << getValueType();
+    out << toSlice("Ptr<") << getValueType();
+    maybePrintAccessQualifierOperand(out, accessQualifier);
     maybePrintAddrSpaceOperand(out, addrSpace);
     out << toSlice(">");
 }
 
 void RefType::_toTextOverride(StringBuilder& out)
 {
+    auto accessQualifier = tryGetAccessQualifierValue(getAccessQualifier());
+    auto addrSpace = tryGetAddressSpaceValue(getAddressSpace());
     out << toSlice("Ref<") << getValueType();
-    auto addressSpaceVal = getAddressSpace();
-    maybePrintAddrSpaceOperand(out, tryGetAddressSpaceValue(addressSpaceVal));
+    maybePrintAccessQualifierOperand(out, accessQualifier);
+    maybePrintAddrSpaceOperand(out, addrSpace);
     out << toSlice(">");
 }