More work on IR-based lowering and cross-compilation

None of these changes are made "live" at the moment. I'm just trying to get them checked in to avoid divering too far from `master` at any point during development.

- Add basic emit logic to produce GLSL from the IR in a few cases (the existing IR emit logic was ad hoc and HLSL-specific)

- When lowering a function declaration, walk up its chain of parent declarations to collect additional parameters as needed

- When lowering a call, make sure to add generic arguments that come from the declaration reference being called

- Attach a "mangled name" to symbols when lowering, so that we can eventually use that name to resolve things for linkage.

- After the above work, I had to apply some fixups to make sure that generic arguments *don't* get added when the user is calling an `__intrinsic_op` function, since those should map 1-to-1 down to instructions with just their ordinary parameter list.

A big open question right now is whether I should continue to represent the generic arguments as just part of the ordinary argument list for a function, or split them out into separate `applyGeneric` and `apply` steps.
A strongly related question is whether a declaration with generic parameters should lower into a single declaration, or one declaration nested inside an outer generic declaration.

A good future step at this point would be to eliminate a lot of the `__intrinsic_op` stuff in favor of having the builtin functions include their own definitions, which might be in terms of a new expression-level construct for writing inline IR operations. This can't be done until the existing AST-to-AST path is no longer needed for cross-compilation purposes.

More immediate next steps here:

- We need a way to round-trip calls to external declaration that get handled by this mangled-name logic. Basically, if we are asked to output HLSL and we see a call to `_S...GetDimensions...(float4, t, a, ...)` we need to be able to walk the mangled name and get back to `t.getDimensions(a, ...)` without a whole lot of manual definitions to make things round-trip.

- In the other case, where a declaration isn't built-in for the chosen target, we need to be able to load a module of target-specific definitions (which will somehow map back to symbols with certain mangled names) and then look these up (by mangled name) and then load/link/inline them into the user's IR to satisfy requirements in their code.

1 files changed, 61 insertions, 15 deletions

diff --git a/source/slang/ir.cpp b/source/slang/ir.cpp
index 2c6395903..3e12ef1a2 100644
--- a/source/slang/ir.cpp
+++ b/source/slang/ir.cpp
@@ -83,7 +83,14 @@ namespace Slang
         auto entryBlock = getFirstBlock();
         if(!entryBlock) return nullptr;
 
-        auto firstInst = entryBlock->firstChild;
+        return entryBlock->getFirstParam();
+    }
+
+    // IRBlock
+
+    IRParam* IRBlock::getFirstParam()
+    {
+        auto firstInst = firstChild;
         if(!firstInst) return nullptr;
 
         if(firstInst->op != kIROp_Param)
@@ -92,6 +99,7 @@ namespace Slang
         return (IRParam*) firstInst;
     }
 
+
     // IRParam
 
     IRParam* IRParam::getNextParam()
@@ -781,6 +789,18 @@ namespace Slang
         return getArrayType(elementType, nullptr);
     }
 
+    IRType* IRBuilder::getGenericParameterType(UInt index)
+    {
+        auto indexVal = getIntValue(getBaseType(BaseType::Int), index);
+
+        return findOrEmitInst<IRGenericParameterType>(
+            this,
+            kIROp_GenericParameterType,
+            getTypeType(),
+            indexVal);
+
+    }
+
 
     IRType* IRBuilder::getTypeType()
     {
@@ -1442,6 +1462,11 @@ namespace Slang
         {
             dump(context, "<null>");
         }
+        else if( auto mangled = inst->findDecoration<IRMangledNameDecoration>() )
+        {
+            dump(context, "@");
+            dump(context, mangled->mangledName.Buffer());
+        }
         else if(inst->id)
         {
             dump(context, "%");
@@ -1526,6 +1551,21 @@ namespace Slang
             dumpID(context, type);
             break;
 
+        case kIROp_FuncType:
+            {
+                auto funcType = (IRFuncType*) type;
+                UInt paramCount = funcType->getParamCount();
+                dump(context, "(");
+                for( UInt pp = 0; pp < paramCount; ++pp )
+                {
+                    if(pp != 0) dump(context, ", ");
+                    dumpType(context, funcType->getParamType(pp));
+                }
+                dump(context, ") -> ");
+                dumpType(context, funcType->getResultType());
+            }
+            break;
+
         default:
             {
                 dump(context, opInfo.name);
@@ -1619,20 +1659,8 @@ namespace Slang
                 dumpIndent(context);
                 dump(context, "func ");
                 dumpID(context, func);
-                dump(context, "(\n");
-                context->indent++;
-                for (auto pp = func->getFirstParam(); pp; pp = pp->getNextParam())
-                {
-                    if (pp != func->getFirstParam())
-                        dump(context, ",\n");
-
-                    dumpIndent(context);
-                    dump(context, "param ");
-                    dumpID(context, pp);
-                    dumpInstTypeClause(context, pp->getType());
-                }
-                context->indent--;
-                dump(context, ")\n");
+                dumpInstTypeClause(context, func->getType());
+                dump(context, "\n");
 
                 dumpIndent(context);
                 dump(context, "{\n");
@@ -1665,6 +1693,24 @@ namespace Slang
                 context->indent--;
                 dump(context, "block ");
                 dumpID(context, block);
+
+                if( block->getFirstParam() )
+                {
+                    dump(context, "(");
+                    context->indent++;
+                    for (auto pp = block->getFirstParam(); pp; pp = pp->getNextParam())
+                    {
+                        if (pp != block->getFirstParam())
+                            dump(context, ",\n");
+
+                        dumpIndent(context);
+                        dump(context, "param ");
+                        dumpID(context, pp);
+                        dumpInstTypeClause(context, pp->getType());
+                    }
+                    context->indent--;
+                    dump(context, ")\n");
+                }
                 dump(context, ":\n");
                 context->indent++;