Change handling of strings for HLSL/GLSL targets (#1204)

* Change handling of strings for HLSL/GLSL targets

This change switches our handling of string literals and `getStringHash` to something that is more streamlined at the cost of potentially being less general/flexible.

* `String` is now allowed as a parameter type in user-defined functions

* `getStringHash` is now allowed to apply to `String`-type values that aren't literals

* The list of strings in an IR module is now generated during IR lowering as part of lowering a string literal expression, rather than being defined by recursively walking the IR of the module looking for `getStringHash` calls. The public API still refers to these as "hashed" strings, but they are realistically now "static strings."

* When emitting code for HLSL/GLSL, the `String` type emits as `int`, and `getStringHash(x)` emits as `x`.

In terms of implementation, the choice was whether to translate `String` over to `int` in an explicit IR pass, or to lump it into the emit pass. While adding the logic to emit clutters up an already complicated step, it is ultimately much easier to make the change there than to write a clean IR pass to eliminate all `String` use.

Note that other targets that can handle a more full-featured `String` type are *not* addressed by this change and thus do not support `String` at all. It may be woth emitting `String` as `const char*` on those targets, and emitting string literals directly, but the `getStringHash` function would need to be implemented in the "prelude" then, and we probably want to pick a well-known/-documented hash algorithm before we go that far.

This change also brings along some some clean-ups to the `gpu-printing` example, since it can now take advantage of the new functionality of `String`.

* Fix up tests for new string handling

* Add global string literal list to string-literal test (since we now list *all* static string literals and not just those passed to `getStringHash`)

* Disable `getStringHash` test on CPU, since we don't have a working `String` on that platform right now (only HLSL/GLSL)

Co-authored-by: Tim Foley <tim.foley.is@gmail.com>

3 files changed, 14 insertions, 23 deletions

diff --git a/examples/gpu-printing/gpu-printing.cpp b/examples/gpu-printing/gpu-printing.cpp
index ff35fd0b3..7503c8e03 100644
--- a/examples/gpu-printing/gpu-printing.cpp
+++ b/examples/gpu-printing/gpu-printing.cpp
@@ -219,7 +219,7 @@ void GPUPrinting::processGPUPrintCommands(const void* data, size_t dataSize)
                     // likely that the application code needs to be configured
                     // to pass in the right strings.
                     //
-                    fprintf(stderr, "error: string with unknown hash %d\n", hash);
+                    fprintf(stderr, "error: string with unknown hash 0x%x\n", hash);
                     continue;
                 }
 
@@ -253,7 +253,7 @@ void GPUPrinting::processGPUPrintCommands(const void* data, size_t dataSize)
                     // likely that the application code needs to be configured
                     // to pass in the right strings.
                     //
-                    fprintf(stderr, "error: string with unknown hash %d\n", formatHash);
+                    fprintf(stderr, "error: string with unknown hash 0x%x\n", formatHash);
                     continue;
                 }
                 std::string format = iter->second;
@@ -373,7 +373,7 @@ void GPUPrinting::processGPUPrintCommands(const void* data, size_t dataSize)
                             auto iter = m_hashedStrings.find(hash);
                             if(iter == m_hashedStrings.end())
                             {
-                                fprintf(stderr, "error: string with unknown hash %d\n", hash);
+                                fprintf(stderr, "error: string with unknown hash 0x%x\n", hash);
                                 continue;
                             }
                             printf("%s", iter->second.c_str());
diff --git a/examples/gpu-printing/kernels.slang b/examples/gpu-printing/kernels.slang
index ec4533958..8693bfed1 100644
--- a/examples/gpu-printing/kernels.slang
+++ b/examples/gpu-printing/kernels.slang
@@ -29,10 +29,10 @@ void computeMain(uint3 tid : SV_DispatchThreadID)
     // in terms of their hash code, and the current Slang implementation
     // of `getStringHash` only applies to string literals.
     //
-    println(getStringHash("hello from thread number "), tid.x);
+    println("hello from thread number ", tid.x);
 
     // The second facility supported by `printing.slang` is a C-style
     // `printf()` function.
     //
-    printf(getStringHash("printf from thread 0x%x\n"), tid.x);
+    printf("printf from thread 0x%x\n", tid.x);
 }
diff --git a/examples/gpu-printing/printing.slang b/examples/gpu-printing/printing.slang
index 47d102f97..941a1518b 100644
--- a/examples/gpu-printing/printing.slang
+++ b/examples/gpu-printing/printing.slang
@@ -199,23 +199,14 @@ extension uint : IPrintable // <-- Note: we are adding a conformance to `IPrinta
     }
 }
 
-// HACK: Because we currently don't have a `String` type that we
-// can pass down into subroutines, we will be using the hash
-// code of a string to represent the string itself. These hash
-// codes currently have type `int`, so our printing library
-// will *always* assume that an `int` represents a hashed
-// string, and thus we can't print plain old `int`s right now.
-
-typedef int StringHash;
-
-extension StringHash : IPrintable
+extension String : IPrintable
 {
     uint getPrintWordCount() { return 2; }
 
     void writePrintWords(RWStructuredBuffer<uint> buffer, uint offset)
     {
         buffer[offset++] = (uint(PrintingOp.String) << 16) | 1;
-        buffer[offset++] = this;
+        buffer[offset++] = getStringHash(this);
     }
 }
 
@@ -294,7 +285,7 @@ void println<A : IPrintable, B : IPrintable, C : IPrintable>(
 // work.
 //
 
-uint _beginPrintf(int formatStrngHash, uint wordCount)
+uint _beginPrintf(String format, uint wordCount)
 {
     // A printf command will start with the usual command header word,
     // along with a word for the (hashed) format string. These
@@ -303,7 +294,7 @@ uint _beginPrintf(int formatStrngHash, uint wordCount)
     //
     uint wordOffset = _allocatePrintWords(wordCount + 2);
     gPrintBuffer[wordOffset++] = (uint(PrintingOp.PrintF) << 16) | (wordCount+1);
-    gPrintBuffer[wordOffset++] = formatStrngHash;
+    gPrintBuffer[wordOffset++] = getStringHash(format);
     return wordOffset;
 }
 
@@ -337,26 +328,26 @@ extension uint : IPrintf
     }
 }
 
-extension StringHash : IPrintf
+extension String : IPrintf
 {
     uint getPrintfWordCount() { return 1; }
 
     void writePrintfWords(RWStructuredBuffer<uint> buffer, uint offset)
     {
-        buffer[offset++] = this;
+        buffer[offset++] = getStringHash(this);
     }
 }
 
 
 // A `printf()` with no format arguments can just call back to `_beginPrintf()`
-void printf(StringHash format)
+void printf(String format)
 {
     _beginPrintf(format, 0);
 }
 
 // The `printf()` cases with one or more format arguments are all quite similar.
 
-void printf<A : IPrintf>(StringHash format, A a)
+void printf<A : IPrintf>(String format, A a)
 {
     // We need to compute the words required by each format argument
     // and sum them up.
@@ -375,7 +366,7 @@ void printf<A : IPrintf>(StringHash format, A a)
     a.writePrintfWords(gPrintBuffer, wordOffset); wordOffset += aCount;
 }
 
-void printf<A : IPrintf, B : IPrintf>(StringHash format, A a, B b)
+void printf<A : IPrintf, B : IPrintf>(String format, A a, B b)
 {
     uint wordCount = 0;
     uint aCount = a.getPrintfWordCount(); wordCount += aCount;