Rename UsesCallfinallyThunks to UsesCallFinallyThunks

filipnavara · filipnavara · commit 25840685040d · 2024-03-29T08:46:38.000+01:00
diff --git a/src/coreclr/jit/codegencommon.cpp b/src/coreclr/jit/codegencommon.cpp
@@ -412,7 +412,7 @@ void CodeGen::genMarkLabelsForCodegen()
             case BBJ_CALLFINALLY:
                 // The finally target itself will get marked by walking the EH table, below, and marking
                 // all handler begins.
-                if (compiler->UsesCallfinallyThunks())
+                if (compiler->UsesCallFinallyThunks())
                 {
                     // For callfinally thunks, we need to mark the block following the callfinally/callfinallyret pair,
                     // as that's needed for identifying the range of the "duplicate finally" region in EH data.
@@ -2242,7 +2242,7 @@ void CodeGen::genReportEH()
     unsigned clonedFinallyCount = 0;
 
     // Duplicate clauses are not used by NativeAOT ABI
-    if (compiler->UsesFunclets() && compiler->UsesCallfinallyThunks() && !isNativeAOT)
+    if (compiler->UsesFunclets() && compiler->UsesCallFinallyThunks() && !isNativeAOT)
     {
         // We don't keep track of how many cloned finally there are. So, go through and count.
         // We do a quick pass first through the EH table to see if there are any try/finally
@@ -2276,7 +2276,7 @@ void CodeGen::genReportEH()
     {
         if (compiler->UsesFunclets())
         {
-            if (compiler->UsesCallfinallyThunks())
+            if (compiler->UsesCallFinallyThunks())
             {
                 printf("%d EH table entries, %d duplicate clauses, %d cloned finallys, %d total EH entries reported to "
                        "VM\n",
diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
@@ -5431,15 +5431,15 @@ bool Compiler::shouldAlignLoop(FlowGraphNaturalLoop* loop, BasicBlock* top)
 
     assert(!top->IsFirst());
 
-    if (UsesCallfinallyThunks() && top->Prev()->KindIs(BBJ_CALLFINALLY))
+    if (UsesCallFinallyThunks() && top->Prev()->KindIs(BBJ_CALLFINALLY))
     {
         // It must be a retless BBJ_CALLFINALLY if we get here.
         assert(!top->Prev()->isBBCallFinallyPair());
 
         // If the block before the loop start is a retless BBJ_CALLFINALLY
-        // with UsesCallfinallyThunks, we can't add alignment
+        // with UsesCallFinallyThunks, we can't add alignment
         // because it will affect reported EH region range. For x86 (where
-        // !UsesCallfinallyThunks), we can allow this.
+        // !UsesCallFinallyThunks), we can allow this.
 
         JITDUMP("Skipping alignment for " FMT_LP "; its top block follows a CALLFINALLY block\n", loop->GetIndex());
         return false;
@@ -5450,7 +5450,7 @@ bool Compiler::shouldAlignLoop(FlowGraphNaturalLoop* loop, BasicBlock* top)
         // If the previous block is the BBJ_CALLFINALLYRET of a
         // BBJ_CALLFINALLY/BBJ_CALLFINALLYRET pair, then we can't add alignment
         // because we can't add instructions in that block. In the
-        // UsesCallfinallyThunks case, it would affect the reported EH, as above.
+        // UsesCallFinallyThunks case, it would affect the reported EH, as above.
         JITDUMP("Skipping alignment for " FMT_LP "; its top block follows a CALLFINALLY/ALWAYS pair\n",
                 loop->GetIndex());
         return false;
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
@@ -8229,7 +8229,7 @@ class Compiler
         return IsTargetAbi(CORINFO_NATIVEAOT_ABI);
     }
 
-    bool UsesCallfinallyThunks()
+    bool UsesCallFinallyThunks()
     {
         // Generate call-to-finally code in "thunks" in the enclosing EH region, protected by "cloned finally" clauses.
         return UsesFunclets();
@@ -8240,7 +8240,7 @@ class Compiler
         return true;
     }
 
-    bool UsesCallfinallyThunks()
+    bool UsesCallFinallyThunks()
     {
         return true;
     }
diff --git a/src/coreclr/jit/fgdiagnostic.cpp b/src/coreclr/jit/fgdiagnostic.cpp
@@ -3166,7 +3166,7 @@ void Compiler::fgDebugCheckBBlist(bool checkBBNum /* = false */, bool checkBBRef
                 //    try {
                 //        try {
                 //            LEAVE L_OUTER; // this becomes a branch to a BBJ_CALLFINALLY in an outer try region
-                //                           // (in the UsesCallfinallyThunks case)
+                //                           // (in the UsesCallFinallyThunks case)
                 //        } catch {
                 //        }
                 //    } finally {
@@ -3177,7 +3177,7 @@ void Compiler::fgDebugCheckBBlist(bool checkBBNum /* = false */, bool checkBBRef
                 if (ehDsc->ebdTryBeg == succBlock)
                 {
                     // The BBJ_CALLFINALLY is the first block of it's `try` region. Don't check the predecessor.
-                    // Note that this case won't occur in the UsesCallfinallyThunks case, since the
+                    // Note that this case won't occur in the UsesCallFinallyThunks case, since the
                     // BBJ_CALLFINALLY in that case won't exist in the `try` region of the `finallyIndex`.
                 }
                 else
diff --git a/src/coreclr/jit/fgehopt.cpp b/src/coreclr/jit/fgehopt.cpp
@@ -350,7 +350,7 @@ PhaseStatus Compiler::fgRemoveEmptyTry()
             continue;
         }
 
-        if (UsesCallfinallyThunks())
+        if (UsesCallFinallyThunks())
         {
             // Look for blocks that are always jumps to a call finally
             // pair that targets the finally
@@ -796,7 +796,7 @@ PhaseStatus Compiler::fgCloneFinally()
         {
             BasicBlock* jumpDest = nullptr;
 
-            if (UsesCallfinallyThunks())
+            if (UsesCallFinallyThunks())
             {
                 // Blocks that transfer control to callfinallies are usually
                 // BBJ_ALWAYS blocks, but the last block of a try may fall
@@ -883,7 +883,7 @@ PhaseStatus Compiler::fgCloneFinally()
                 isUpdate                = true;
             }
 
-            if (UsesCallfinallyThunks())
+            if (UsesCallFinallyThunks())
             {
                 // When there are callfinally thunks, we don't expect to see the
                 // callfinally within a handler region either.
@@ -1345,7 +1345,7 @@ void Compiler::fgDebugCheckTryFinallyExits()
                 // logically "belong" to a child region and the exit
                 // path validity will be checked when looking at the
                 // try blocks in that region.
-                if (UsesCallfinallyThunks() && block->KindIs(BBJ_CALLFINALLY))
+                if (UsesCallFinallyThunks() && block->KindIs(BBJ_CALLFINALLY))
                 {
                     continue;
                 }
@@ -1367,12 +1367,12 @@ void Compiler::fgDebugCheckTryFinallyExits()
                 // (e) via an always jump clonefinally exit
                 bool isCallToFinally = false;
 
-                if (UsesCallfinallyThunks() && succBlock->KindIs(BBJ_CALLFINALLY))
+                if (UsesCallFinallyThunks() && succBlock->KindIs(BBJ_CALLFINALLY))
                 {
                     // case (a1)
                     isCallToFinally = isFinally && succBlock->TargetIs(finallyBlock);
                 }
-                else if (!UsesCallfinallyThunks() && block->KindIs(BBJ_CALLFINALLY))
+                else if (!UsesCallFinallyThunks() && block->KindIs(BBJ_CALLFINALLY))
                 {
                     // case (a2)
                     isCallToFinally = isFinally && block->TargetIs(finallyBlock);
@@ -1533,7 +1533,7 @@ PhaseStatus Compiler::fgMergeFinallyChains()
     }
 #endif // FEATURE_EH_WINDOWS_X86
 
-    if (!UsesCallfinallyThunks())
+    if (!UsesCallFinallyThunks())
     {
         // For non-thunk EH models (x86) the callfinallys may contain
         // statements, and merging is not safe unless the callfinally
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
@@ -4729,7 +4729,7 @@ void Compiler::impImportLeave(BasicBlock* block)
 
             BasicBlock* callBlock;
 
-            if (step == nullptr && UsesCallfinallyThunks())
+            if (step == nullptr && UsesCallFinallyThunks())
             {
                 // Put the call to the finally in the enclosing region.
                 unsigned callFinallyTryIndex =
@@ -4762,7 +4762,7 @@ void Compiler::impImportLeave(BasicBlock* block)
                 }
 #endif
             }
-            else if (step == nullptr) // && !UsesCallfinallyThunks()
+            else if (step == nullptr) // && !UsesCallFinallyThunks()
             {
                 callBlock = block;
 
@@ -4801,7 +4801,7 @@ void Compiler::impImportLeave(BasicBlock* block)
                 assert(step->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET, BBJ_EHCATCHRET));
                 assert((step == block) || !step->HasInitializedTarget());
 
-                if (UsesCallfinallyThunks() && step->KindIs(BBJ_EHCATCHRET))
+                if (UsesCallFinallyThunks() && step->KindIs(BBJ_EHCATCHRET))
                 {
                     // Need to create another step block in the 'try' region that will actually branch to the
                     // call-to-finally thunk.
@@ -4837,7 +4837,7 @@ void Compiler::impImportLeave(BasicBlock* block)
                 unsigned callFinallyTryIndex;
                 unsigned callFinallyHndIndex;
 
-                if (UsesCallfinallyThunks())
+                if (UsesCallFinallyThunks())
                 {
                     callFinallyTryIndex = (HBtab->ebdEnclosingTryIndex == EHblkDsc::NO_ENCLOSING_INDEX)
                                               ? 0
diff --git a/src/coreclr/jit/jiteh.cpp b/src/coreclr/jit/jiteh.cpp
@@ -906,7 +906,7 @@ unsigned Compiler::ehGetCallFinallyRegionIndex(unsigned finallyIndex, bool* inTr
     assert(finallyIndex != EHblkDsc::NO_ENCLOSING_INDEX);
     assert(ehGetDsc(finallyIndex)->HasFinallyHandler());
 
-    if (UsesCallfinallyThunks())
+    if (UsesCallFinallyThunks())
     {
         return ehGetDsc(finallyIndex)->ebdGetEnclosingRegionIndex(inTryRegion);
     }
@@ -924,7 +924,7 @@ void Compiler::ehGetCallFinallyBlockRange(unsigned finallyIndex, BasicBlock** st
     assert(startBlock != nullptr);
     assert(lastBlock != nullptr);
 
-    if (UsesCallfinallyThunks())
+    if (UsesCallFinallyThunks())
     {
         bool     inTryRegion;
         unsigned callFinallyRegionIndex = ehGetCallFinallyRegionIndex(finallyIndex, &inTryRegion);
@@ -4039,7 +4039,7 @@ bool Compiler::fgIsIntraHandlerPred(BasicBlock* predBlock, BasicBlock* block)
 
     EHblkDsc* xtab = ehGetDsc(block->getHndIndex());
 
-    if (UsesCallfinallyThunks() && xtab->HasFinallyHandler())
+    if (UsesCallFinallyThunks() && xtab->HasFinallyHandler())
     {
         assert((xtab->ebdHndBeg == block) || // The normal case
                (xtab->ebdHndBeg->NextIs(block) &&
diff --git a/src/coreclr/jit/optimizer.cpp b/src/coreclr/jit/optimizer.cpp
@@ -3183,7 +3183,7 @@ bool Compiler::optCanonicalizeExit(FlowGraphNaturalLoop* loop, BasicBlock* exit)
     JITDUMP("Canonicalize exit " FMT_BB " for " FMT_LP " to have only loop predecessors\n", exit->bbNum,
             loop->GetIndex());
 
-    if (UsesCallfinallyThunks() && exit->KindIs(BBJ_CALLFINALLY))
+    if (UsesCallFinallyThunks() && exit->KindIs(BBJ_CALLFINALLY))
     {
         // Branches to a BBJ_CALLFINALLY _must_ come from inside its associated
         // try region, and when we have callfinally thunks the BBJ_CALLFINALLY

Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ void CodeGen::genMarkLabelsForCodegen()`
`412`	`412`	`case BBJ_CALLFINALLY:`
`413`	`413`	`// The finally target itself will get marked by walking the EH table, below, and marking`
`414`	`414`	`// all handler begins.`
`415`		`- if (compiler->UsesCallfinallyThunks())`
	`415`	`+ if (compiler->UsesCallFinallyThunks())`
`416`	`416`	`{`
`417`	`417`	`// For callfinally thunks, we need to mark the block following the callfinally/callfinallyret pair,`
`418`	`418`	`// as that's needed for identifying the range of the "duplicate finally" region in EH data.`
`@@ -2242,7 +2242,7 @@ void CodeGen::genReportEH()`
`2242`	`2242`	`unsigned clonedFinallyCount = 0;`
`2243`	`2243`
`2244`	`2244`	`// Duplicate clauses are not used by NativeAOT ABI`
`2245`		`- if (compiler->UsesFunclets() && compiler->UsesCallfinallyThunks() && !isNativeAOT)`
	`2245`	`+ if (compiler->UsesFunclets() && compiler->UsesCallFinallyThunks() && !isNativeAOT)`
`2246`	`2246`	`{`
`2247`	`2247`	`// We don't keep track of how many cloned finally there are. So, go through and count.`
`2248`	`2248`	`// We do a quick pass first through the EH table to see if there are any try/finally`
`@@ -2276,7 +2276,7 @@ void CodeGen::genReportEH()`
`2276`	`2276`	`{`
`2277`	`2277`	`if (compiler->UsesFunclets())`
`2278`	`2278`	`{`
`2279`		`- if (compiler->UsesCallfinallyThunks())`
	`2279`	`+ if (compiler->UsesCallFinallyThunks())`
`2280`	`2280`	`{`
`2281`	`2281`	`printf("%d EH table entries, %d duplicate clauses, %d cloned finallys, %d total EH entries reported to "`
`2282`	`2282`	`"VM\n",`
Original file line number	Diff line number	Diff line change
`@@ -8229,7 +8229,7 @@ class Compiler`
`8229`	`8229`	`return IsTargetAbi(CORINFO_NATIVEAOT_ABI);`
`8230`	`8230`	`}`
`8231`	`8231`
`8232`		`- bool UsesCallfinallyThunks()`
	`8232`	`+ bool UsesCallFinallyThunks()`
`8233`	`8233`	`{`
`8234`	`8234`	`// Generate call-to-finally code in "thunks" in the enclosing EH region, protected by "cloned finally" clauses.`
`8235`	`8235`	`return UsesFunclets();`
`@@ -8240,7 +8240,7 @@ class Compiler`
`8240`	`8240`	`return true;`
`8241`	`8241`	`}`
`8242`	`8242`
`8243`		`- bool UsesCallfinallyThunks()`
	`8243`	`+ bool UsesCallFinallyThunks()`
`8244`	`8244`	`{`
`8245`	`8245`	`return true;`
`8246`	`8246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ PhaseStatus Compiler::fgRemoveEmptyTry()`
`350`	`350`	`continue;`
`351`	`351`	`}`
`352`	`352`
`353`		`- if (UsesCallfinallyThunks())`
	`353`	`+ if (UsesCallFinallyThunks())`
`354`	`354`	`{`
`355`	`355`	`// Look for blocks that are always jumps to a call finally`
`356`	`356`	`// pair that targets the finally`
`@@ -796,7 +796,7 @@ PhaseStatus Compiler::fgCloneFinally()`
`796`	`796`	`{`
`797`	`797`	`BasicBlock* jumpDest = nullptr;`
`798`	`798`
`799`		`- if (UsesCallfinallyThunks())`
	`799`	`+ if (UsesCallFinallyThunks())`
`800`	`800`	`{`
`801`	`801`	`// Blocks that transfer control to callfinallies are usually`
`802`	`802`	`// BBJ_ALWAYS blocks, but the last block of a try may fall`
`@@ -883,7 +883,7 @@ PhaseStatus Compiler::fgCloneFinally()`
`883`	`883`	`isUpdate = true;`
`884`	`884`	`}`
`885`	`885`
`886`		`- if (UsesCallfinallyThunks())`
	`886`	`+ if (UsesCallFinallyThunks())`
`887`	`887`	`{`
`888`	`888`	`// When there are callfinally thunks, we don't expect to see the`
`889`	`889`	`// callfinally within a handler region either.`
`@@ -1345,7 +1345,7 @@ void Compiler::fgDebugCheckTryFinallyExits()`
`1345`	`1345`	`// logically "belong" to a child region and the exit`
`1346`	`1346`	`// path validity will be checked when looking at the`
`1347`	`1347`	`// try blocks in that region.`
`1348`		`- if (UsesCallfinallyThunks() && block->KindIs(BBJ_CALLFINALLY))`
	`1348`	`+ if (UsesCallFinallyThunks() && block->KindIs(BBJ_CALLFINALLY))`
`1349`	`1349`	`{`
`1350`	`1350`	`continue;`
`1351`	`1351`	`}`
`@@ -1367,12 +1367,12 @@ void Compiler::fgDebugCheckTryFinallyExits()`
`1367`	`1367`	`// (e) via an always jump clonefinally exit`
`1368`	`1368`	`bool isCallToFinally = false;`
`1369`	`1369`
`1370`		`- if (UsesCallfinallyThunks() && succBlock->KindIs(BBJ_CALLFINALLY))`
	`1370`	`+ if (UsesCallFinallyThunks() && succBlock->KindIs(BBJ_CALLFINALLY))`
`1371`	`1371`	`{`
`1372`	`1372`	`// case (a1)`
`1373`	`1373`	`isCallToFinally = isFinally && succBlock->TargetIs(finallyBlock);`
`1374`	`1374`	`}`
`1375`		`- else if (!UsesCallfinallyThunks() && block->KindIs(BBJ_CALLFINALLY))`
	`1375`	`+ else if (!UsesCallFinallyThunks() && block->KindIs(BBJ_CALLFINALLY))`
`1376`	`1376`	`{`
`1377`	`1377`	`// case (a2)`
`1378`	`1378`	`isCallToFinally = isFinally && block->TargetIs(finallyBlock);`
`@@ -1533,7 +1533,7 @@ PhaseStatus Compiler::fgMergeFinallyChains()`
`1533`	`1533`	`}`
`1534`	`1534`	`#endif // FEATURE_EH_WINDOWS_X86`
`1535`	`1535`
`1536`		`- if (!UsesCallfinallyThunks())`
	`1536`	`+ if (!UsesCallFinallyThunks())`
`1537`	`1537`	`{`
`1538`	`1538`	`// For non-thunk EH models (x86) the callfinallys may contain`
`1539`	`1539`	`// statements, and merging is not safe unless the callfinally`
Original file line number	Diff line number	Diff line change
`@@ -4729,7 +4729,7 @@ void Compiler::impImportLeave(BasicBlock* block)`
`4729`	`4729`
`4730`	`4730`	`BasicBlock* callBlock;`
`4731`	`4731`
`4732`		`- if (step == nullptr && UsesCallfinallyThunks())`
	`4732`	`+ if (step == nullptr && UsesCallFinallyThunks())`
`4733`	`4733`	`{`
`4734`	`4734`	`// Put the call to the finally in the enclosing region.`
`4735`	`4735`	`unsigned callFinallyTryIndex =`
`@@ -4762,7 +4762,7 @@ void Compiler::impImportLeave(BasicBlock* block)`
`4762`	`4762`	`}`
`4763`	`4763`	`#endif`
`4764`	`4764`	`}`
`4765`		`- else if (step == nullptr) // && !UsesCallfinallyThunks()`
	`4765`	`+ else if (step == nullptr) // && !UsesCallFinallyThunks()`
`4766`	`4766`	`{`
`4767`	`4767`	`callBlock = block;`
`4768`	`4768`
`@@ -4801,7 +4801,7 @@ void Compiler::impImportLeave(BasicBlock* block)`
`4801`	`4801`	`assert(step->KindIs(BBJ_ALWAYS, BBJ_CALLFINALLYRET, BBJ_EHCATCHRET));`
`4802`	`4802`	`assert((step == block) \|\| !step->HasInitializedTarget());`
`4803`	`4803`
`4804`		`- if (UsesCallfinallyThunks() && step->KindIs(BBJ_EHCATCHRET))`
	`4804`	`+ if (UsesCallFinallyThunks() && step->KindIs(BBJ_EHCATCHRET))`
`4805`	`4805`	`{`
`4806`	`4806`	`// Need to create another step block in the 'try' region that will actually branch to the`
`4807`	`4807`	`// call-to-finally thunk.`
`@@ -4837,7 +4837,7 @@ void Compiler::impImportLeave(BasicBlock* block)`
`4837`	`4837`	`unsigned callFinallyTryIndex;`
`4838`	`4838`	`unsigned callFinallyHndIndex;`
`4839`	`4839`
`4840`		`- if (UsesCallfinallyThunks())`
	`4840`	`+ if (UsesCallFinallyThunks())`
`4841`	`4841`	`{`
`4842`	`4842`	`callFinallyTryIndex = (HBtab->ebdEnclosingTryIndex == EHblkDsc::NO_ENCLOSING_INDEX)`
`4843`	`4843`	`? 0`
Original file line number	Diff line number	Diff line change
`@@ -906,7 +906,7 @@ unsigned Compiler::ehGetCallFinallyRegionIndex(unsigned finallyIndex, bool* inTr`
`906`	`906`	`assert(finallyIndex != EHblkDsc::NO_ENCLOSING_INDEX);`
`907`	`907`	`assert(ehGetDsc(finallyIndex)->HasFinallyHandler());`
`908`	`908`
`909`		`- if (UsesCallfinallyThunks())`
	`909`	`+ if (UsesCallFinallyThunks())`
`910`	`910`	`{`
`911`	`911`	`return ehGetDsc(finallyIndex)->ebdGetEnclosingRegionIndex(inTryRegion);`
`912`	`912`	`}`
`@@ -924,7 +924,7 @@ void Compiler::ehGetCallFinallyBlockRange(unsigned finallyIndex, BasicBlock** st`
`924`	`924`	`assert(startBlock != nullptr);`
`925`	`925`	`assert(lastBlock != nullptr);`
`926`	`926`
`927`		`- if (UsesCallfinallyThunks())`
	`927`	`+ if (UsesCallFinallyThunks())`
`928`	`928`	`{`
`929`	`929`	`bool inTryRegion;`
`930`	`930`	`unsigned callFinallyRegionIndex = ehGetCallFinallyRegionIndex(finallyIndex, &inTryRegion);`
`@@ -4039,7 +4039,7 @@ bool Compiler::fgIsIntraHandlerPred(BasicBlock* predBlock, BasicBlock* block)`
`4039`	`4039`
`4040`	`4040`	`EHblkDsc* xtab = ehGetDsc(block->getHndIndex());`
`4041`	`4041`
`4042`		`- if (UsesCallfinallyThunks() && xtab->HasFinallyHandler())`
	`4042`	`+ if (UsesCallFinallyThunks() && xtab->HasFinallyHandler())`
`4043`	`4043`	`{`
`4044`	`4044`	`assert((xtab->ebdHndBeg == block) \|\| // The normal case`
`4045`	`4045`	`(xtab->ebdHndBeg->NextIs(block) &&`
Original file line number	Diff line number	Diff line change
`@@ -3183,7 +3183,7 @@ bool Compiler::optCanonicalizeExit(FlowGraphNaturalLoop* loop, BasicBlock* exit)`
`3183`	`3183`	`JITDUMP("Canonicalize exit " FMT_BB " for " FMT_LP " to have only loop predecessors\n", exit->bbNum,`
`3184`	`3184`	`loop->GetIndex());`
`3185`	`3185`
`3186`		`- if (UsesCallfinallyThunks() && exit->KindIs(BBJ_CALLFINALLY))`
	`3186`	`+ if (UsesCallFinallyThunks() && exit->KindIs(BBJ_CALLFINALLY))`
`3187`	`3187`	`{`
`3188`	`3188`	`// Branches to a BBJ_CALLFINALLY _must_ come from inside its associated`
`3189`	`3189`	`// try region, and when we have callfinally thunks the BBJ_CALLFINALLY`