IR: fixes for subscript accessors (#322)

* IR: fixes for subscript accessors

Fixes #320

This is a bunch of fixes for handling of `__subscript` operations on builtin types (notably `RWStructuredBuffer` and `StructuredBuffer` at this point).

- Automatically add a `GetterDecl` to any subscript decalratio was declithout any accessors. This avoids hitting a null- dereference in the emit logic.

- Add a notion of a `RefAccessor` (declared with `ref`) as a peer to getters and setters. The idea is that a `ref` accessor returns a pointer to the element data, so that it can be used for both getting and setting values. This is closer to the behavior of `RWStructuredBuffer` element access in HLSL.

- Fixes for dealing with "access chains" where there might be a combination of a subscript (where the is a `get` and `set` but no `ref`) and member access, so that we have to read the base value into a temp, modify it, and then write it back.
  - This logic is still a bit of a mess, so we will eventually want to take a more consistent pass over this to deal with how we "materialize" values for setters.

- Update `RWStructuredBuffer` to have a `ref` accessor, and then fix up the IR tests to handle the new opcode that I added for it.
  - Note: I didn't handle this as an intrinsic simply because the `tests/ir/*` tests aren't really set up to handle builtins with ugly mangled names.

* Fixup: type error in VM for buffer element ref

I was using the result type of the op as the element type for computing the element address, but the result type is a pointer to the real element type.
This caused test failures on 64-bit platforms, where the stride of the buffer in the `ir/factorial` test needs to be 4.

The fix is to assume the result type is a pointer, and extract the pointed-to type out of that.

1 files changed, 27 insertions, 0 deletions

diff --git a/source/slang/vm.cpp b/source/slang/vm.cpp
index d795a841b..ffc455232 100644
--- a/source/slang/vm.cpp
+++ b/source/slang/vm.cpp
@@ -877,6 +877,33 @@ void resumeThread(
                 memcpy(elementData, srcPtr, size);
             }
             break;
+
+        case kIROp_BufferElementRef:
+            {
+                VMType ptrType = decodeType(frame, &ip);
+                VMType type = ((VMPtrTypeImpl*)ptrType.getImpl())->base;
+
+                UInt argCount = decodeUInt(&ip);
+                void* argPtrs[16] = { 0 };
+                for( UInt aa = 0; aa < argCount; ++aa )
+                {
+                    void* argPtr = decodeOperandPtr<void>(frame, &ip);
+                    argPtrs[aa] = argPtr;
+                }
+
+                void* dest = decodeOperandPtr<void>(frame, &ip);
+
+                char* bufferData = *(char**)argPtrs[0];
+                uint32_t index = *(uint32_t*)argPtrs[1];
+
+                auto size = type.getSize();
+                char* elementData = bufferData + index*size;
+
+                *(void**)dest = elementData;
+            }
+            break;
+
+
         case kIROp_Call:
             {
                 VMType type = decodeType(frame, &ip);