format

* format

* Minor test fixes

* enable checking cpp format in ci

1 files changed, 138 insertions, 123 deletions

diff --git a/source/slang/slang-ir-ssa-simplification.cpp b/source/slang/slang-ir-ssa-simplification.cpp
index a71b2c86c..b5081dab7 100644
--- a/source/slang/slang-ir-ssa-simplification.cpp
+++ b/source/slang/slang-ir-ssa-simplification.cpp
@@ -1,155 +1,170 @@
 // slang-ir-ssa-simplification.cpp
 #include "slang-ir-ssa-simplification.h"
-#include "slang-ir.h"
-#include "slang-ir-ssa.h"
-#include "slang-ir-sccp.h"
+
+#include "../core/slang-performance-profiler.h"
 #include "slang-ir-dce.h"
-#include "slang-ir-simplify-cfg.h"
-#include "slang-ir-peephole.h"
 #include "slang-ir-deduplicate-generic-children.h"
-#include "slang-ir-remove-unused-generic-param.h"
-#include "slang-ir-redundancy-removal.h"
+#include "slang-ir-peephole.h"
 #include "slang-ir-propagate-func-properties.h"
-#include "../core/slang-performance-profiler.h"
+#include "slang-ir-redundancy-removal.h"
+#include "slang-ir-remove-unused-generic-param.h"
+#include "slang-ir-sccp.h"
+#include "slang-ir-simplify-cfg.h"
+#include "slang-ir-ssa.h"
 #include "slang-ir-util.h"
+#include "slang-ir.h"
 
 namespace Slang
 {
-    IRSimplificationOptions IRSimplificationOptions::getDefault(TargetProgram* targetProgram)
-    {
-        IRSimplificationOptions result;
-        result.minimalOptimization = targetProgram ? targetProgram->getOptionSet().shouldPerformMinimumOptimizations() : false;
-        if (result.minimalOptimization)
-            result.cfgOptions = CFGSimplificationOptions::getFast();
-        else
-            result.cfgOptions = CFGSimplificationOptions::getDefault();
-        result.peepholeOptions = PeepholeOptimizationOptions();
-        if (targetProgram)
-            result.deadCodeElimOptions.keepGlobalParamsAlive = targetProgram->getOptionSet().getBoolOption(CompilerOptionName::PreserveParameters);
-        result.deadCodeElimOptions.useFastAnalysis = result.minimalOptimization;
-        return result;
-    }
-
-    IRSimplificationOptions IRSimplificationOptions::getFast(TargetProgram* targetProgram)
-    {
-        IRSimplificationOptions result;
-        result.minimalOptimization = targetProgram ? targetProgram->getOptionSet().shouldPerformMinimumOptimizations() : false;
+IRSimplificationOptions IRSimplificationOptions::getDefault(TargetProgram* targetProgram)
+{
+    IRSimplificationOptions result;
+    result.minimalOptimization =
+        targetProgram ? targetProgram->getOptionSet().shouldPerformMinimumOptimizations() : false;
+    if (result.minimalOptimization)
         result.cfgOptions = CFGSimplificationOptions::getFast();
-        result.peepholeOptions = PeepholeOptimizationOptions();
-        if (targetProgram)
-            result.deadCodeElimOptions.keepGlobalParamsAlive = targetProgram->getOptionSet().getBoolOption(CompilerOptionName::PreserveParameters);
-        result.deadCodeElimOptions.useFastAnalysis = result.minimalOptimization;
-        return result;
-    }
+    else
+        result.cfgOptions = CFGSimplificationOptions::getDefault();
+    result.peepholeOptions = PeepholeOptimizationOptions();
+    if (targetProgram)
+        result.deadCodeElimOptions.keepGlobalParamsAlive =
+            targetProgram->getOptionSet().getBoolOption(CompilerOptionName::PreserveParameters);
+    result.deadCodeElimOptions.useFastAnalysis = result.minimalOptimization;
+    return result;
+}
 
-    // Run a combination of SSA, SCCP, SimplifyCFG, and DeadCodeElimination pass
-    // until no more changes are possible.
-    void simplifyIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options, DiagnosticSink* sink)
-    {
-        SLANG_PROFILE;
-        bool changed = true;
-        const int kMaxIterations = 8;
-        const int kMaxFuncIterations = 16;
-        int iterationCounter = 0;
+IRSimplificationOptions IRSimplificationOptions::getFast(TargetProgram* targetProgram)
+{
+    IRSimplificationOptions result;
+    result.minimalOptimization =
+        targetProgram ? targetProgram->getOptionSet().shouldPerformMinimumOptimizations() : false;
+    result.cfgOptions = CFGSimplificationOptions::getFast();
+    result.peepholeOptions = PeepholeOptimizationOptions();
+    if (targetProgram)
+        result.deadCodeElimOptions.keepGlobalParamsAlive =
+            targetProgram->getOptionSet().getBoolOption(CompilerOptionName::PreserveParameters);
+    result.deadCodeElimOptions.useFastAnalysis = result.minimalOptimization;
+    return result;
+}
 
-        while (changed && iterationCounter < kMaxIterations)
-        {
-            if (sink && sink->getErrorCount())
-                break;
+// Run a combination of SSA, SCCP, SimplifyCFG, and DeadCodeElimination pass
+// until no more changes are possible.
+void simplifyIR(
+    TargetProgram* target,
+    IRModule* module,
+    IRSimplificationOptions options,
+    DiagnosticSink* sink)
+{
+    SLANG_PROFILE;
+    bool changed = true;
+    const int kMaxIterations = 8;
+    const int kMaxFuncIterations = 16;
+    int iterationCounter = 0;
 
-            changed = false;
+    while (changed && iterationCounter < kMaxIterations)
+    {
+        if (sink && sink->getErrorCount())
+            break;
+
+        changed = false;
 
-            changed |= deduplicateGenericChildren(module);
-            changed |= propagateFuncProperties(module);
-            changed |= removeUnusedGenericParam(module);
-            changed |= applySparseConditionalConstantPropagationForGlobalScope(module, sink);
-            changed |= peepholeOptimizeGlobalScope(target, module);
-            changed |= trimOptimizableTypes(module);
+        changed |= deduplicateGenericChildren(module);
+        changed |= propagateFuncProperties(module);
+        changed |= removeUnusedGenericParam(module);
+        changed |= applySparseConditionalConstantPropagationForGlobalScope(module, sink);
+        changed |= peepholeOptimizeGlobalScope(target, module);
+        changed |= trimOptimizableTypes(module);
 
-            for (auto inst : module->getGlobalInsts())
+        for (auto inst : module->getGlobalInsts())
+        {
+            auto func = as<IRGlobalValueWithCode>(inst);
+            if (!func)
+                continue;
+            bool funcChanged = true;
+            int funcIterationCount = 0;
+            while (funcChanged && funcIterationCount < kMaxFuncIterations)
             {
-                auto func = as<IRGlobalValueWithCode>(inst);
-                if (!func)
-                    continue;
-                bool funcChanged = true;
-                int funcIterationCount = 0;
-                while (funcChanged && funcIterationCount < kMaxFuncIterations)
-                {
-                    
-                    eliminateDeadCode(func, options.deadCodeElimOptions);
-                    funcChanged = false;
-                    funcChanged |= applySparseConditionalConstantPropagation(func, sink);
-                    funcChanged |= peepholeOptimize(target, func);
-                    if (options.removeRedundancy)
-                        funcChanged |= removeRedundancyInFunc(func);
-                    funcChanged |= simplifyCFG(func, options.cfgOptions);
-                    // Note: we disregard the `changed` state from dead code elimination pass since
-                    // SCCP pass could be generating temporarily evaluated constant values and never actually use them.
-                    // DCE will always remove those nearly generated consts and always returns true here.
-                    // Run eliminate-dead-code twice to ensure optimizations are applied on the dce'd code.
-                    //
-                    eliminateDeadCode(func, options.deadCodeElimOptions);
-                    if (funcIterationCount == 0)
-                        funcChanged |= constructSSA(func);
-                    changed |= funcChanged;
-                    funcIterationCount++;
-                }
+
+                eliminateDeadCode(func, options.deadCodeElimOptions);
+                funcChanged = false;
+                funcChanged |= applySparseConditionalConstantPropagation(func, sink);
+                funcChanged |= peepholeOptimize(target, func);
+                if (options.removeRedundancy)
+                    funcChanged |= removeRedundancyInFunc(func);
+                funcChanged |= simplifyCFG(func, options.cfgOptions);
+                // Note: we disregard the `changed` state from dead code elimination pass since
+                // SCCP pass could be generating temporarily evaluated constant values and never
+                // actually use them. DCE will always remove those nearly generated consts and
+                // always returns true here. Run eliminate-dead-code twice to ensure optimizations
+                // are applied on the dce'd code.
+                //
+                eliminateDeadCode(func, options.deadCodeElimOptions);
+                if (funcIterationCount == 0)
+                    funcChanged |= constructSSA(func);
+                changed |= funcChanged;
+                funcIterationCount++;
             }
-            iterationCounter++;
         }
-        eliminateDeadCode(module, options.deadCodeElimOptions);
+        iterationCounter++;
     }
+    eliminateDeadCode(module, options.deadCodeElimOptions);
+}
 
-    void simplifyNonSSAIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options)
+void simplifyNonSSAIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options)
+{
+    bool changed = true;
+    const int kMaxIterations = 8;
+    int iterationCounter = 0;
+
+    while (changed && iterationCounter < kMaxIterations)
     {
-        bool changed = true;
-        const int kMaxIterations = 8;
-        int iterationCounter = 0;
+        changed = false;
+        changed |= peepholeOptimize(target, module, options.peepholeOptions);
 
-        while (changed && iterationCounter < kMaxIterations)
-        {
-            changed = false;
-            changed |= peepholeOptimize(target, module, options.peepholeOptions);
-
-            if (!options.minimalOptimization)
-                changed |= removeRedundancy(module);
-            changed |= simplifyCFG(module, options.cfgOptions);
-
-            // Note: we disregard the `changed` state from dead code elimination pass since
-            // SCCP pass could be generating temporarily evaluated constant values and never actually use them.
-            // DCE will always remove those nearly generated consts and always returns true here.
-            eliminateDeadCode(module, options.deadCodeElimOptions);
-            iterationCounter++;
-        }
+        if (!options.minimalOptimization)
+            changed |= removeRedundancy(module);
+        changed |= simplifyCFG(module, options.cfgOptions);
+
+        // Note: we disregard the `changed` state from dead code elimination pass since
+        // SCCP pass could be generating temporarily evaluated constant values and never actually
+        // use them. DCE will always remove those nearly generated consts and always returns true
+        // here.
+        eliminateDeadCode(module, options.deadCodeElimOptions);
+        iterationCounter++;
     }
+}
 
 
-    void simplifyFunc(TargetProgram* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink)
+void simplifyFunc(
+    TargetProgram* target,
+    IRGlobalValueWithCode* func,
+    IRSimplificationOptions options,
+    DiagnosticSink* sink)
+{
+    bool changed = true;
+    const int kMaxIterations = 8;
+    int iterationCounter = 0;
+    while (changed && iterationCounter < kMaxIterations)
     {
-        bool changed = true;
-        const int kMaxIterations = 8;
-        int iterationCounter = 0;
-        while (changed && iterationCounter < kMaxIterations)
-        {
-            if (sink && sink->getErrorCount())
-                break;
+        if (sink && sink->getErrorCount())
+            break;
 
-            changed = false;
-            changed |= applySparseConditionalConstantPropagation(func, sink);
-            changed |= peepholeOptimize(target, func);
-            if (!options.minimalOptimization)
-                changed |= removeRedundancyInFunc(func);
-            changed |= simplifyCFG(func, options.cfgOptions);
+        changed = false;
+        changed |= applySparseConditionalConstantPropagation(func, sink);
+        changed |= peepholeOptimize(target, func);
+        if (!options.minimalOptimization)
+            changed |= removeRedundancyInFunc(func);
+        changed |= simplifyCFG(func, options.cfgOptions);
 
-            // Note: we disregard the `changed` state from dead code elimination pass since
-            // SCCP pass could be generating temporarily evaluated constant values and never actually use them.
-            // DCE will always remove those nearly generated consts and always returns true here.
-            eliminateDeadCode(func, options.deadCodeElimOptions);
+        // Note: we disregard the `changed` state from dead code elimination pass since
+        // SCCP pass could be generating temporarily evaluated constant values and never actually
+        // use them. DCE will always remove those nearly generated consts and always returns true
+        // here.
+        eliminateDeadCode(func, options.deadCodeElimOptions);
 
-            changed |= constructSSA(func);
+        changed |= constructSSA(func);
 
-            iterationCounter++;
-
-        }
+        iterationCounter++;
     }
 }
+} // namespace Slang