Fixes.

Author: csyonghe

source/core/slang-common.h

@@ -88,10 +88,10 @@ namespace Slang
 template<typename F>
 class SlangDeferImpl
 {
-    const F& f;
+    F f;
 public:
-    SlangDeferImpl(const F& f)
-        : f(f)
+    SlangDeferImpl(F&& f)
+        : f(Slang::_Move(f))
     {}
     ~SlangDeferImpl()
     {
@@ -101,7 +101,7 @@ class SlangDeferImpl
 
 #ifndef SLANG_DEFER_LAMBDA
 #define SLANG_DEFER_LAMBDA(x) auto SLANG_CONCAT(slang_defer_, __LINE__) = SlangDeferImpl(x)
-#define SLANG_DEFER(x) auto SLANG_CONCAT(slang_defer_##,__LINE__) = SlangDeferImpl([&](){x;})
+#define SLANG_DEFER(x) auto SLANG_CONCAT(slang_defer_,__LINE__) = SlangDeferImpl([&](){x;})
 #endif
 
 //

source/slang/slang-compiler-options.h

@@ -366,6 +366,11 @@ namespace Slang
             return getBoolOption(CompilerOptionName::MinimumSlangOptimization);
         }
 
+        bool shouldRunNonEssentialValidation()
+        {
+            return !getBoolOption(CompilerOptionName::DisableNonEssentialValidations);
+        }
+
         FloatingPointMode getFloatingPointMode()
         {
             return getEnumOption<FloatingPointMode>(CompilerOptionName::FloatingPointMode);

source/slang/slang-emit.cpp

@@ -636,7 +636,7 @@ Result linkAndOptimizeIR(
         break;
     }
 
-    if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
+    if (targetProgram->getOptionSet().shouldRunNonEssentialValidation())
         checkForRecursiveTypes(irModule, sink);
 
     if (sink->getErrorCount() != 0)

source/slang/slang-ir-lower-generics.cpp

@@ -182,7 +182,8 @@ namespace Slang
 
     void stripWrapExistential(IRModule* module)
     {
-        auto& workList = *module->getContainerPool().getList<IRInst>();
+        InstWorkList workList(module);
+
         workList.add(module->getModuleInst());
         for (Index i = 0; i < workList.getCount(); i++)
         {

source/slang/slang-ir-specialize.cpp

@@ -56,7 +56,7 @@ struct SpecializationContext
     SpecializationContext(IRModule* inModule, TargetProgram* target)
         : workList(*inModule->getContainerPool().getList<IRInst>())
         , workListSet(*inModule->getContainerPool().getHashSet<IRInst>())
-        , cleanInsts(*module->getContainerPool().getHashSet<IRInst>())
+        , cleanInsts(*inModule->getContainerPool().getHashSet<IRInst>())
         , module(inModule)
         , targetProgram(target)
     {
@@ -1250,13 +1250,9 @@ struct SpecializationContext
         if (!isInstFullySpecialized(inst))
             return false;
 
-        List<IRInst*>& localWorkList = *module->getContainerPool().getList<IRInst>();
-        HashSet<IRInst*>& processedInsts = *module->getContainerPool().getHashSet<IRInst>();
-        SLANG_DEFER(module->getContainerPool().free(&localWorkList));
-        SLANG_DEFER(module->getContainerPool().free(&processedInsts));
+        ShortList<IRInst*> localWorkList;
 
         localWorkList.add(inst);
-        processedInsts.add(inst);
 
         while (localWorkList.getCount() != 0)
         {
@@ -1279,10 +1275,7 @@ struct SpecializationContext
             for (UInt i = 0; i < curInst->getOperandCount(); ++i)
             {
                 auto operand = curInst->getOperand(i);
-                if (processedInsts.add(operand))
-                {
-                    localWorkList.add(operand);
-                }
+                localWorkList.add(operand);
             }
         }
         return true;

source/slang/slang-ir-uniformity.cpp

@@ -191,10 +191,8 @@ namespace Slang
 
         void propagateNonUniform(IRFunc* root, List<IRInst*>& workList)
         {
-            List<IRInst*>& nextWorkList = *module->getContainerPool().getList<IRInst>();
-            HashSet<IRInst*>& workListSet = *module->getContainerPool().getHashSet<IRInst>();
-            SLANG_DEFER([&]() { module->getContainerPool().free(&nextWorkList); });
-            SLANG_DEFER([&]() { module->getContainerPool().free(&workListSet); });
+            InstWorkList nextWorkList(module);
+            InstHashSet workListSet(module);
 
             auto addToWorkList = [&](IRInst* inst)
                 {
@@ -407,15 +405,14 @@ namespace Slang
                         addToWorkList(user);
                     }
                 }
-                workList.swapWith(nextWorkList);
+                workList.swapWith(nextWorkList.getList());
                 nextWorkList.clear();
             }
         }
 
         void analyzeModule()
         {
-            List<IRInst*>& workList = *module->getContainerPool().getList<IRInst>();
-            SLANG_DEFER([&]() { module->getContainerPool().free(&workList); });
+            InstWorkList workList(module);
 
             for (auto globalInst : module->getGlobalInsts())
             {
@@ -443,7 +440,7 @@ namespace Slang
                     }
                     currentCallee = func;
                     call = nullptr;
-                    propagateNonUniform(func, workList);
+                    propagateNonUniform(func, workList.getList());
                 }
             }
             workList.clear();
@@ -453,9 +450,7 @@ namespace Slang
 
         void eliminateAsDynamicUniformInst()
         {
-            List<IRInst*>& workList = *module->getContainerPool().getList<IRInst>();
-            SLANG_DEFER([&]() { module->getContainerPool().free(&workList); });
-
+            InstWorkList workList(module);
             workList.add(module->getModuleInst());
             for (Index i = 0; i < workList.getCount(); i++)
             {

source/slang/slang-ir.h

@@ -2419,6 +2419,7 @@ struct InstWorkList
         other.pool = nullptr;
         return *this;
     }
+    List<IRInst*>& getList() { return *workList; }
     IRInst* operator[](Index i) { return (*workList)[i]; }
     Index getCount() { return workList->getCount(); }
     IRInst** begin() { return workList->begin(); }
@@ -2464,7 +2465,7 @@ struct InstHashSet
         other.pool = nullptr;
         return *this;
     }
-
+    HashSet<IRInst*>& getHashSet() { return *set; }
     Index getCount() { return set->getCount(); }
     bool add(IRInst* inst) { return set->add(inst); }
     bool contains(IRInst* inst) { return set->contains(inst); }

source/slang/slang-lower-to-ir.cpp

@@ -10829,14 +10829,20 @@ RefPtr<IRModule> generateIRForTranslationUnit(
         insertDebugValueStore(module);
     }
 
+
     // Next, attempt to promote local variables to SSA
     // temporaries and do basic simplifications.
     //
     constructSSA(module);
-    simplifyCFG(module, CFGSimplificationOptions::getDefault());
     applySparseConditionalConstantPropagation(module, compileRequest->getSink());
-    auto peepholeOptions = PeepholeOptimizationOptions::getPrelinking();
-    peepholeOptimize(nullptr, module, peepholeOptions);
+    
+    bool minimumOptimizations = linkage->m_optionSet.getBoolOption(CompilerOptionName::MinimumSlangOptimization);
+    if (!minimumOptimizations)
+    {
+        simplifyCFG(module, CFGSimplificationOptions::getFast());
+        auto peepholeOptions = PeepholeOptimizationOptions::getPrelinking();
+        peepholeOptimize(nullptr, module, peepholeOptions);
+    }
 
     IRDeadCodeEliminationOptions dceOptions = IRDeadCodeEliminationOptions();
     dceOptions.keepExportsAlive = true;
@@ -10881,20 +10887,18 @@ RefPtr<IRModule> generateIRForTranslationUnit(
     // are eliminated from the callee, and not copied into
     // call sites.
     //
-    HashSet<IRInst*>* modifiedFuncs = module->getContainerPool().getHashSet<IRInst>();
-    SLANG_DEFER(module->getContainerPool().free(modifiedFuncs));
-    bool minimumOptimizations = sharedContextStorage.m_linkage->m_optionSet.getBoolOption(CompilerOptionName::MinimumSlangOptimization);
+    InstHashSet modifiedFuncs(module);
     for (;;)
     {
         bool changed = false;
-        modifiedFuncs->clear();
-        changed = performMandatoryEarlyInlining(module, modifiedFuncs);
+        modifiedFuncs.clear();
+        changed = performMandatoryEarlyInlining(module, &modifiedFuncs.getHashSet());
         if (changed)
         {
             changed = peepholeOptimizeGlobalScope(nullptr, module);
             if (!minimumOptimizations)
             {
-                for (auto func : *modifiedFuncs)
+                for (auto func : modifiedFuncs.getHashSet())
                 {
                     changed |= constructSSA(func);
                     changed |= applySparseConditionalConstantPropagation(func, compileRequest->getSink());
@@ -10908,7 +10912,7 @@ RefPtr<IRModule> generateIRForTranslationUnit(
     }
 
     // Check for using uninitialized out parameters.
-    if (!compileRequest->getLinkage()->m_optionSet.getBoolOption(CompilerOptionName::DisableNonEssentialValidations))
+    if (compileRequest->getLinkage()->m_optionSet.shouldRunNonEssentialValidation())
     {
         // Propagate `constexpr`-ness through the dataflow graph (and the
         // call graph) based on constraints imposed by different instructions.