Work on IR-based cross-compilation (#222)

There are two big changes here:

- Add logic during the initial IR cloning pass for an entry point + target that tries to pick the best possible version of any target-overloaded function. This allows us to pick the intrinsic version of `saturate()` when compiling for HLSL output, but then pick the non-intrinsic version (that is implemented in terms of `clamp()`) when targetting GLSL.

- Add an initial specialization pass that tries to deal with generics. This required some fixing work to IR generation, so that we correctly generate explicit operations to specialize a generic for specific types (this is currently implemented as a `specialize` instruction that takes the generic to specialize plus a declaration-reference that represents the specialized form). With that work in place, we can scan for `specialize` instructions inside of non-generic functions, and use them to trigger generation of specialized code. We rely on the name-mangling scheme to help us find pre-existing specializations when possible.

There are also a bunch of cleanups encountered along the way:

- Don't use the explicit `layout(offset=...)` for uniforms, because it isn't supported by all current drivers. For now we will just assume that our layout rules compute the same values that the driver would for un-marked-up code. We can come back later and try to implement a workaround in the cases where this doesn't apply (e.g., by re-running the layout logic as part of emission, and dropping layout modifiers from variables that don't need explicit layout).

- Fix some issues in IR dump printing so that we print function declarations more nicely.

- Testing: print out failing pixel when image-diff fails

1 files changed, 9 insertions, 1 deletions

diff --git a/tools/slang-test/main.cpp b/tools/slang-test/main.cpp
index 83d512cc1..5c0c81392 100644
--- a/tools/slang-test/main.cpp
+++ b/tools/slang-test/main.cpp
@@ -1205,9 +1205,10 @@ TestResult doImageComparison(String const& filePath)
             continue;
         }
 
+        float relativeDiff = 0.0f;
         if( expectedVal != 0 )
         {
-            float relativeDiff = fabsf(float(actualVal) - float(expectedVal)) / float(expectedVal);
+            relativeDiff = fabsf(float(actualVal) - float(expectedVal)) / float(expectedVal);
 
             if( relativeDiff < kRelativeDiffCutoff )
             {
@@ -1220,6 +1221,13 @@ TestResult doImageComparison(String const& filePath)
         // cases where vertex shader results lead to rendering that is off
         // by one pixel...
 
+        fprintf(stderr, "image compare failure at (%d,%d) channel %d. expected %d got %d (absolute error: %d, relative error: %f)\n",
+            x, y, n,
+            expectedVal,
+            actualVal,
+            absoluteDiff,
+            relativeDiff);
+
         // There was a difference we couldn't excuse!
         return kTestResult_Fail;
     }