Improve SSA promotion for arrays and structs (#521)

* Improve SSA promotion for arrays and structs

Fixes #518

The existing SSA pass would only handle `load(v)` and `store(v,...)`
where `v` is the variable instruction, and would bail out if `v` was
used as an operand in any other fashion.

The new pass adds support for `load(ac)` where `ac` is an "access chain"
with a gramar like:

    ac :: v
        | getElementPtr(ac, ...)
	| getFieldAddress(ac, ...)

What this means in practical terms is that we can promote a local
variable of array or structure type to an SSA temporary even if there
are loads of individual elements/fields, as along as any *assignment* to
the variable assigns the whole thing.

I've added a test case to confirm that this change fixes passing of
arrays as function parameters for Vulkan.

* Fixup: disable test on Vulkan because render-test isn't ready

This is a fix for Vulkan, but I don't think our testing setup is ready
for it.

* Fixup: error in unreachable return case, caught by clang

* Fixups based on testing

These are fixes found when testing the original changes against the user code that originated the bug report.

* `emit.cpp`: Make sure to handle array-of-texture types when deciding whether to declare a temporary as a local variable in GLSL output

* `ir-legalize-types.cpp`: Make a not of a source of validation failures that we need to clean up sooner or later (just not in scope for this bug fix change).

* `ir-ssa.cpp`:
  * When checking if something is an access chain with a promotable var at the end, make sure the recursive case recurses into the "access chain" logic instead of the leaf case
  * Add some assertions to guard the assumption that any access chain we apply has been scheduled for removal
  * Correctly emit an element *extract* instead of getting an element *address* when promoting an element access into an array being promoted
  * Eliminate a wrapper routine that was setting up an `IRBuilder` and use the one from the block being processed in the SSA pass (since it was set up for stuff just like this)

* `ir-validate.cpp`
  * Add a hack to avoid validation failures when running IR validation on the stdlib code. This case triggers for an initializer (`__init`) declaration inside an interface, since the logical "return type" is the interface type itself, which has no representation at the IR level and thus yields a null result type in a `FuncType` instruction.

1 files changed, 10 insertions, 0 deletions

diff --git a/source/slang/ir-validate.cpp b/source/slang/ir-validate.cpp
index 1e36322f4..7c04c0873 100644
--- a/source/slang/ir-validate.cpp
+++ b/source/slang/ir-validate.cpp
@@ -75,6 +75,16 @@ namespace Slang
         auto instParent = inst->getParent();
 
         auto operandValue = operandUse->get();
+
+        if( !operandValue )
+        {
+            // A null operand should almost always be an error, but
+            // we currently have a few cases where this arises.
+            //
+            // TODO: plug the leaks.
+            return;
+        }
+
         auto operandParent = operandValue->getParent();
 
         if (auto instParentBlock = as<IRBlock>(instParent))