Add options to speedup compilation.

Author: csyonghe

build/visual-studio/slang/slang.vcxproj

@@ -444,7 +444,6 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-optional-type.h" />
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-reinterpret.h" />
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-result-type.h" />
-    <ClInclude Include="..\..\..\source\slang\slang-ir-lower-size-of.h" />
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-tuple-types.h" />
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-witness-lookup.h" />
     <ClInclude Include="..\..\..\source\slang\slang-ir-marshal-native-call.h" />
@@ -685,7 +684,6 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-optional-type.cpp" />
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-reinterpret.cpp" />
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-result-type.cpp" />
-    <ClCompile Include="..\..\..\source\slang\slang-ir-lower-size-of.cpp" />
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-tuple-types.cpp" />
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-witness-lookup.cpp" />
     <ClCompile Include="..\..\..\source\slang\slang-ir-marshal-native-call.cpp" />

build/visual-studio/slang/slang.vcxproj.filters

@@ -420,9 +420,6 @@
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-result-type.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\source\slang\slang-ir-lower-size-of.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\..\source\slang\slang-ir-lower-tuple-types.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -1139,9 +1136,6 @@
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-result-type.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\..\source\slang\slang-ir-lower-size-of.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\source\slang\slang-ir-lower-tuple-types.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

slang.h

@@ -863,6 +863,7 @@ extern "C"
             SourceEmbedLanguage,
             DisableShortCircuit,   // bool
             MinimumSlangOptimization, // bool
+            DisableNonEssentialValidations, // bool
 
             // Target
 

source/slang/slang-check-modifier.cpp

@@ -1678,7 +1678,7 @@ namespace Slang
             {
                 if (mapExclusiveGroupToModifier.tryGetValue(conflictGroup, existingModifier))
                 {
-                    getSink()->diagnose(modifier->loc, Diagnostics::duplicateModifier, modifier, existingModifier);
+                    //getSink()->diagnose(modifier->loc, Diagnostics::duplicateModifier, modifier, existingModifier);
                 }
                 mapExclusiveGroupToModifier[conflictGroup] = modifier;
             }

source/slang/slang-emit.cpp

@@ -48,7 +48,6 @@
 #include "slang-ir-lower-bit-cast.h"
 #include "slang-ir-lower-combined-texture-sampler.h"
 #include "slang-ir-lower-l-value-cast.h"
-#include "slang-ir-lower-size-of.h"
 #include "slang-ir-lower-reinterpret.h"
 #include "slang-ir-loop-unroll.h"
 #include "slang-ir-legalize-vector-types.h"
@@ -214,6 +213,99 @@ struct LinkingAndOptimizationOptions
     CLikeSourceEmitter* sourceEmitter = nullptr;
 };
 
+struct RequiredLoweringPassSet
+{
+    bool resultType;
+    bool optionalType;
+    bool combinedTextureSamplers;
+    bool reinterpret;
+    bool generics;
+    bool autodiff;
+    bool derivativePyBindWrapper;
+    bool bitcast;
+    bool existentialTypeLayout;
+    bool bindingQuery;
+    bool meshOutput;
+};
+
+void calcRequiredLoweringPassSet(RequiredLoweringPassSet& result, CodeGenContext* codeGenContext, IRInst* inst)
+{
+    switch (inst->getOp())
+    {
+    case kIROp_ResultType:
+        result.resultType = true;
+        break;
+    case kIROp_OptionalType:
+        result.optionalType = true;
+        break;
+    case kIROp_TextureType:
+        if (!isKhronosTarget(codeGenContext->getTargetReq()))
+        {
+            if (auto texType = as<IRTextureType>(inst))
+            {
+                auto isCombined = texType->getIsCombinedInst();
+                if (auto isCombinedVal = as<IRIntLit>(isCombined))
+                {
+                    if (isCombinedVal->getValue() != 0)
+                    {
+                        result.combinedTextureSamplers = true;
+                    }
+                }
+                else
+                {
+                    result.combinedTextureSamplers = true;
+                }
+            }
+        }
+        break;
+    case kIROp_PseudoPtrType:
+        result.existentialTypeLayout = true;
+        break;
+    case kIROp_GetRegisterIndex:
+    case kIROp_GetRegisterSpace:
+        result.bindingQuery = true;
+        break;
+    case kIROp_BackwardDifferentiate:
+    case kIROp_ForwardDifferentiate:
+        result.autodiff = true;
+        break;
+    case kIROp_VerticesType:
+    case kIROp_IndicesType:
+    case kIROp_PrimitivesType:
+        result.meshOutput = true;
+        break;
+    case kIROp_CreateExistentialObject:
+    case kIROp_MakeExistential:
+    case kIROp_ExtractExistentialType:
+    case kIROp_ExtractExistentialValue:
+    case kIROp_ExtractExistentialWitnessTable:
+    case kIROp_WrapExistential:
+    case kIROp_LookupWitness:
+        result.generics = true;
+        break;
+    case kIROp_Specialize:
+        {
+            auto specInst = as<IRSpecialize>(inst);
+            if (!findAnyTargetIntrinsicDecoration(getResolvedInstForDecorations(specInst)))
+                result.generics = true;
+        }
+        break;
+    case kIROp_Reinterpret:
+        result.reinterpret = true;
+        break;
+    case kIROp_BitCast:
+        result.bitcast = true;
+        break;
+    case kIROp_AutoPyBindCudaDecoration:
+        result.derivativePyBindWrapper = true;
+        break;
+    }
+    for (auto child : inst->getDecorationsAndChildren())
+    {
+        calcRequiredLoweringPassSet(result, codeGenContext, child);
+    }
+}
+
 Result linkAndOptimizeIR(
     CodeGenContext*                         codeGenContext,
     LinkingAndOptimizationOptions const&    options,
@@ -354,7 +446,11 @@ Result linkAndOptimizeIR(
         break;
     }
 
-    lowerOptionalType(irModule, sink);
+    RequiredLoweringPassSet requiredLoweringPassSet = {};
+    calcRequiredLoweringPassSet(requiredLoweringPassSet, codeGenContext, irModule->getModuleInst());
+
+    if (requiredLoweringPassSet.optionalType)
+        lowerOptionalType(irModule, sink);
 
     switch (target)
     {
@@ -370,7 +466,8 @@ Result linkAndOptimizeIR(
     }
 
     // Lower `Result<T,E>` types into ordinary struct types.
-    lowerResultType(irModule, sink);
+    if (requiredLoweringPassSet.resultType)
+        lowerResultType(irModule, sink);
 
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "UNIONS DESUGARED");
@@ -403,7 +500,8 @@ Result linkAndOptimizeIR(
         fuseCallsToSaturatedCooperation(irModule);
 
     // Generate any requested derivative wrappers
-    generateDerivativeWrappers(irModule, sink);
+    if (requiredLoweringPassSet.derivativePyBindWrapper)
+        generateDerivativeWrappers(irModule, sink);
 
     // Next, we need to ensure that the code we emit for
     // the target doesn't contain any operations that would
@@ -448,8 +546,11 @@ Result linkAndOptimizeIR(
         // Unroll loops.
         if (codeGenContext->getSink()->getErrorCount() == 0)
         {
-            if (!unrollLoopsInModule(targetProgram, irModule, codeGenContext->getSink()))
-                return SLANG_FAIL;
+            if (!fastIRSimplificationOptions.minimalOptimization)
+            {
+                if (!unrollLoopsInModule(targetProgram, irModule, codeGenContext->getSink()))
+                    return SLANG_FAIL;
+            }
         }
 
         // Few of our targets support higher order functions, and
@@ -462,15 +563,19 @@ Result linkAndOptimizeIR(
 
         dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-AUTODIFF");
         enableIRValidationAtInsert();
-        changed |= processAutodiffCalls(targetProgram, irModule, sink);
+        if (requiredLoweringPassSet.autodiff)
+        {
+            changed |= processAutodiffCalls(targetProgram, irModule, sink);
+        }
         disableIRValidationAtInsert();
         dumpIRIfEnabled(codeGenContext, irModule, "AFTER-AUTODIFF");
 
         if (!changed)
             break;
     }
 
-    finalizeAutoDiffPass(targetProgram, irModule);
+    if (requiredLoweringPassSet.autodiff)
+        finalizeAutoDiffPass(targetProgram, irModule);
 
     finalizeSpecialization(irModule);
 
@@ -507,7 +612,9 @@ Result linkAndOptimizeIR(
         SLANG_RETURN_ON_FAIL(performTypeInlining(irModule, sink));
     }
 
-    lowerReinterpret(targetProgram, irModule, sink);
+    if (requiredLoweringPassSet.reinterpret)
+        lowerReinterpret(targetProgram, irModule, sink);
+
     if (sink->getErrorCount() != 0)
         return SLANG_FAIL;
 
@@ -517,20 +624,33 @@ Result linkAndOptimizeIR(
     // but are not used for dynamic dispatch, unpin them so we don't
     // do unnecessary work to lower them.
     unpinWitnessTables(irModule);
-
-    simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
+    
+    if (fastIRSimplificationOptions.minimalOptimization)
+    {
+        eliminateDeadCode(irModule);
+    }
+    else
+    {
+        simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
+    }
 
     if (!ArtifactDescUtil::isCpuLikeTarget(artifactDesc))
     {
         // We could fail because (perhaps, somehow) end up with getStringHash that the operand is not a string literal
         SLANG_RETURN_ON_FAIL(checkGetStringHashInsts(irModule, sink));
     }
 
+    requiredLoweringPassSet = {};
+    calcRequiredLoweringPassSet(requiredLoweringPassSet, codeGenContext, irModule->getModuleInst());
+
     // For targets that supports dynamic dispatch, we need to lower the
     // generics / interface types to ordinary functions and types using
     // function pointers.
     dumpIRIfEnabled(codeGenContext, irModule, "BEFORE-LOWER-GENERICS");
-    lowerGenerics(targetProgram, irModule, sink);
+    if (requiredLoweringPassSet.generics)
+        lowerGenerics(targetProgram, irModule, sink);
+    else
+        cleanupGenerics(targetProgram, irModule, sink);
     dumpIRIfEnabled(codeGenContext, irModule, "AFTER-LOWER-GENERICS");
 
     if (sink->getErrorCount() != 0)
@@ -547,7 +667,10 @@ Result linkAndOptimizeIR(
     // up downstream passes like type legalization, so we
     // will run a DCE pass to clean up after the specialization.
     //
-    simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);
+    if (!fastIRSimplificationOptions.minimalOptimization)
+    {
+        simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);
+    }
 
     validateIRModuleIfEnabled(codeGenContext, irModule);
 
@@ -569,11 +692,15 @@ Result linkAndOptimizeIR(
     case CodeGenTarget::Metal:
     case CodeGenTarget::MetalLib:
     case CodeGenTarget::MetalLibAssembly:
-        lowerCombinedTextureSamplers(irModule, sink);
+        if (requiredLoweringPassSet.combinedTextureSamplers)
+            lowerCombinedTextureSamplers(irModule, sink);
         break;
     }
 
-    addUserTypeHintDecorations(irModule);
+    if (codeGenContext->getTargetProgram()->getOptionSet().getBoolOption(CompilerOptionName::VulkanEmitReflection))
+    {
+        addUserTypeHintDecorations(irModule);
+    }
 
     // We don't need the legalize pass for C/C++ based types
     if(options.shouldLegalizeExistentialAndResourceTypes )
@@ -603,10 +730,13 @@ Result linkAndOptimizeIR(
         //  we need to replace it with just an `X`, after which we
         //  will have (more) legal shader code.
         //
-        legalizeExistentialTypeLayout(
-            targetProgram,
-            irModule,
-            sink);
+        if (requiredLoweringPassSet.existentialTypeLayout)
+        {
+            legalizeExistentialTypeLayout(
+                targetProgram,
+                irModule,
+                sink);
+        }
 
 #if 0
         dumpIRIfEnabled(codeGenContext, irModule, "EXISTENTIALS LEGALIZED");
@@ -652,7 +782,8 @@ Result linkAndOptimizeIR(
     // to see if we can clean up any temporaries created by legalization.
     // (e.g., things that used to be aggregated might now be split up,
     // so that we can work with the individual fields).
-    simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
+    if (!fastIRSimplificationOptions.minimalOptimization)
+        simplifyIR(targetProgram, irModule, fastIRSimplificationOptions, sink);
 
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "AFTER SSA");
@@ -678,7 +809,6 @@ Result linkAndOptimizeIR(
     {
         specializeArrayParameters(codeGenContext, irModule);
     }
-    eliminateDeadCode(irModule);
 
 #if 0
     dumpIRIfEnabled(codeGenContext, irModule, "AFTER RESOURCE SPECIALIZATION");
@@ -965,14 +1095,16 @@ Result linkAndOptimizeIR(
 
     // Lower the `getRegisterIndex` and `getRegisterSpace` intrinsics.
     //
-    lowerBindingQueries(irModule, sink);
+    if (requiredLoweringPassSet.bindingQuery)
+        lowerBindingQueries(irModule, sink);
 
     // For some small improvement in type safety we represent these as opaque
     // structs instead of regular arrays.
     //
     // If any have survived this far, change them back to regular (decorated)
     // arrays that the emitters can deal with.
-    legalizeMeshOutputTypes(irModule);
+    if (requiredLoweringPassSet.meshOutput)
+        legalizeMeshOutputTypes(irModule);
 
     if (options.shouldLegalizeExistentialAndResourceTypes)
     {
@@ -997,13 +1129,10 @@ Result linkAndOptimizeIR(
             rcpWOfPositionInput(irModule);
     }
 
-    // Lower sizeof/alignof
-
-    lowerSizeOfLike(targetProgram, irModule, sink);
-
     // Lower all bit_cast operations on complex types into leaf-level
     // bit_cast on basic types.
-    lowerBitCast(targetProgram, irModule, sink);
+    if (requiredLoweringPassSet.bitcast)
+        lowerBitCast(targetProgram, irModule, sink);
 
     bool emitSpirvDirectly = targetProgram->shouldEmitSPIRVDirectly();
 
@@ -1076,7 +1205,7 @@ Result linkAndOptimizeIR(
     // For now we are avoiding that problem by simply *not* emitting live-range
     // information when we fix variable scoping later on.
 
-    // Depending on the target, certain things that were represented as
+    // Depending on the target, certain things that were represented ass
     // single IR instructions will need to be emitted with the help of
     // function declaratons in output high-level code.
     //

source/slang/slang-ir-dce.cpp

@@ -307,7 +307,7 @@ bool shouldInstBeLiveIfParentIsLive(IRInst* inst, IRDeadCodeEliminationOptions o
     // First, if `inst` is an instruction that might have some effects
     // when it is executed, then we should keep it around.
     //
-    if (inst->mightHaveSideEffects(SideEffectAnalysisOptions::UseDominanceTree))
+    if (inst->mightHaveSideEffects(SideEffectAnalysisOptions::None))
     {
         return true;
     }