more cleanup and fixes.

Author: csyonghe

source/core/slang-common.h

@@ -84,6 +84,26 @@ namespace Slang
     }
 }
 
+// SLANG_DEFER
+template<typename F>
+class SlangDeferImpl
+{
+    const F& f;
+public:
+    SlangDeferImpl(const F& f)
+        : f(f)
+    {}
+    ~SlangDeferImpl()
+    {
+        f();
+    }
+};
+
+#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;})
+#endif
+
 //
 // Some macros for avoiding boilerplate
 // TODO: could probably deduce the size with templates, and move the whole

source/slang/slang-ir-inline.cpp

@@ -29,6 +29,8 @@ struct InliningPassBase
         /// The module that we are optimizing/transforming
     IRModule* m_module = nullptr;
 
+    HashSet<IRInst*>* m_modifiedFuncs = nullptr;
+
         /// Initialize an inlining pass to operate on the given `module`
     InliningPassBase(IRModule* module)
         : m_module(module)
@@ -157,6 +159,11 @@ struct InliningPassBase
         // given call site, we hand off the a worker routine
         // that does the meat of the work.
         //
+        if (m_modifiedFuncs)
+        {
+            if (auto parentFunc = getParentFunc(call))
+                m_modifiedFuncs->add(parentFunc);
+        }
         inlineCallSite(callSite);
         return true;
     }
@@ -698,11 +705,12 @@ struct MandatoryEarlyInliningPass : InliningPassBase
 };
 
 
-bool performMandatoryEarlyInlining(IRModule* module)
+bool performMandatoryEarlyInlining(IRModule* module, HashSet<IRInst*>* modifiedFuncs)
 {
     SLANG_PROFILE;
 
     MandatoryEarlyInliningPass pass(module);
+    pass.m_modifiedFuncs = modifiedFuncs;
     return pass.considerAllCallSites();
 }
 

source/slang/slang-ir-inline.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "../../slang-com-helper.h"
+#include "core/slang-basic.h"
 
 namespace Slang
 {
@@ -10,12 +11,13 @@ namespace Slang
     struct IRGlobalValueWithCode;
     class DiagnosticSink;
     class TargetProgram;
+    struct IRInst;
 
         /// Any call to a function that takes or returns a string/RefType parameter is inlined
     Result performTypeInlining(IRModule* module, DiagnosticSink* sink);
 
         /// Inline any call sites to functions marked `[unsafeForceInlineEarly]`
-    bool performMandatoryEarlyInlining(IRModule* module);
+    bool performMandatoryEarlyInlining(IRModule* module, HashSet<IRInst*>* modifiedFuncs = nullptr);
 
         /// Inline any call sites to functions marked `[ForceInline]`
     void performForceInlining(IRModule* module);

source/slang/slang-ir-specialize.cpp

@@ -61,6 +61,12 @@ struct SpecializationContext
         , targetProgram(target)
     {
     }
+    ~SpecializationContext()
+    {
+        module->getContainerPool().free(&workList);
+        module->getContainerPool().free(&workListSet);
+        module->getContainerPool().free(&cleanInsts);
+    }
 
     // An instruction is then fully specialized if and only
     // if it is in our set.
@@ -1246,6 +1252,9 @@ struct SpecializationContext
 
         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));
+
         localWorkList.add(inst);
         processedInsts.add(inst);
 

source/slang/slang-ir-uniformity.cpp

@@ -193,6 +193,9 @@ namespace Slang
         {
             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); });
+
             auto addToWorkList = [&](IRInst* inst)
                 {
                     if (workListSet.add(inst))
@@ -412,6 +415,8 @@ namespace Slang
         void analyzeModule()
         {
             List<IRInst*>& workList = *module->getContainerPool().getList<IRInst>();
+            SLANG_DEFER([&]() { module->getContainerPool().free(&workList); });
+
             for (auto globalInst : module->getGlobalInsts())
             {
                 if (auto code = as<IRGlobalValueWithCode>(globalInst))
@@ -449,6 +454,8 @@ namespace Slang
         void eliminateAsDynamicUniformInst()
         {
             List<IRInst*>& workList = *module->getContainerPool().getList<IRInst>();
+            SLANG_DEFER([&]() { module->getContainerPool().free(&workList); });
+
             workList.add(module->getModuleInst());
             for (Index i = 0; i < workList.getCount(); i++)
             {

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

@@ -10881,32 +10881,30 @@ 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);
     for (;;)
     {
         bool changed = false;
-        changed |= performMandatoryEarlyInlining(module);
-        if (!changed)
-            break;
-    }
-
-    // Optionally, run optimization after inlining.
-    if (!sharedContextStorage.m_linkage->m_optionSet.getBoolOption(CompilerOptionName::MinimumSlangOptimization))
-    {
-        for (;;)
+        modifiedFuncs->clear();
+        changed = performMandatoryEarlyInlining(module, modifiedFuncs);
+        if (changed)
         {
-            bool changed = false;
-            changed |= constructSSA(module);
-            simplifyCFG(module, CFGSimplificationOptions::getDefault());
-            changed |= applySparseConditionalConstantPropagation(module, compileRequest->getSink());
-            changed |= peepholeOptimize(nullptr, module, PeepholeOptimizationOptions::getPrelinking());
-            for (auto inst : module->getGlobalInsts())
+            changed = peepholeOptimizeGlobalScope(nullptr, module);
+            if (!minimumOptimizations)
             {
-                if (auto func = as<IRGlobalValueWithCode>(inst))
+                for (auto func : *modifiedFuncs)
+                {
+                    changed |= constructSSA(func);
+                    changed |= applySparseConditionalConstantPropagation(func, compileRequest->getSink());
+                    changed |= peepholeOptimize(nullptr, func);
                     eliminateDeadCode(func);
+                }
             }
-            if (!changed)
-                break;
         }
+        if (!changed)
+            break;
     }
 
     // Check for using uninitialized out parameters.