Remove uses of global variables

There were two main places where global variables were used in the Slang implementation:

1. The "standard library" code was generated as a string at run-time, and stored in a global variable so that it could be amortized across compiles.

2. The representation of types uses some globals (well, class `static` members) to store common types (e.g., `void`) and to deal with memory lifetime for things like canonicalized types.

In each case the "simple" fix is to move the relevant state into the `Session` type that controlled their lifetime already (the `Session` destructor was already cleaning up these globals to avoid leaks).

For the standard library stuff this really was easy, but for the types it required threading through the `Session` a bit carefully.

One more case that I found: there was a function-`static` variable used to generate a unique ID for files output when dumping of intermediates is enabled (this is almost strictly a debugging option).
Rather than make this counter per-session (which would lead to different sessions on different threads clobbering the same few files), I went ahead and used an atomic in this case.

Note that the remaining case I had been worried about was any function-`static` counter that might be used in generating unique names.
It  turns out that right now the parser doesn't use such a counter (even in cases where it probably should), and the lowering pass already uses a counter local to the pass (again, whether or not this is a good idea).

This change should be a major step toward allowing an application to use Slang in multiple threads, so long as each thread uses a distinct `SlangSession`. The case of using a single session across multiple threads is harder to support, and will require more careful implementation work.

1 files changed, 14 insertions, 3 deletions

diff --git a/source/slang/compiler.cpp b/source/slang/compiler.cpp
index 6bb8abe7e..60f111d83 100644
--- a/source/slang/compiler.cpp
+++ b/source/slang/compiler.cpp
@@ -8,7 +8,6 @@
 #include "parser.h"
 #include "preprocessor.h"
 #include "syntax-visitors.h"
-#include "slang-stdlib.h"
 
 #include "reflection.h"
 #include "emit.h"
@@ -883,8 +882,20 @@ namespace Slang
         char const*     ext,
         bool            isBinary)
     {
-        static int counter = 0;
-        int id = counter++;
+        // Try to generate a unique ID for the file to dump,
+        // even in cases where there might be multiple threads
+        // doing compilation.
+        //
+        // This is primarily a debugging aid, so we don't
+        // really need/want to do anything too elaborate
+
+        static uint32_t counter = 0;
+#ifdef WIN32
+        uint32_t id = InterlockedIncrement(&counter);
+#else
+        // TODO: actually implement the case for other platforms
+        uint32_t id = counter++;
+#endif
 
         String path;
         path.append("slang-dump-");