Dynamic code gen for generic local variables. (shader-slang#1434)

* Dynamic code gen for generic local variables.

* Fixes to function calls with generic typed `in` argument.

* Fixes per code review comments

Author: csyonghe

prelude/slang-cpp-prelude.h

@@ -17,6 +17,7 @@
 
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 
 #if defined(_MSC_VER)
 #   define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)

prelude/slang-cpp-types.h

@@ -15,6 +15,11 @@
 namespace SLANG_PRELUDE_NAMESPACE {
 #endif
 
+struct TypeInfo
+{
+    size_t typeSize;
+};
+
 template <typename T, size_t SIZE>
 struct FixedArray
 {

prelude/slang-cuda-prelude.h

@@ -54,6 +54,11 @@
 #   define SLANG_CUDA_BOUNDARY_MODE cudaBoundaryModeZero
 #endif
 
+struct TypeInfo
+{
+    size_t typeSize;
+};
+
 template <typename T, size_t SIZE>
 struct FixedArray
 {

source/slang/slang-emit-c-like.cpp

@@ -309,6 +309,14 @@ void CLikeSourceEmitter::emitInterface(IRInterfaceType* interfaceType)
     // This behavior is overloaded by concrete emitters.
 }
 
+void CLikeSourceEmitter::emitRTTIObject(IRRTTIObject* rttiObject)
+{
+    SLANG_UNUSED(rttiObject);
+    // Ignore rtti object by default.
+    // This is only used in targets that support dynamic dispatching.
+}
+
+
 void CLikeSourceEmitter::emitTypeImpl(IRType* type, const StringSliceLoc* nameAndLoc)
 {
     if (nameAndLoc)
@@ -908,6 +916,7 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst)
     case kIROp_GlobalParam:
     case kIROp_Param:
     case kIROp_Func:
+    case kIROp_Alloca:
         return false;
 
     // Always fold these in, because they are trivial
@@ -2010,6 +2019,8 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
         /* Don't need to to output anything for this instruction - it's used for reflecting string literals that
         are hashed with 'getStringHash' */
         break;
+    case kIROp_RTTIPointerType:
+        break;
 
     case kIROp_undefined:
         m_writer->emit(getName(inst));
@@ -3674,6 +3685,10 @@ void CLikeSourceEmitter::emitGlobalInst(IRInst* inst)
         emitWitnessTable(cast<IRWitnessTable>(inst));
         break;
 
+    case kIROp_RTTIObject:
+        emitRTTIObject(cast<IRRTTIObject>(inst));
+        break;
+
     default:
         // We have an "ordinary" instruction at the global
         // scope, and we should therefore emit it using the

source/slang/slang-emit-c-like.h

@@ -334,6 +334,7 @@ class CLikeSourceEmitter: public RefObject
 
     virtual void emitWitnessTable(IRWitnessTable* witnessTable);
     virtual void emitInterface(IRInterfaceType* interfaceType);
+    virtual void emitRTTIObject(IRRTTIObject* rttiObject);
 
     virtual void handleCallExprDecorationsImpl(IRInst* funcValue) { SLANG_UNUSED(funcValue); }
 

source/slang/slang-emit-cpp.cpp

@@ -394,6 +394,8 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
 {
     switch (type->op)
     {
+        case kIROp_OutType:
+        case kIROp_InOutType:
         case kIROp_PtrType:
         {
             auto ptrType = static_cast<IRPtrType*>(type);
@@ -496,6 +498,7 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
             return SLANG_OK;
         }
         case kIROp_RawPointerType:
+        case kIROp_RTTIPointerType:
         {
             out << "void*";
             return SLANG_OK;
@@ -510,6 +513,11 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
             out << "*";
             return SLANG_OK;
         }
+        case kIROp_RTTIType:
+        {
+            out << "TypeInfo";
+            return SLANG_OK;
+        }
         default:
         {
             if (isNominalOp(type->op))
@@ -1692,14 +1700,35 @@ void CPPSourceEmitter::_emitWitnessTableWrappers()
                             else
                                 m_writer->emit(", ");
 
+                            // If the implementation expects a concrete type
+                            // (either in the form of a pointer for `out`/`inout` parameters,
+                            // or in the form a a value for `in` parameters, while
+                            // the interface exposes a raw pointer type (void*),
+                            // we need to cast the raw pointer type to the appropriate
+                            // concerete type. (void*->Concrete* / void*->Concrete&).
                             if (reqParamType->op == kIROp_RawPointerType &&
-                                param->getFullType()->op != kIROp_RawPointerType)
+                                param->getDataType()->op != kIROp_RawPointerType)
                             {
-                                m_writer->emit("*static_cast<");
-                                emitType(param->getFullType());
-                                m_writer->emit("*>(");
-                                m_writer->emit(getName(param));
-                                m_writer->emit(")");
+                                if (as<IRPtrTypeBase>(param->getFullType()))
+                                {
+                                    // The implementation function expects a pointer to the
+                                    // concrete type. This is the case for inout/out parameters.
+                                    m_writer->emit("static_cast<");
+                                    emitType(param->getFullType());
+                                    m_writer->emit(">(");
+                                    m_writer->emit(getName(param));
+                                    m_writer->emit(")");
+                                }
+                                else
+                                {
+                                    // The implementation function expects just a value of the
+                                    // concrete type. We need to insert a dereference in this case.
+                                    m_writer->emit("*static_cast<");
+                                    emitType(param->getFullType());
+                                    m_writer->emit("*>(");
+                                    m_writer->emit(getName(param));
+                                    m_writer->emit(")");
+                                }
                             }
                             else
                             {
@@ -1773,6 +1802,18 @@ void CPPSourceEmitter::emitInterface(IRInterfaceType* interfaceType)
     m_writer->emit(";\n");
 }
 
+void CPPSourceEmitter::emitRTTIObject(IRRTTIObject* rttiObject)
+{
+    m_writer->emit("static TypeInfo ");
+    m_writer->emit(getName(rttiObject));
+    m_writer->emit(" = {");
+    auto typeSizeDecoration = rttiObject->findDecoration<IRRTTITypeSizeDecoration>();
+    SLANG_ASSERT(typeSizeDecoration);
+    m_writer->emit(typeSizeDecoration->getTypeSize());
+    m_writer->emit("};\n");
+}
+
+
     /// Emits witness table type definition given a sorted list of witness tables
     /// acoording to the order defined by `interfaceType`.
     ///
@@ -2273,6 +2314,29 @@ bool CPPSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOut
             m_writer->emit("))");
             return true;
         }
+        case kIROp_RTTIObject:
+        {
+            m_writer->emit(getName(inst));
+            return true;
+        }
+        case kIROp_Alloca:
+        {
+            m_writer->emit("alloca(");
+            emitOperand(inst->getOperand(0), EmitOpInfo::get(EmitOp::Postfix));
+            m_writer->emit("->typeSize)");
+            return true;
+        }
+        case kIROp_Copy:
+        {
+            m_writer->emit("memcpy(");
+            emitOperand(inst->getOperand(0), EmitOpInfo::get(EmitOp::General));
+            m_writer->emit(", ");
+            emitOperand(inst->getOperand(1), EmitOpInfo::get(EmitOp::General));
+            m_writer->emit(", ");
+            emitOperand(inst->getOperand(2), EmitOpInfo::get(EmitOp::Postfix));
+            m_writer->emit("->typeSize)");
+            return true;
+        }
     }
 }
 

source/slang/slang-emit-cpp.h

@@ -67,6 +67,7 @@ class CPPSourceEmitter: public CLikeSourceEmitter
     virtual void emitParamTypeImpl(IRType* type, String const& name) SLANG_OVERRIDE;
     virtual void emitWitnessTable(IRWitnessTable* witnessTable) SLANG_OVERRIDE;
     virtual void emitInterface(IRInterfaceType* interfaceType) SLANG_OVERRIDE;
+    virtual void emitRTTIObject(IRRTTIObject* rttiObject) SLANG_OVERRIDE;
     virtual bool tryEmitGlobalParamImpl(IRGlobalParam* varDecl, IRType* varType) SLANG_OVERRIDE;
     virtual void emitIntrinsicCallExprImpl(IRCall* inst, IRTargetIntrinsicDecoration* targetIntrinsic, EmitOpInfo const& inOuterPrec) SLANG_OVERRIDE;
 

source/slang/slang-ir-inst-defs.h

@@ -26,6 +26,7 @@ INST(Nop, nop, 0, 0)
 
     INST(StringType, String, 0, 0)
     INST(RawPointerType, RawPointerType, 0, 0)
+    INST(RTTIPointerType, RTTIPointerType, 1, 0)
 
     /* ArrayTypeBase */
         INST(ArrayType, Array, 2, 0)
@@ -168,6 +169,7 @@ INST(StructType, struct, 0, PARENT)
 INST(InterfaceType, interface, 0, 0)
 INST(AssociatedType, associated_type, 0, 0)
 INST(ThisType, this_type, 0, 0)
+INST(RTTIType, rtti_type, 0, 0)
 
 // A TypeType-typed IRValue represents a IRType.
 // It is used to represent a type parameter/argument in a generics.
@@ -224,6 +226,8 @@ INST(makeStruct, makeStruct, 0, 0)
 
 INST(Call, call, 1, 0)
 
+INST(RTTIObject, rtti_object, 0, 0)
+INST(Alloca, alloca, 1, 0)
 
 INST(WitnessTableEntry, witness_table_entry, 2, 0)
 INST(InterfaceRequirementEntry, interface_req_entry, 2, 0)
@@ -234,6 +238,7 @@ INST(Var, var, 0, 0)
 
 INST(Load, load, 1, 0)
 INST(Store, store, 2, 0)
+INST(Copy, copy, 3, 0)
 
 INST(FieldExtract, get_field, 2, 0)
 INST(FieldAddress, get_field_addr, 2, 0)
@@ -527,6 +532,10 @@ INST(HighLevelDeclDecoration,               highLevelDecl,          1, 0)
     /* LinkageDecoration */
         INST(ImportDecoration, import, 1, 0)
         INST(ExportDecoration, export, 1, 0)
+
+    /* Decorations for RTTI objects */
+        INST(RTTITypeSizeDecoration, RTTI_typeSize, 1, 0)
+
     INST_RANGE(LinkageDecoration, ImportDecoration, ExportDecoration)
 
     INST(SemanticDecoration, semantic, 2, 0)

source/slang/slang-ir-insts.h

@@ -143,6 +143,19 @@ struct IRNameHintDecoration : IRDecoration
     }
 };
 
+/// A decoration on a RTTIObject providing type size information.
+struct IRRTTITypeSizeDecoration : IRDecoration
+{
+    enum { kOp = kIROp_RTTITypeSizeDecoration };
+    IR_LEAF_ISA(RTTITypeSizeDecoration)
+
+    IRIntLit* getTypeSizeOperand() { return cast<IRIntLit>(getOperand(0)); }
+    IRIntegerValue getTypeSize()
+    {
+        return getTypeSizeOperand()->getValue();
+    }
+};
+
 #define IR_SIMPLE_DECORATION(NAME)      \
     struct IR##NAME : IRDecoration      \
     {                                   \
@@ -420,6 +433,26 @@ struct IRLookupWitnessTable : IRInst
     IRUse interfaceType;
 };
 
+/// Allocates space from local stack.
+///
+struct IRAlloca : IRInst
+{
+    IR_LEAF_ISA(Alloca)
+
+    IRInst* getAllocSize() { return getOperand(0); }
+};
+
+/// Copies `size` bytes from `src` to `dst`.
+///
+struct IRCopy : IRInst
+{
+    IR_LEAF_ISA(Copy)
+
+    IRInst* getDst() { return getOperand(0); }
+    IRInst* getSrc() { return getOperand(1); }
+    IRInst* getSize() { return getOperand(2); }
+};
+
 // Layout decorations
 
     /// A decoration that marks a field key as having been associated
@@ -1122,12 +1155,14 @@ struct IRCall : IRInst
 struct IRLoad : IRInst
 {
     IRUse ptr;
+    IR_LEAF_ISA(Load)
 };
 
 struct IRStore : IRInst
 {
     IRUse ptr;
     IRUse val;
+    IR_LEAF_ISA(Store)
 };
 
 struct IRFieldExtract : IRInst
@@ -1137,6 +1172,8 @@ struct IRFieldExtract : IRInst
 
     IRInst* getBase() { return base.get(); }
     IRInst* getField() { return field.get(); }
+    IR_LEAF_ISA(FieldExtract)
+
 };
 
 struct IRFieldAddress : IRInst
@@ -1146,6 +1183,8 @@ struct IRFieldAddress : IRInst
 
     IRInst* getBase() { return base.get(); }
     IRInst* getField() { return field.get(); }
+    IR_LEAF_ISA(FieldAddress)
+
 };
 
 struct IRGetAddress : IRInst
@@ -1439,6 +1478,16 @@ struct IRWitnessTable : IRInst
     IR_LEAF_ISA(WitnessTable)
 };
 
+/// Represents an RTTI object.
+/// An IRRTTIObject has 1 operand, specifying the type
+/// this RTTI object provides info for.
+/// All type info are encapsualted as `IRRTTI*Decoration`s attached
+/// to the object.
+struct IRRTTIObject : IRInst
+{
+    IR_LEAF_ISA(RTTIObject)
+};
+
 // An instruction that yields an undefined value.
 //
 // Note that we make this an instruction rather than a value,
@@ -1574,6 +1623,8 @@ struct IRBuilder
     IRAssociatedType* getAssociatedType();
     IRThisType* getThisType();
     IRRawPointerType* getRawPointerType();
+    IRRTTIPointerType* getRTTIPointerType(IRInst* rttiPtr);
+    IRRTTIType* getRTTIType();
 
 
     IRBasicBlockType*   getBasicBlockType();
@@ -1681,6 +1732,10 @@ struct IRBuilder
         IRInst* witnessTableVal,
         IRInst* interfaceMethodVal);
 
+    IRInst* emitAlloca(IRInst* type, IRInst* rttiObjPtr);
+
+    IRInst* emitCopy(IRInst* dst, IRInst* src, IRInst* rttiObjPtr);
+
     IRInst* emitCallInst(
         IRType*         type,
         IRInst*         func,
@@ -1712,6 +1767,9 @@ struct IRBuilder
         UInt            argCount,
         IRInst* const* args);
 
+    // Creates an RTTI object. Result is of `IRRTTIType`.
+    IRInst* emitMakeRTTIObject(IRInst* typeInst);
+
     IRInst* emitMakeVector(
         IRType*         type,
         UInt            argCount,
@@ -2243,6 +2301,11 @@ struct IRBuilder
     {
         addDecoration(inst, kIROp_FormatDecoration, format);
     }
+
+    void addRTTITypeSizeDecoration(IRInst* inst, IRIntegerValue value)
+    {
+        addDecoration(inst, kIROp_RTTITypeSizeDecoration, getIntValue(getIntType(), value));
+    }
 };
 
 void addHoistableInst(