Heterogeneous Flag Error Visibility (#1642)

* PR to fix issue #1638.  This change introduces a diagnostic sink to the
emitModule function, and updates all associated calls to that function.
Additionally, this commit updates the heterogeneous hello world example
to not need the entry and stage flags for simplicity.

* Updated emit-cpp per suggested changes

Co-authored-by: Tim Foley <tfoleyNV@users.noreply.github.com>

7 files changed, 47 insertions, 29 deletions

diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index eefa2363c..9d208b8a3 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -3892,13 +3892,15 @@ void CLikeSourceEmitter::executeEmitActions(List<EmitAction> const& actions)
     }
 }
 
-void CLikeSourceEmitter::emitModuleImpl(IRModule* module)
+void CLikeSourceEmitter::emitModuleImpl(IRModule* module, DiagnosticSink* sink)
 {
     // The IR will usually come in an order that respects
     // dependencies between global declarations, but this
     // isn't guaranteed, so we need to be careful about
     // the order in which we emit things.
 
+    SLANG_UNUSED(sink);
+
     List<EmitAction> actions;
 
     computeEmitActions(module, actions);
diff --git a/source/slang/slang-emit-c-like.h b/source/slang/slang-emit-c-like.h
index 9c6da8a64..0b6e63110 100644
--- a/source/slang/slang-emit-c-like.h
+++ b/source/slang/slang-emit-c-like.h
@@ -283,7 +283,8 @@ public:
     void computeEmitActions(IRModule* module, List<EmitAction>& ioActions);
 
     void executeEmitActions(List<EmitAction> const& actions);
-    void emitModule(IRModule* module) { m_irModule = module; emitModuleImpl(module); }
+    void emitModule(IRModule* module, DiagnosticSink* sink)
+        { m_irModule = module; emitModuleImpl(module, sink); }
 
         /// Emit any preprocessor directives that should come *before* the prelude code
         ///
@@ -331,7 +332,7 @@ public:
     virtual void emitMatrixLayoutModifiersImpl(IRVarLayout* layout) { SLANG_UNUSED(layout);  }
     virtual void emitTypeImpl(IRType* type, const StringSliceLoc* nameLoc);
     virtual void emitSimpleValueImpl(IRInst* inst);
-    virtual void emitModuleImpl(IRModule* module);
+    virtual void emitModuleImpl(IRModule* module, DiagnosticSink* sink);
     virtual void emitSimpleFuncImpl(IRFunc* func);
     virtual void emitVarExpr(IRInst* inst, EmitOpInfo const& outerPrec);
     virtual void emitOperandImpl(IRInst* inst, EmitOpInfo const& outerPrec);
diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp
index e02ca3007..2a4b14954 100644
--- a/source/slang/slang-emit-cpp.cpp
+++ b/source/slang/slang-emit-cpp.cpp
@@ -2553,7 +2553,7 @@ void CPPSourceEmitter::_emitForwardDeclarations(const List<EmitAction>& actions)
     }
 }
 
-void CPPSourceEmitter::emitModuleImpl(IRModule* module)
+void CPPSourceEmitter::emitModuleImpl(IRModule* module, DiagnosticSink* sink)
 {
     // If we are emitting a heterogeneous program
     // Emit the binary blob of each non-CPP target
@@ -2589,34 +2589,49 @@ void CPPSourceEmitter::emitModuleImpl(IRModule* module)
                             default:
 
                                 auto targetProgram = program->getTargetProgram(targetRequest);
-                                DiagnosticSink sink(linkage->getSourceManager());
                                 CompileResult result =
-                                    targetProgram->getOrCreateEntryPointResult(index, &sink);
+                                    targetProgram->getOrCreateEntryPointResult(index, sink);
 
                                 Slang::ComPtr<ISlangBlob> blob;
                                 if (SLANG_FAILED(result.getBlob(blob)))
                                 {
-                                    SLANG_UNEXPECTED("No blob to emit");
-                                    return;
+                                    sink->diagnoseRaw(Severity::Error,
+                                        "Slang heterogeneous error: No blob to emit\n");
+                                    m_writer->emit("size_t __");
+                                    m_writer->emit(entryPointName);
+                                    m_writer->emit("Size = 0;\n");
+                                    m_writer->emit("unsigned char __");
+                                    m_writer->emit(entryPointName);
+                                    m_writer->emit("[1];\n");
                                 }
 
-                                auto ptr = (const unsigned char*)blob->getBufferPointer();
-
-                                m_writer->emit("size_t __");
-                                m_writer->emit(entryPointName );
-                                m_writer->emit("Size = ");
-                                m_writer->emitInt64(blob->getBufferSize());
-                                m_writer->emit(";\n");
-
-                                m_writer->emit("unsigned char __");
-                                m_writer->emit(entryPointName );
-                                m_writer->emit("[] = {");
-                                for (unsigned int i = 0; i < blob->getBufferSize() - 1; i++) {
-                                    m_writer->emitUInt64(ptr[i]);
-                                    m_writer->emit(", ");
+                                else
+                                {
+                                    auto ptr = (const unsigned char*)blob->getBufferPointer();
+
+                                    m_writer->emit("size_t __");
+                                    m_writer->emit(entryPointName);
+                                    m_writer->emit("Size = ");
+                                    m_writer->emitInt64(blob->getBufferSize());
+                                    m_writer->emit(";\n");
+
+                                    m_writer->emit("unsigned char __");
+                                    m_writer->emit(entryPointName);
+                                    m_writer->emit("[] = {");
+                                    // every 20 bytes, emit a newline
+                                    size_t j = 0;
+                                    for (size_t i = 0; i < blob->getBufferSize(); i++) {
+                                        m_writer->emitUInt64(ptr[i]);
+                                        m_writer->emit(", ");
+                                        if (j == 20)
+                                        {
+                                            m_writer->emit("\n");
+                                            j = 0;
+                                        }
+                                        j++;
+                                    }
+                                    m_writer->emit("};\n");
                                 }
-                                m_writer->emitUInt64(ptr[blob->getBufferSize() - 1]);
-                                m_writer->emit("};\n");
                             }
                         }
                         // Emit a wrapper function for calling the shader blob
diff --git a/source/slang/slang-emit-cpp.h b/source/slang/slang-emit-cpp.h
index b1ca7475f..2ff922421 100644
--- a/source/slang/slang-emit-cpp.h
+++ b/source/slang/slang-emit-cpp.h
@@ -61,7 +61,7 @@ protected:
     virtual void emitPreprocessorDirectivesImpl() SLANG_OVERRIDE;
     virtual void emitSimpleValueImpl(IRInst* value) SLANG_OVERRIDE;
     virtual void emitSimpleFuncParamImpl(IRParam* param) SLANG_OVERRIDE;
-    virtual void emitModuleImpl(IRModule* module) SLANG_OVERRIDE;
+    virtual void emitModuleImpl(IRModule* module, DiagnosticSink* sink) SLANG_OVERRIDE;
     virtual void emitSimpleFuncImpl(IRFunc* func) SLANG_OVERRIDE;
     virtual void emitOperandImpl(IRInst* inst, EmitOpInfo const&  outerPrec) SLANG_OVERRIDE;
     virtual void emitParamTypeImpl(IRType* type, String const& name) SLANG_OVERRIDE;
diff --git a/source/slang/slang-emit-cuda.cpp b/source/slang/slang-emit-cuda.cpp
index 60387ca7f..5b29c9e81 100644
--- a/source/slang/slang-emit-cuda.cpp
+++ b/source/slang/slang-emit-cuda.cpp
@@ -729,7 +729,7 @@ bool CUDASourceEmitter::tryEmitGlobalParamImpl(IRGlobalParam* varDecl, IRType* v
 }
 
 
-void CUDASourceEmitter::emitModuleImpl(IRModule* module)
+void CUDASourceEmitter::emitModuleImpl(IRModule* module, DiagnosticSink* sink)
 {
     // Setup all built in types used in the module
     m_typeSet.addAllBuiltinTypes(module);
@@ -747,7 +747,7 @@ void CUDASourceEmitter::emitModuleImpl(IRModule* module)
 
     // TODO(JS): We may need to generate types (for example for matrices)
 
-    CLikeSourceEmitter::emitModuleImpl(module);
+    CLikeSourceEmitter::emitModuleImpl(module, sink);
 
     // Emit all witness table definitions.
     _emitWitnessTableDefinitions();
diff --git a/source/slang/slang-emit-cuda.h b/source/slang/slang-emit-cuda.h
index 01fc3fb5b..fefa40a11 100644
--- a/source/slang/slang-emit-cuda.h
+++ b/source/slang/slang-emit-cuda.h
@@ -71,7 +71,7 @@ protected:
 
     virtual void emitPreprocessorDirectivesImpl() SLANG_OVERRIDE;
 
-    virtual void emitModuleImpl(IRModule* module) SLANG_OVERRIDE;
+    virtual void emitModuleImpl(IRModule* module, DiagnosticSink* sink) SLANG_OVERRIDE;
 
     // CPPSourceEmitter overrides 
     virtual SlangResult calcTypeName(IRType* type, CodeGenTarget target, StringBuilder& out) SLANG_OVERRIDE;
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 2118268cd..ef1442a1b 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -806,7 +806,7 @@ SlangResult emitEntryPointsSourceFromIR(
 #if 0
         dumpIR(compileRequest, irModule, "PRE-EMIT");
 #endif
-        sourceEmitter->emitModule(irModule);
+        sourceEmitter->emitModule(irModule, sink);
     }
 
     String code = sourceWriter.getContent();