WIP: Preliminary Slang -> C++ code generation (#1009)

* Expanded prelude for some other resource types. Disable C++ output for ParameterGroup.

* WIP: Layout for CPU.

* Fixes to CPU layout.

* WIP: The uniform is output, but the variable definition is not.

* WIP: Entry point parameters to global scope in C++.
Handling of resource types (in so far as outputting)

* Some discussion of ABI and different input types.

* WIP: More C++ support around resource types.

* WIP: Split up variables into different structures on emit.

* WIP: Emitting C++ with wrapping up of 'Context'

* WIP: C++ code has access to semantic values.
Wrap in struct so can use method calls to pass shared state.
Disable  legalizeResourceTypes and legalizeExistentialTypeLayout

* Fix structured buffer layout for CPU.

* Remove testing/handling of global uniforms on CPU path.
Typo fix.
Changed CPU tests to use new CPU calling convention.

* Check globals are working. Initalize context to zero globals.

* Order the global parameters for C++ ouput by their layout.
Note - that layout isn't quite working correctly because the StructuredBuffer<int> the int seems to be consuming uniform space.

* Work around for reflection not having all data needed for layout ordering for C++ code.

* Output constant buffers as pointers.

* Entry point parameters accessed through pointer to struct.

* WIP: Layout for CPU is reasonable for test case.

* Only output 'f' after float literal if type marks as a float.

* Cast construction works on C++.

* Made IntrinsicOp::ConvertConstruct to make intent clearer.

* C++ handling construction from scalar.
Handle access of a scalar with .x.
Check default initialization.

* Comment about need for split of kIROp_construct.
Release build works.

* Added support from constructVectorFromScalar to C/C++ target.

* Handling of in/out in C/C++.

* First pass documentation CPU support.

* Improvements to C++/C slang code generation documentation.

* Small doc change to include need for mechansim to specify cpp compiler path.

* Better handling of swizzling - allow swizzling a scalar into a vector.

1 files changed, 53 insertions, 49 deletions

diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index d5dcaca98..205f8ee0e 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -305,7 +305,7 @@ String emitEntryPoint(
         // parameters of a shader entry point and move them into
         // the global scope instead.
         //
-        moveEntryPointUniformParamsToGlobalScope(irModule);
+        moveEntryPointUniformParamsToGlobalScope(irModule, target);
 #if 0
         dumpIRIfEnabled(compileRequest, irModule, "ENTRY POINT UNIFORMS MOVED");
 #endif
@@ -361,56 +361,60 @@ String emitEntryPoint(
 #endif
         validateIRModuleIfEnabled(compileRequest, irModule);
 
-        // The Slang language allows interfaces to be used like
-        // ordinary types (including placing them in constant
-        // buffers and entry-point parameter lists), but then
-        // getting them to lay out in a reasonable way requires
-        // us to treat fields/variables with interface type
-        // *as if* they were pointers to heap-allocated "objects."
-        //
-        // Specialization will have replaced fields/variables
-        // with interface types like `IFoo` with fields/variables
-        // with pointer-like types like `ExistentialBox<SomeType>`.
-        //
-        // We need to legalize these pointer-like types away,
-        // which involves two main changes:
-        //
-        //  1. Any `ExistentialBox<...>` fields need to be moved
-        //  out of their enclosing `struct` type, so that the layout
-        //  of the enclosing type is computed as if the field had
-        //  zero size.
-        //
-        //  2. Once an `ExistentialBox<X>` has been floated out
-        //  of its parent and landed somwhere permanent (e.g., either
-        //  a dedicated variable, or a field of constant buffer),
-        //  we need to replace it with just an `X`, after which we
-        //  will have (more) legal shader code.
-        //
-        legalizeExistentialTypeLayout(
-            irModule,
-            sink);
-        eliminateDeadCode(compileRequest, irModule);
-
+        // We don't need the legalize pass for C/C++ based types
+        if (!(sourceStyle == SourceStyle::CPP || sourceStyle == SourceStyle::C))
+        {
+            // The Slang language allows interfaces to be used like
+            // ordinary types (including placing them in constant
+            // buffers and entry-point parameter lists), but then
+            // getting them to lay out in a reasonable way requires
+            // us to treat fields/variables with interface type
+            // *as if* they were pointers to heap-allocated "objects."
+            //
+            // Specialization will have replaced fields/variables
+            // with interface types like `IFoo` with fields/variables
+            // with pointer-like types like `ExistentialBox<SomeType>`.
+            //
+            // We need to legalize these pointer-like types away,
+            // which involves two main changes:
+            //
+            //  1. Any `ExistentialBox<...>` fields need to be moved
+            //  out of their enclosing `struct` type, so that the layout
+            //  of the enclosing type is computed as if the field had
+            //  zero size.
+            //
+            //  2. Once an `ExistentialBox<X>` has been floated out
+            //  of its parent and landed somwhere permanent (e.g., either
+            //  a dedicated variable, or a field of constant buffer),
+            //  we need to replace it with just an `X`, after which we
+            //  will have (more) legal shader code.
+            //
+            legalizeExistentialTypeLayout(
+                irModule,
+                sink);
+            eliminateDeadCode(compileRequest, irModule);
+        
 #if 0
-        dumpIRIfEnabled(compileRequest, irModule, "EXISTENTIALS LEGALIZED");
+            dumpIRIfEnabled(compileRequest, irModule, "EXISTENTIALS LEGALIZED");
 #endif
-        validateIRModuleIfEnabled(compileRequest, irModule);
-
-        // Many of our target languages and/or downstream compilers
-        // don't support `struct` types that have resource-type fields.
-        // In order to work around this limitation, we will rewrite the
-        // IR so that any structure types with resource-type fields get
-        // split into a "tuple" that comprises the ordinary fields (still
-        // bundles up as a `struct`) and one element for each resource-type
-        // field (recursively).
-        //
-        // What used to be individual variables/parameters/arguments/etc.
-        // then become multiple variables/parameters/arguments/etc.
-        //
-        legalizeResourceTypes(
-            irModule,
-            sink);
-        eliminateDeadCode(compileRequest, irModule);
+            validateIRModuleIfEnabled(compileRequest, irModule);
+
+            // Many of our target languages and/or downstream compilers
+            // don't support `struct` types that have resource-type fields.
+            // In order to work around this limitation, we will rewrite the
+            // IR so that any structure types with resource-type fields get
+            // split into a "tuple" that comprises the ordinary fields (still
+            // bundles up as a `struct`) and one element for each resource-type
+            // field (recursively).
+            //
+            // What used to be individual variables/parameters/arguments/etc.
+            // then become multiple variables/parameters/arguments/etc.
+            //
+            legalizeResourceTypes(
+                irModule,
+                sink);
+            eliminateDeadCode(compileRequest, irModule);
+        }
 
         //  Debugging output of legalization
 #if 0