Append proper suffixes to 16-bit literals for GLSL (#1767)

* Append proper suffixes to 16-bit literals for GLSL

The GLSL output path wasn't putting suffixes on literals of 16-bit types, and that was leading to compilation errors in downstream `glslang`. This change adds the suffixes defined by `GL_EXT_shader_explicit_arithmetic_types`.

This change also wraps up 8-bit literals so that they are emitted as, e.g., `int8_t(1)` instead of just `1`, to make sure we don't have implicit conversions in the output GLSL that weren't implicit in the Slang IR. We similarly wrap floating-point special values like infinities in their desired types when the type is `float` (e.g., `double(1.0 / 0.0)` for a double-precision infinity).

Note: Standad IEEE 754 half-precision doesn't provide an encoding for infinite or not-a-number values, so it might be considered an error if we emit `half(1.0 / 0.0)` but there really isn't a significantly better alternative for us to emit.

* fixup

1 files changed, 56 insertions, 4 deletions

diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp
index a1142749b..5b29fb8fa 100644
--- a/source/slang/slang-emit-glsl.cpp
+++ b/source/slang/slang-emit-glsl.cpp
@@ -737,6 +737,17 @@ void GLSLSourceEmitter::emitLoopControlDecorationImpl(IRLoopControlDecoration* d
     }
 }
 
+void GLSLSourceEmitter::_emitSpecialFloatImpl(IRType* type, const char* valueExpr)
+{
+    if( type->getOp() != kIROp_FloatType )
+    {
+        emitType(type);
+    }
+    m_writer->emit("(");
+    m_writer->emit(valueExpr);
+    m_writer->emit(")");
+}
+
 void GLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst) 
 {
     switch (inst->getOp())
@@ -753,14 +764,38 @@ void GLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst)
                     default: 
                     
                     case BaseType::Int8:
+                    {
+                        emitType(type);
+                        m_writer->emit("(");
+                        m_writer->emit(litInst->value.intVal);
+                        m_writer->emit(")");
+                        return;
+                    }
                     case BaseType::Int16:
+                    {
+                        m_writer->emit(litInst->value.intVal);
+                        m_writer->emit("S");
+                        return;
+                    }
                     case BaseType::Int:
                     {
                         m_writer->emit(litInst->value.intVal);
                         return;
                     }
                     case BaseType::UInt8:
+                    {
+                        emitType(type);
+                        m_writer->emit("(");
+                        m_writer->emit(UInt(litInst->value.intVal));
+                        m_writer->emit("U)");
+                        return;
+                    }
                     case BaseType::UInt16:
+                    {
+                        m_writer->emit(UInt(litInst->value.intVal));
+                        m_writer->emit("US");
+                        return;
+                    }
                     case BaseType::UInt:
                     {
                         m_writer->emit(UInt(litInst->value.intVal));
@@ -789,26 +824,43 @@ void GLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst)
         {
             IRConstant* constantInst = static_cast<IRConstant*>(inst);
 
+            auto type = constantInst->getDataType();
             IRConstant::FloatKind kind = constantInst->getFloatKind();
 
             switch (kind)
             {
                 case IRConstant::FloatKind::Nan:
                 {
-                    m_writer->emit("(0.0 / 0.0)");
+                    _emitSpecialFloatImpl(type, "0.0 / 0.0");
                     return;
                 }
                 case IRConstant::FloatKind::PositiveInfinity:
                 {
-                    m_writer->emit("(1.0 / 0.0)");
+                    _emitSpecialFloatImpl(type, "1.0 / 0.0");
                     return;
                 }
                 case IRConstant::FloatKind::NegativeInfinity:
                 {
-                    m_writer->emit("(-1.0 / 0.0)");
+                    _emitSpecialFloatImpl(type, "-1.0 / 0.0");
+                    return;
+                }
+                default:
+                {
+                    m_writer->emit(((IRConstant*) inst)->value.floatVal);
+                    switch( type->getOp() )
+                    {
+                    case kIROp_HalfType:
+                        m_writer->emit("HF");
+                        break;
+                    case kIROp_DoubleType:
+                        m_writer->emit("LF");
+                        break;
+                    default:
+                        break;
+                    }
+
                     return;
                 }
-                default: break;
             }
             break;
         }