Insert checks in a later phase

Author: EgorBo

src/coreclr/jit/compiler.cpp

@@ -5026,6 +5026,10 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
     compQuirkForPPPflag = compQuirkForPPP();
 #endif
 
+    // Insert quick "is class statically initialized" checks in front of
+    // static init helper calls
+    DoPhase(this, PHASE_INSERT_STATINIT_CHECKS, &Compiler::fgInsertClsInitChecks);
+
     // Insert GC Polls
     DoPhase(this, PHASE_INSERT_GC_POLLS, &Compiler::fgInsertGCPolls);
 

src/coreclr/jit/compiler.h

@@ -5184,6 +5184,8 @@ class Compiler
     PhaseStatus fgInsertGCPolls();
     BasicBlock* fgCreateGCPoll(GCPollType pollType, BasicBlock* block);
 
+    PhaseStatus fgInsertClsInitChecks();
+
     // Requires that "block" is a block that returns from
     // a finally.  Returns the number of successors (jump targets of
     // of blocks in the covered "try" that did a "LEAVE".)

src/coreclr/jit/compphases.h

@@ -89,6 +89,7 @@ CompPhaseNameMacro(PHASE_ASSERTION_PROP_MAIN,    "Assertion prop",
 #endif
 CompPhaseNameMacro(PHASE_OPT_UPDATE_FLOW_GRAPH,  "Update flow graph opt pass",     "UPD-FG-O", false, -1, false)
 CompPhaseNameMacro(PHASE_COMPUTE_EDGE_WEIGHTS2,  "Compute edge weights (2, false)",       "EDG-WGT2", false, -1, false)
+CompPhaseNameMacro(PHASE_INSERT_STATINIT_CHECKS, "Insert is-cls-stat-init Checks", "CLSSICHK", false, -1, true)
 CompPhaseNameMacro(PHASE_INSERT_GC_POLLS,        "Insert GC Polls",                "GC-POLLS", false, -1, true)
 CompPhaseNameMacro(PHASE_DETERMINE_FIRST_COLD_BLOCK, "Determine first cold block", "COLD-BLK", false, -1, true)
 CompPhaseNameMacro(PHASE_RATIONALIZE,            "Rationalize IR",                 "RAT",      false, -1, false)

src/coreclr/jit/flowgraph.cpp

@@ -52,6 +52,133 @@ static bool blockNeedsGCPoll(BasicBlock* block)
     return blockMayNeedGCPoll;
 }
 
+//------------------------------------------------------------------------------
+// fgInsertClsInitChecks : Wraps static init helper calls with "is class statically initialized"
+//                         inlined checks.
+//
+// Returns:
+//    PhaseStatus indicating what, if anything, was changed.
+//
+
+PhaseStatus Compiler::fgInsertClsInitChecks()
+{
+
+    if (!strcmp(info.compMethodName, "Test"))
+    {
+        fgDispBasicBlocks(true);
+    }
+
+    if (!opts.OptimizationEnabled())
+    {
+        return PhaseStatus::MODIFIED_NOTHING;
+    }
+
+    bool        modified = false;
+    BasicBlock* block;
+    for (block = fgFirstBB; block; block = block->bbNext)
+    {
+        if (!block->isRunRarely() && block->bbFlags)
+        {
+            for (Statement* stmt : block->Statements())
+            {
+                for (GenTree* tree = stmt->GetTreeList(); tree != nullptr; tree = tree->gtNext)
+                {
+                    if (!tree->IsCall())
+                    {
+                        continue;
+                    }
+
+                    GenTreeCall* call = tree->AsCall();
+                    if (call->gtCallType != CT_HELPER)
+                    {
+                        continue;
+                    }
+
+                    CorInfoHelpFunc helpFunc = eeGetHelperNum(call->gtCallMethHnd);
+                    if (helpFunc != CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE)
+                    {
+                        continue;
+                    }
+
+                    GenTree* moduleIdArg = call->LateArgs().begin()->GetNode();
+                    GenTree* clsIdArg    = call->LateArgs().begin()->GetNext()->GetNode();
+
+                    if (!moduleIdArg->IsCnsIntOrI() || !clsIdArg->IsCnsIntOrI())
+                    {
+                        // Looks like moduleId or/and clsId were passed as indirect loads
+                        continue;
+                    }
+
+                    //
+                    //  *  JTRUE     void
+                    //  \--*  NE        int
+                    //     +--*  AND       int
+                    //     |  +--*  IND       ubyte
+                    //     |  |  \--*  CNS_INT   long   moduleIdArg + clsIdArg + dataBlobOffset
+                    //     |  \--*  CNS_INT   int    isInitMask
+                    //     \--*  CNS_INT   int    0
+                    //
+                    //  *  CALL help long   HELPER.CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE
+                    //  +--*  CNS_INT   long   moduleIdArg
+                    //  \--*  CNS_INT   int    clsIdArg
+                    //
+                                       
+                    BasicBlock* callInitBb = fgNewBBbefore(BBJ_NONE, block, true);
+                    fgAddRefPred(block, callInitBb);
+                    callInitBb->bbSetRunRarely();
+                    callInitBb->bbFlags |= block->bbFlags & (BBF_SPLIT_GAINED | BBF_IMPORTED | BBF_HAS_CALL);
+
+                    GenTree* clonedHelperCall = gtCloneExprCallHelper(call);
+                    clonedHelperCall->gtFlags |= call->gtFlags;
+                    fgInsertStmtAtEnd(callInitBb, fgNewStmtFromTree(clonedHelperCall));
+
+                    BasicBlock* isInitedBb = fgNewBBbefore(BBJ_COND, callInitBb, true);
+                    fgAddRefPred(callInitBb, isInitedBb);
+                    fgAddRefPred(block, isInitedBb);
+                    isInitedBb->inheritWeight(block);
+                    isInitedBb->bbFlags |= block->bbFlags & (BBF_SPLIT_GAINED | BBF_IMPORTED | BBF_HAS_CALL);
+
+                    // TODO: ask VM for these constants:
+                    const int dataBlobOffset = 48;
+                    const int isInitMask     = 1;
+
+                    size_t   address = moduleIdArg->AsIntCon()->IconValue() + dataBlobOffset + clsIdArg->AsIntCon()->IconValue();
+                    GenTree* indir   = gtNewIndir(TYP_UBYTE, gtNewIconNode(address, TYP_I_IMPL));
+                    indir->gtFlags = (GTF_IND_NONFAULTING | GTF_IND_INVARIANT);
+
+                    GenTree* isInitedMask = gtNewOperNode(GT_AND, TYP_INT, indir, gtNewIconNode(isInitMask));
+                    GenTree* isInitedCmp  = gtNewOperNode(GT_NE, TYP_INT, isInitedMask, gtNewIconNode(0));
+
+                    fgInsertStmtAtEnd(isInitedBb, fgNewStmtFromTree(gtNewOperNode(GT_JTRUE, TYP_VOID, isInitedCmp)));
+                    isInitedBb->bbJumpDest = block;
+                    gtReplaceTree(stmt, call, gtNewNothingNode());
+
+
+                    modified = true;
+                }
+                if (modified)
+                {
+                    // clear GTF_CALL and GTF_EXC flags
+                    gtUpdateStmtSideEffects(stmt);
+                }
+            }
+        }
+    }
+
+    if (!strcmp(info.compMethodName, "Test"))
+    {
+        fgDispBasicBlocks(true);
+    }
+
+    if (modified)
+    {
+        fgReorderBlocks();
+        fgUpdateChangedFlowGraph(false);
+        return PhaseStatus::MODIFIED_EVERYTHING;
+    }
+    return PhaseStatus::MODIFIED_NOTHING;
+}
+
 //------------------------------------------------------------------------------
 // fgInsertGCPolls : Insert GC polls for basic blocks containing calls to methods
 //                   with SuppressGCTransitionAttribute.