Plumb options to DCE pass.

csyonghe · csyonghe · commit 3e91cf1db030 · 2024-05-28T17:52:36.000-07:00
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
@@ -479,7 +479,9 @@ Result linkAndOptimizeIR(
 
     IRSimplificationOptions defaultIRSimplificationOptions = IRSimplificationOptions::getDefault(targetProgram);
     IRSimplificationOptions fastIRSimplificationOptions = IRSimplificationOptions::getFast(targetProgram);
+    IRDeadCodeEliminationOptions deadCodeEliminationOptions = IRDeadCodeEliminationOptions();
     fastIRSimplificationOptions.minimalOptimization = defaultIRSimplificationOptions.minimalOptimization;
+    deadCodeEliminationOptions.useFastAnalysis = fastIRSimplificationOptions.minimalOptimization;
 
     simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);
 
@@ -535,7 +537,7 @@ Result linkAndOptimizeIR(
         dumpIRIfEnabled(codeGenContext, irModule, "AFTER-SPECIALIZE");
 
         applySparseConditionalConstantPropagation(irModule, codeGenContext->getSink());
-        eliminateDeadCode(irModule);
+        eliminateDeadCode(irModule, deadCodeEliminationOptions);
 
         validateIRModuleIfEnabled(codeGenContext, irModule);
     
@@ -627,7 +629,7 @@ Result linkAndOptimizeIR(
     
     if (fastIRSimplificationOptions.minimalOptimization)
     {
-        eliminateDeadCode(irModule);
+        eliminateDeadCode(irModule, deadCodeEliminationOptions);
     }
     else
     {
@@ -1078,7 +1080,7 @@ Result linkAndOptimizeIR(
     //
     // We run DCE pass again to clean things up.
     //
-    eliminateDeadCode(irModule);
+    eliminateDeadCode(irModule, deadCodeEliminationOptions);
 
     if (isKhronosTarget(targetRequest))
     {
@@ -1139,7 +1141,7 @@ Result linkAndOptimizeIR(
     if (emitSpirvDirectly)
     {
         performIntrinsicFunctionInlining(irModule);
-        eliminateDeadCode(irModule);
+        eliminateDeadCode(irModule, deadCodeEliminationOptions);
     }
     eliminateMultiLevelBreak(irModule);
 
diff --git a/source/slang/slang-ir-dce.cpp b/source/slang/slang-ir-dce.cpp
@@ -307,7 +307,11 @@ 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::None))
+    SideEffectAnalysisOptions sideEffectOptions = options.useFastAnalysis
+        ? SideEffectAnalysisOptions::None
+        : SideEffectAnalysisOptions::UseDominanceTree;
+
+    if (inst->mightHaveSideEffects(sideEffectOptions))
     {
         return true;
     }
diff --git a/source/slang/slang-ir-dce.h b/source/slang/slang-ir-dce.h
@@ -11,6 +11,7 @@ namespace Slang
     {
         bool keepExportsAlive = false;
         bool keepLayoutsAlive = false;
+        bool useFastAnalysis = false;
     };
 
         /// Eliminate "dead" code from the given IR module.
diff --git a/source/slang/slang-ir-peephole.cpp b/source/slang/slang-ir-peephole.cpp
@@ -11,13 +11,15 @@ struct PeepholeContext : InstPassBase
 {
     PeepholeContext(IRModule* inModule)
         : InstPassBase(inModule)
-    {}
+    {
+    }
 
     bool changed = false;
     FloatingPointMode floatingPointMode = FloatingPointMode::Precise;
     bool removeOldInst = true;
     bool isInGeneric = false;
     bool isPrelinking = false;
+    bool useFastAnalysis = false;
 
     TargetProgram* targetProgram;
 
@@ -350,7 +352,7 @@ struct PeepholeContext : InstPassBase
             }
             else
             {
-                //changed |= tryFoldElementExtractFromUpdateInst(inst);
+                changed |= tryFoldElementExtractFromUpdateInst(inst);
             }
             break;
         case kIROp_GetElement:
@@ -415,7 +417,7 @@ struct PeepholeContext : InstPassBase
             }
             else
             {
-                //changed |= tryFoldElementExtractFromUpdateInst(inst);
+                changed |= tryFoldElementExtractFromUpdateInst(inst);
             }
             break;
         case kIROp_UpdateElement:
@@ -846,7 +848,7 @@ struct PeepholeContext : InstPassBase
         case kIROp_Div:
         case kIROp_And:
         case kIROp_Or:
-            //changed |= tryOptimizeArithmeticInst(inst);
+            changed |= tryOptimizeArithmeticInst(inst);
             break;
         case kIROp_Param:
             {
@@ -895,8 +897,7 @@ struct PeepholeContext : InstPassBase
                             // Never remove param inst.
                             changed = true;
                         }
-#if 0
-                        else
+                        else if (!useFastAnalysis)
                         {
                             // If argValue is defined locally,
                             // we can replace only if argVal dominates inst.
@@ -913,7 +914,6 @@ struct PeepholeContext : InstPassBase
                                 changed = true;
                             }
                         }
-#endif
                     }
                 }
             }
@@ -1120,7 +1120,8 @@ struct PeepholeContext : InstPassBase
 
     bool processFunc(IRInst* func)
     {
-        func->getModule()->invalidateAllAnalysis();
+        if (!useFastAnalysis)
+            func->getModule()->invalidateAllAnalysis();
 
         bool lastIsInGeneric = isInGeneric;
         if (!isInGeneric)
@@ -1153,21 +1154,27 @@ bool peepholeOptimize(TargetProgram* target, IRModule* module, PeepholeOptimizat
     PeepholeContext context = PeepholeContext(module);
     context.targetProgram = target;
     context.isPrelinking = options.isPrelinking;
+    context.useFastAnalysis = target
+        ? target->getOptionSet().getBoolOption(CompilerOptionName::MinimumSlangOptimization)
+        : true;
     return context.processModule();
 }
 
 bool peepholeOptimize(TargetProgram* target, IRInst* func)
 {
     PeepholeContext context = PeepholeContext(func->getModule());
     context.targetProgram = target;
+    context.useFastAnalysis = target
+        ? target->getOptionSet().getBoolOption(CompilerOptionName::MinimumSlangOptimization)
+        : true;
     return context.processFunc(func);
 }
 
 bool peepholeOptimizeGlobalScope(TargetProgram* target, IRModule* module)
 {
     PeepholeContext context = PeepholeContext(module);
     context.targetProgram = target;
-
+    context.useFastAnalysis = true;
     bool result = false;
     for (;;)
     {
@@ -1189,6 +1196,7 @@ bool tryReplaceInstUsesWithSimplifiedValue(TargetProgram* target, IRModule* modu
     PeepholeContext context = PeepholeContext(inst->getModule());
     context.targetProgram = target;
     context.removeOldInst = false;
+    context.useFastAnalysis = true;
     context.processInst(inst);
     return context.changed;
 }
diff --git a/source/slang/slang-ir-ssa-simplification.cpp b/source/slang/slang-ir-ssa-simplification.cpp
@@ -45,6 +45,8 @@ namespace Slang
         const int kMaxIterations = 8;
         const int kMaxFuncIterations = 16;
         int iterationCounter = 0;
+        IRDeadCodeEliminationOptions dceOptions = IRDeadCodeEliminationOptions();
+        dceOptions.useFastAnalysis = options.minimalOptimization;
 
         while (changed && iterationCounter < kMaxIterations)
         {
@@ -77,7 +79,7 @@ namespace Slang
                     // 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);
+                    eliminateDeadCode(func, dceOptions);
                     if (funcIterationCount == 0)
                         funcChanged |= constructSSA(func);
                     changed |= funcChanged;
@@ -86,14 +88,17 @@ namespace Slang
             }
             iterationCounter++;
         }
-        eliminateDeadCode(module);
+        eliminateDeadCode(module, dceOptions);
     }
 
     void simplifyNonSSAIR(TargetProgram* target, IRModule* module, IRSimplificationOptions options)
     {
         bool changed = true;
         const int kMaxIterations = 8;
         int iterationCounter = 0;
+        IRDeadCodeEliminationOptions dceOptions = IRDeadCodeEliminationOptions();
+        dceOptions.useFastAnalysis = options.minimalOptimization;
+
         while (changed && iterationCounter < kMaxIterations)
         {
             changed = false;
@@ -106,14 +111,17 @@ namespace Slang
             // 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);
+            eliminateDeadCode(module, dceOptions);
             iterationCounter++;
         }
     }
 
 
     void simplifyFunc(TargetProgram* target, IRGlobalValueWithCode* func, IRSimplificationOptions options, DiagnosticSink* sink)
     {
+        IRDeadCodeEliminationOptions dceOptions = IRDeadCodeEliminationOptions();
+        dceOptions.useFastAnalysis = options.minimalOptimization;
+
         bool changed = true;
         const int kMaxIterations = 8;
         int iterationCounter = 0;
@@ -132,7 +140,7 @@ namespace Slang
             // 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);
+            eliminateDeadCode(func, dceOptions);
 
             changed |= constructSSA(func);
 
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
@@ -10834,12 +10834,18 @@ RefPtr<IRModule> generateIRForTranslationUnit(
     constructSSA(module);
     simplifyCFG(module, CFGSimplificationOptions::getDefault());
     applySparseConditionalConstantPropagation(module, compileRequest->getSink());
-    peepholeOptimize(nullptr, module, PeepholeOptimizationOptions::getPrelinking());
+    auto peepholeOptions = PeepholeOptimizationOptions::getPrelinking();
+    peepholeOptimize(nullptr, module, peepholeOptions);
+
+    IRDeadCodeEliminationOptions dceOptions = IRDeadCodeEliminationOptions();
+    dceOptions.keepExportsAlive = true;
+    dceOptions.keepLayoutsAlive = true;
+    dceOptions.useFastAnalysis = true;
 
     for (auto inst : module->getGlobalInsts())
     {
         if (auto func = as<IRGlobalValueWithCode>(inst))
-            eliminateDeadCode(func);
+            eliminateDeadCode(func, dceOptions);
     }
     // Next, inline calls to any functions that have been
     // marked for mandatory "early" inlining.
@@ -10963,9 +10969,7 @@ RefPtr<IRModule> generateIRForTranslationUnit(
         // pass here, but make sure to set our options so that we don't
         // eliminate anything that has been marked for export.
         //
-        IRDeadCodeEliminationOptions options;
-        options.keepExportsAlive = true;
-        eliminateDeadCode(module, options);
+        eliminateDeadCode(module, dceOptions);
 
         if (linkage->m_optionSet.shouldObfuscateCode())
         {

Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,9 @@ Result linkAndOptimizeIR(`
`479`	`479`
`480`	`480`	`IRSimplificationOptions defaultIRSimplificationOptions = IRSimplificationOptions::getDefault(targetProgram);`
`481`	`481`	`IRSimplificationOptions fastIRSimplificationOptions = IRSimplificationOptions::getFast(targetProgram);`
	`482`	`+ IRDeadCodeEliminationOptions deadCodeEliminationOptions = IRDeadCodeEliminationOptions();`
`482`	`483`	`fastIRSimplificationOptions.minimalOptimization = defaultIRSimplificationOptions.minimalOptimization;`
	`484`	`+ deadCodeEliminationOptions.useFastAnalysis = fastIRSimplificationOptions.minimalOptimization;`
`483`	`485`
`484`	`486`	`simplifyIR(targetProgram, irModule, defaultIRSimplificationOptions, sink);`
`485`	`487`
`@@ -535,7 +537,7 @@ Result linkAndOptimizeIR(`
`535`	`537`	`dumpIRIfEnabled(codeGenContext, irModule, "AFTER-SPECIALIZE");`
`536`	`538`
`537`	`539`	`applySparseConditionalConstantPropagation(irModule, codeGenContext->getSink());`
`538`		`- eliminateDeadCode(irModule);`
	`540`	`+ eliminateDeadCode(irModule, deadCodeEliminationOptions);`
`539`	`541`
`540`	`542`	`validateIRModuleIfEnabled(codeGenContext, irModule);`
`541`	`543`
`@@ -627,7 +629,7 @@ Result linkAndOptimizeIR(`
`627`	`629`
`628`	`630`	`if (fastIRSimplificationOptions.minimalOptimization)`
`629`	`631`	`{`
`630`		`- eliminateDeadCode(irModule);`
	`632`	`+ eliminateDeadCode(irModule, deadCodeEliminationOptions);`
`631`	`633`	`}`
`632`	`634`	`else`
`633`	`635`	`{`
`@@ -1078,7 +1080,7 @@ Result linkAndOptimizeIR(`
`1078`	`1080`	`//`
`1079`	`1081`	`// We run DCE pass again to clean things up.`
`1080`	`1082`	`//`
`1081`		`- eliminateDeadCode(irModule);`
	`1083`	`+ eliminateDeadCode(irModule, deadCodeEliminationOptions);`
`1082`	`1084`
`1083`	`1085`	`if (isKhronosTarget(targetRequest))`
`1084`	`1086`	`{`
`@@ -1139,7 +1141,7 @@ Result linkAndOptimizeIR(`
`1139`	`1141`	`if (emitSpirvDirectly)`
`1140`	`1142`	`{`
`1141`	`1143`	`performIntrinsicFunctionInlining(irModule);`
`1142`		`- eliminateDeadCode(irModule);`
	`1144`	`+ eliminateDeadCode(irModule, deadCodeEliminationOptions);`
`1143`	`1145`	`}`
`1144`	`1146`	`eliminateMultiLevelBreak(irModule);`
`1145`	`1147`
Original file line number	Diff line number	Diff line change
`@@ -307,7 +307,11 @@ bool shouldInstBeLiveIfParentIsLive(IRInst* inst, IRDeadCodeEliminationOptions o`
`307`	`307`	// First, if `inst` is an instruction that might have some effects
`308`	`308`	`// when it is executed, then we should keep it around.`
`309`	`309`	`//`
`310`		`- if (inst->mightHaveSideEffects(SideEffectAnalysisOptions::None))`
	`310`	`+ SideEffectAnalysisOptions sideEffectOptions = options.useFastAnalysis`
	`311`	`+ ? SideEffectAnalysisOptions::None`
	`312`	`+ : SideEffectAnalysisOptions::UseDominanceTree;`
	`313`	`+`
	`314`	`+ if (inst->mightHaveSideEffects(sideEffectOptions))`
`311`	`315`	`{`
`312`	`316`	`return true;`
`313`	`317`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace Slang`
`11`	`11`	`{`
`12`	`12`	`bool keepExportsAlive = false;`
`13`	`13`	`bool keepLayoutsAlive = false;`
	`14`	`+ bool useFastAnalysis = false;`
`14`	`15`	`};`
`15`	`16`
`16`	`17`	`/// Eliminate "dead" code from the given IR module.`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,15 @@ struct PeepholeContext : InstPassBase`
`11`	`11`	`{`
`12`	`12`	`PeepholeContext(IRModule* inModule)`
`13`	`13`	`: InstPassBase(inModule)`
`14`		`- {}`
	`14`	`+ {`
	`15`	`+ }`
`15`	`16`
`16`	`17`	`bool changed = false;`
`17`	`18`	`FloatingPointMode floatingPointMode = FloatingPointMode::Precise;`
`18`	`19`	`bool removeOldInst = true;`
`19`	`20`	`bool isInGeneric = false;`
`20`	`21`	`bool isPrelinking = false;`
	`22`	`+ bool useFastAnalysis = false;`
`21`	`23`
`22`	`24`	`TargetProgram* targetProgram;`
`23`	`25`
`@@ -350,7 +352,7 @@ struct PeepholeContext : InstPassBase`
`350`	`352`	`}`
`351`	`353`	`else`
`352`	`354`	`{`
`353`		`- //changed \|= tryFoldElementExtractFromUpdateInst(inst);`
	`355`	`+ changed \|= tryFoldElementExtractFromUpdateInst(inst);`
`354`	`356`	`}`
`355`	`357`	`break;`
`356`	`358`	`case kIROp_GetElement:`
`@@ -415,7 +417,7 @@ struct PeepholeContext : InstPassBase`
`415`	`417`	`}`
`416`	`418`	`else`
`417`	`419`	`{`
`418`		`- //changed \|= tryFoldElementExtractFromUpdateInst(inst);`
	`420`	`+ changed \|= tryFoldElementExtractFromUpdateInst(inst);`
`419`	`421`	`}`
`420`	`422`	`break;`
`421`	`423`	`case kIROp_UpdateElement:`
`@@ -846,7 +848,7 @@ struct PeepholeContext : InstPassBase`
`846`	`848`	`case kIROp_Div:`
`847`	`849`	`case kIROp_And:`
`848`	`850`	`case kIROp_Or:`
`849`		`- //changed \|= tryOptimizeArithmeticInst(inst);`
	`851`	`+ changed \|= tryOptimizeArithmeticInst(inst);`
`850`	`852`	`break;`
`851`	`853`	`case kIROp_Param:`
`852`	`854`	`{`
`@@ -895,8 +897,7 @@ struct PeepholeContext : InstPassBase`
`895`	`897`	`// Never remove param inst.`
`896`	`898`	`changed = true;`
`897`	`899`	`}`
`898`		`-#if 0`
`899`		`- else`
	`900`	`+ else if (!useFastAnalysis)`
`900`	`901`	`{`
`901`	`902`	`// If argValue is defined locally,`
`902`	`903`	`// we can replace only if argVal dominates inst.`
`@@ -913,7 +914,6 @@ struct PeepholeContext : InstPassBase`
`913`	`914`	`changed = true;`
`914`	`915`	`}`
`915`	`916`	`}`
`916`		`-#endif`
`917`	`917`	`}`
`918`	`918`	`}`
`919`	`919`	`}`
`@@ -1120,7 +1120,8 @@ struct PeepholeContext : InstPassBase`
`1120`	`1120`
`1121`	`1121`	`bool processFunc(IRInst* func)`
`1122`	`1122`	`{`
`1123`		`- func->getModule()->invalidateAllAnalysis();`
	`1123`	`+ if (!useFastAnalysis)`
	`1124`	`+ func->getModule()->invalidateAllAnalysis();`
`1124`	`1125`
`1125`	`1126`	`bool lastIsInGeneric = isInGeneric;`
`1126`	`1127`	`if (!isInGeneric)`
`@@ -1153,21 +1154,27 @@ bool peepholeOptimize(TargetProgram* target, IRModule* module, PeepholeOptimizat`
`1153`	`1154`	`PeepholeContext context = PeepholeContext(module);`
`1154`	`1155`	`context.targetProgram = target;`
`1155`	`1156`	`context.isPrelinking = options.isPrelinking;`
	`1157`	`+ context.useFastAnalysis = target`
	`1158`	`+ ? target->getOptionSet().getBoolOption(CompilerOptionName::MinimumSlangOptimization)`
	`1159`	`+ : true;`
`1156`	`1160`	`return context.processModule();`
`1157`	`1161`	`}`
`1158`	`1162`
`1159`	`1163`	`bool peepholeOptimize(TargetProgram* target, IRInst* func)`
`1160`	`1164`	`{`
`1161`	`1165`	`PeepholeContext context = PeepholeContext(func->getModule());`
`1162`	`1166`	`context.targetProgram = target;`
	`1167`	`+ context.useFastAnalysis = target`
	`1168`	`+ ? target->getOptionSet().getBoolOption(CompilerOptionName::MinimumSlangOptimization)`
	`1169`	`+ : true;`
`1163`	`1170`	`return context.processFunc(func);`
`1164`	`1171`	`}`
`1165`	`1172`
`1166`	`1173`	`bool peepholeOptimizeGlobalScope(TargetProgram* target, IRModule* module)`
`1167`	`1174`	`{`
`1168`	`1175`	`PeepholeContext context = PeepholeContext(module);`
`1169`	`1176`	`context.targetProgram = target;`
`1170`		`-`
	`1177`	`+ context.useFastAnalysis = true;`
`1171`	`1178`	`bool result = false;`
`1172`	`1179`	`for (;;)`
`1173`	`1180`	`{`
`@@ -1189,6 +1196,7 @@ bool tryReplaceInstUsesWithSimplifiedValue(TargetProgram* target, IRModule* modu`
`1189`	`1196`	`PeepholeContext context = PeepholeContext(inst->getModule());`
`1190`	`1197`	`context.targetProgram = target;`
`1191`	`1198`	`context.removeOldInst = false;`
	`1199`	`+ context.useFastAnalysis = true;`
`1192`	`1200`	`context.processInst(inst);`
`1193`	`1201`	`return context.changed;`
`1194`	`1202`	`}`