Map SV_InstanceID to gl_InstanceIndex-gl_BaseInstance

Author: csyonghe

source/slang/glsl.meta.slang

@@ -136,7 +136,27 @@ public property uint3 gl_WorkGroupSize
 // TODO: define overload for tessellation control stage.
 public in int gl_InvocationID : SV_GSInstanceID;
 
-public in int gl_InstanceIndex : SV_InstanceID;
+internal in int __sv_InstanceIndex : SV_InstanceID;
+
+// SPIRV InstanceIndex builtin for vertex shader
+public property int gl_InstanceIndex
+{
+    [require(vertex)]
+    get
+    {
+        __target_switch
+        {
+        default:
+            return __sv_InstanceIndex;
+        case glsl:
+            __intrinsic_asm "gl_InstanceIndex";
+        case spirv:
+            return spirv_asm {
+                result:$$int = OpLoad builtin(InstanceIndex:int);
+            };
+        }
+    }
+}
 public in bool gl_FrontFacing : SV_IsFrontFace;
 
 // TODO: define overload for geometry stage.

source/slang/slang-compiler.cpp

@@ -16,6 +16,8 @@
 #include "slang-check-impl.h"
 #include "slang-check.h"
 
+#include <chrono>
+
 // Artifact
 #include "../compiler-core/slang-artifact-associated.h"
 #include "../compiler-core/slang-artifact-container-util.h"
@@ -1835,6 +1837,26 @@ SlangResult CodeGenContext::_emitEntryPoints(ComPtr<IArtifact>& outArtifact)
     return SLANG_FAIL;
 }
 
+// Helper class for recording compile time.
+struct CompileTimerRAII
+{
+    std::chrono::high_resolution_clock::time_point startTime;
+    Session* session;
+    CompileTimerRAII(Session* inSession)
+    {
+        startTime = std::chrono::high_resolution_clock::now();
+        session = inSession;
+    }
+    ~CompileTimerRAII()
+    {
+        double elapsedTime = std::chrono::duration_cast<std::chrono::microseconds>(
+                                 std::chrono::high_resolution_clock::now() - startTime)
+                                 .count() /
+                             1e6;
+        session->addTotalCompileTime(elapsedTime);
+    }
+};
+
 // Do emit logic for a zero or more entry points
 SlangResult CodeGenContext::emitEntryPoints(ComPtr<IArtifact>& outArtifact)
 {

source/slang/slang-compiler.h

@@ -3755,26 +3755,6 @@ SLANG_FORCE_INLINE SlangSourceLanguage asExternal(SourceLanguage sourceLanguage)
     return (SlangSourceLanguage)sourceLanguage;
 }
 
-// Helper class for recording compile time.
-struct CompileTimerRAII
-{
-    std::chrono::high_resolution_clock::time_point startTime;
-    Session* session;
-    CompileTimerRAII(Session* inSession)
-    {
-        startTime = std::chrono::high_resolution_clock::now();
-        session = inSession;
-    }
-    ~CompileTimerRAII()
-    {
-        double elapsedTime = std::chrono::duration_cast<std::chrono::microseconds>(
-                                 std::chrono::high_resolution_clock::now() - startTime)
-                                 .count() /
-                             1e6;
-        session->addTotalCompileTime(elapsedTime);
-    }
-};
-
 // helpers for error/warning reporting
 enum class DiagnosticCategory
 {

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

@@ -345,6 +345,20 @@ IRNumThreadsDecoration* CLikeSourceEmitter::getComputeThreadGroupSize(
     return decor;
 }
 
+String CLikeSourceEmitter::getTargetBuiltinVarName(IRInst* inst, IRTargetBuiltinVarName builtinName)
+{
+    switch (builtinName)
+    {
+    case IRTargetBuiltinVarName::SpvInstanceIndex:
+        return "gl_InstanceIndex";
+    case IRTargetBuiltinVarName::SpvBaseInstance:
+        return "gl_BaseInstance";
+    }
+    if (auto linkage = inst->findDecoration<IRLinkageDecoration>())
+        return linkage->getMangledName();
+    return generateName(inst);
+}
+
 List<IRWitnessTableEntry*> CLikeSourceEmitter::getSortedWitnessTableEntries(
     IRWitnessTable* witnessTable)
 {
@@ -1208,6 +1222,11 @@ String CLikeSourceEmitter::generateName(IRInst* inst)
         return externCppDecoration->getName();
     }
 
+    if (auto builtinTargetVarDecoration = inst->findDecoration<IRTargetBuiltinVarDecoration>())
+    {
+        return getTargetBuiltinVarName(inst, builtinTargetVarDecoration->getBuiltinVarName());
+    }
+
     // If we have a name hint on the instruction, then we will try to use that
     // to provide the basis for the actual name in the output code.
     if (auto nameHintDecoration = inst->findDecoration<IRNameHintDecoration>())

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

@@ -243,7 +243,6 @@ class CLikeSourceEmitter : public SourceEmitterBase
     Linkage* getLinkage() { return m_codeGenContext->getLinkage(); }
     ComponentType* getProgram() { return m_codeGenContext->getProgram(); }
     TargetProgram* getTargetProgram() { return m_codeGenContext->getTargetProgram(); }
-
     //
     // Types
     //
@@ -519,6 +518,7 @@ class CLikeSourceEmitter : public SourceEmitterBase
 protected:
     virtual void emitGlobalParamDefaultVal(IRGlobalParam* inst) { SLANG_UNUSED(inst); }
     virtual void emitPostDeclarationAttributesForType(IRInst* type) { SLANG_UNUSED(type); }
+    virtual String getTargetBuiltinVarName(IRInst* inst, IRTargetBuiltinVarName builtinName);
     virtual bool doesTargetSupportPtrTypes() { return false; }
     virtual bool isResourceTypeBindless(IRType* type)
     {

source/slang/slang-emit-glsl.cpp

@@ -1791,6 +1791,12 @@ bool GLSLSourceEmitter::tryEmitGlobalParamImpl(IRGlobalParam* varDecl, IRType* v
         }
     }
 
+    if (varDecl->findDecoration<IRTargetBuiltinVarDecoration>())
+    {
+        // By default, we don't need to emit a definition for target builtin variables.
+        return true;
+    }
+
     // Do the default thing
     return false;
 }

source/slang/slang-emit-spirv.cpp

@@ -5215,6 +5215,16 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
     {
         IRBuilder builder(m_irModule);
         builder.setInsertBefore(inst);
+        if (auto builtinVarDecor = inst->findDecoration<IRTargetBuiltinVarDecoration>())
+        {
+            switch (builtinVarDecor->getBuiltinVarName())
+            {
+            case IRTargetBuiltinVarName::SpvInstanceIndex:
+                return getBuiltinGlobalVar(inst->getFullType(), SpvBuiltInInstanceIndex, inst);
+            case IRTargetBuiltinVarName::SpvBaseInstance:
+                return getBuiltinGlobalVar(inst->getFullType(), SpvBuiltInBaseInstance, inst);
+            }
+        }
         if (auto layout = getVarLayout(inst))
         {
             if (auto systemValueAttr = layout->findAttr<IRSystemValueSemanticAttr>())

source/slang/slang-ir-glsl-legalize.cpp

@@ -236,6 +236,9 @@ struct GLSLSystemValueInfo
 
     // The kind of the system value that requires special treatment.
     GLSLSystemValueKind kind = GLSLSystemValueKind::General;
+
+    // The target builtin name.
+    IRTargetBuiltinVarName targetVarName = IRTargetBuiltinVarName::Unknown;
 };
 
 static void leafAddressesImpl(List<IRInst*>& ret, const ScalarizedVal& v)
@@ -283,6 +286,7 @@ struct GLSLLegalizationContext
     DiagnosticSink* sink;
     Stage stage;
     IRFunc* entryPointFunc;
+    Dictionary<IRTargetBuiltinVarName, IRInst*> builtinVarMap;
 
     /// This dictionary stores all bindings of 'VaryingIn/VaryingOut'. We assume 'space' is 0.
     Dictionary<LayoutResourceKind, UIntSet> usedBindingIndex;
@@ -414,7 +418,7 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo(
     char const* outerArrayName = nullptr;
     int arrayIndex = -1;
     GLSLSystemValueKind systemValueKind = GLSLSystemValueKind::General;
-
+    IRTargetBuiltinVarName targetVarName = IRTargetBuiltinVarName::Unknown;
     auto semanticInst = varLayout->findSystemValueSemanticAttr();
     if (!semanticInst)
         return nullptr;
@@ -621,6 +625,7 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo(
 
         requiredType = builder->getBasicType(BaseType::Int);
         name = "gl_InstanceIndex";
+        targetVarName = IRTargetBuiltinVarName::HlslInstanceID;
     }
     else if (semanticName == "sv_isfrontface")
     {
@@ -869,6 +874,7 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo(
         name = "gl_BaseInstance";
     }
 
+    inStorage->targetVarName = targetVarName;
     if (name)
     {
         inStorage->name = name;
@@ -976,6 +982,12 @@ void createVarLayoutForLegalizedGlobalParam(
         default:
             break;
         }
+
+        if (systemValueInfo->targetVarName != IRTargetBuiltinVarName::Unknown)
+        {
+            builder->addTargetBuiltinVarDecoration(globalParam, systemValueInfo->targetVarName);
+            context->builtinVarMap[systemValueInfo->targetVarName] = globalParam;
+        }
     }
 }
 
@@ -1262,7 +1274,7 @@ ScalarizedVal createSimpleGLSLGlobalVarying(
         // Validate the system value, convert to a regular parameter if this is not a valid system
         // value for a given target.
         if (systemSemantic && isSPIRV(codeGenContext->getTargetFormat()) &&
-            systemSemantic->getName().caseInsensitiveEquals(UnownedStringSlice("sv_instanceid")) &&
+            systemValueInfo->targetVarName == IRTargetBuiltinVarName::HlslInstanceID &&
             ((stage == Stage::Fragment) ||
              (stage == Stage::Vertex &&
               inVarLayout->usesResourceKind(LayoutResourceKind::VaryingOutput))))
@@ -1287,6 +1299,7 @@ ScalarizedVal createSimpleGLSLGlobalVarying(
             newVarLayout->sourceLoc = inVarLayout->sourceLoc;
 
             inVarLayout->replaceUsesWith(newVarLayout);
+            systemValueInfo->targetVarName = IRTargetBuiltinVarName::Unknown;
         }
     }
 
@@ -3746,6 +3759,60 @@ ScalarizedVal legalizeEntryPointReturnValueForGLSL(
     return result;
 }
 
+void legalizeTargetBuiltinVar(GLSLLegalizationContext& context)
+{
+    List<KeyValuePair<IRTargetBuiltinVarName, IRInst*>> workItems;
+    for (auto [builtinVarName, varInst] : context.builtinVarMap)
+    {
+        if (builtinVarName == IRTargetBuiltinVarName::HlslInstanceID)
+        {
+            workItems.add(KeyValuePair(builtinVarName, varInst));
+        }
+    }
+
+    auto getOrCreateBuiltinVar = [&](IRTargetBuiltinVarName name, IRType* type)
+    {
+        if (auto var = context.builtinVarMap.tryGetValue(name))
+            return *var;
+        IRBuilder builder(context.entryPointFunc);
+        builder.setInsertBefore(context.entryPointFunc);
+        IRInst* var = builder.createGlobalParam(type);
+        builder.addTargetBuiltinVarDecoration(var, name);
+        return var;
+    };
+    for (auto& kv : workItems)
+    {
+        auto builtinVarName = kv.key;
+        auto varInst = kv.value;
+
+        // Repalce SV_InstanceID with gl_InstanceIndex - gl_BaseInstance.
+        if (builtinVarName == IRTargetBuiltinVarName::HlslInstanceID)
+        {
+            auto instanceIndex = getOrCreateBuiltinVar(
+                IRTargetBuiltinVarName::SpvInstanceIndex,
+                varInst->getDataType());
+            auto baseInstance = getOrCreateBuiltinVar(
+                IRTargetBuiltinVarName::SpvBaseInstance,
+                varInst->getDataType());
+            traverseUses(
+                varInst,
+                [&](IRUse* use)
+                {
+                    auto user = use->getUser();
+                    if (user->getOp() == kIROp_Load)
+                    {
+                        IRBuilder builder(use->getUser());
+                        builder.setInsertBefore(use->getUser());
+                        auto sub = builder.emitSub(
+                            tryGetPointedToType(&builder, varInst->getDataType()),
+                            builder.emitLoad(instanceIndex),
+                            builder.emitLoad(baseInstance));
+                        user->replaceUsesWith(sub);
+                    }
+                });
+        }
+    }
+}
 
 void legalizeEntryPointForGLSL(
     Session* session,
@@ -3937,6 +4004,11 @@ void legalizeEntryPointForGLSL(
             value.globalParam->setFullType(sizedArrayType);
         }
     }
+
+    // Some system value vars can't be mapped 1:1 to a GLSL/Vulkan builtin,
+    // for example, SV_InstanceID should map to gl_InstanceIndex - gl_BaseInstance,
+    // we will replace these builtins with additional compute logic here.
+    legalizeTargetBuiltinVar(context);
 }
 
 void decorateModuleWithSPIRVVersion(IRModule* module, SemanticVersion spirvVersion)

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

@@ -926,6 +926,9 @@ INST_RANGE(BindingQuery, GetRegisterIndex, GetRegisterSpace)
         INST(ExportDecoration, export, 1, 0)
     INST_RANGE(LinkageDecoration, ImportDecoration, ExportDecoration)
 
+        /// Mark a global variable as a target builtin variable.
+    INST(TargetBuiltinVarDecoration, TargetBuiltinVar, 1, 0)
+
         /// Marks an inst as coming from an `extern` symbol defined in the user code.
     INST(UserExternDecoration, UserExtern, 0, 0)
 

source/slang/slang-ir-insts.h

@@ -193,6 +193,14 @@ enum class IRInterpolationMode
     PerVertex,
 };
 
+enum class IRTargetBuiltinVarName
+{
+    Unknown,
+    HlslInstanceID,
+    SpvInstanceIndex,
+    SpvBaseInstance,
+};
+
 struct IRInterpolationModeDecoration : IRDecoration
 {
     enum
@@ -705,6 +713,18 @@ struct IRLinkageDecoration : IRDecoration
     UnownedStringSlice getMangledName() { return getMangledNameOperand()->getStringSlice(); }
 };
 
+// Mark a global variable as a target buitlin variable.
+struct IRTargetBuiltinVarDecoration : IRDecoration
+{
+    IR_LEAF_ISA(TargetBuiltinVarDecoration)
+
+    IRIntLit* getBuiltinVarOperand() { return cast<IRIntLit>(getOperand(0)); }
+    IRTargetBuiltinVarName getBuiltinVarName()
+    {
+        return IRTargetBuiltinVarName(getBuiltinVarOperand()->getValue());
+    }
+};
+
 struct IRUserExternDecoration : IRDecoration
 {
     enum
@@ -4658,6 +4678,18 @@ struct IRBuilder
     //    void addLayoutDecoration(IRInst* value, Layout* layout);
     IRLayoutDecoration* addLayoutDecoration(IRInst* value, IRLayout* layout);
 
+    IRDecoration* addTargetBuiltinVarDecoration(
+        IRInst* value,
+        IRTargetBuiltinVarName builtinVarName)
+    {
+        IRInst* operands[] = {getIntValue((IRIntegerValue)builtinVarName)};
+        return addDecoration(
+            value,
+            kIROp_TargetBuiltinVarDecoration,
+            operands,
+            SLANG_COUNT_OF(operands));
+    }
+
     //    IRLayout* getLayout(Layout* astLayout);
 
     IRTypeSizeAttr* getTypeSizeAttr(LayoutResourceKind kind, LayoutSize size);