JIT: Remove GT_NULLCHECK

Previously the JIT had two ways of representing null checks, either
through GT_NULLCHECK or through any indirection node with an unused
value. This is somewhat problematic since early prop supports only the
former while CSE supports only the latter, so converting between them
always results in improvements and regressions.

To alleviate the problem remove GT_NULLCHECK entirely and switch to
unused indirections to represent null checks. Add the necessary support
for efficient codegen for these to the backend, and add support for
early prop to recognize and fold these away.

src/coreclr/jit/assertionprop.cpp

@@ -2697,11 +2697,6 @@ void Compiler::optAssertionGen(GenTree* tree)
             assertionInfo = optCreateAssertion(tree->AsArrCommon()->ArrRef(), nullptr, OAK_NOT_EQUAL);
             break;
 
-        case GT_NULLCHECK:
-            // Explicit null checks always create non-null assertions.
-            assertionInfo = optCreateAssertion(tree->AsIndir()->Addr(), nullptr, OAK_NOT_EQUAL);
-            break;
-
         case GT_INTRINSIC:
             if (tree->AsIntrinsic()->gtIntrinsicName == NI_System_Object_GetType)
             {
@@ -4935,7 +4930,6 @@ GenTree* Compiler::optAssertionProp(ASSERT_VALARG_TP assertions, GenTree* tree,
         case GT_OBJ:
         case GT_BLK:
         case GT_IND:
-        case GT_NULLCHECK:
         case GT_STORE_DYN_BLK:
             return optAssertionProp_Ind(assertions, tree, stmt);
 

src/coreclr/jit/codegen.h

@@ -1268,6 +1268,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     void genCodeForLclAddr(GenTreeLclVarCommon* lclAddrNode);
     void genCodeForIndexAddr(GenTreeIndexAddr* tree);
     void genCodeForIndir(GenTreeIndir* tree);
+    void genEmitCodeForUnusedIndir(GenTreeIndir* tree);
     void genCodeForNegNot(GenTree* tree);
     void genCodeForBswap(GenTree* tree);
     bool genCanOmitNormalizationForBswap16(GenTree* tree);
@@ -1285,7 +1286,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     void genCodeForCpBlkHelper(GenTreeBlk* cpBlkNode);
 #endif
     void genCodeForPhysReg(GenTreePhysReg* tree);
-    void genCodeForNullCheck(GenTreeIndir* tree);
     void genCodeForCmpXchg(GenTreeCmpXchg* tree);
 
     void genAlignStackBeforeCall(GenTreePutArgStk* putArgStk);

src/coreclr/jit/codegenarmarch.cpp

@@ -485,10 +485,6 @@ void CodeGen::genCodeForTreeNode(GenTree* treeNode)
             genCodeForPhysReg(treeNode->AsPhysReg());
             break;
 
-        case GT_NULLCHECK:
-            genCodeForNullCheck(treeNode->AsIndir());
-            break;
-
         case GT_CATCH_ARG:
 
             noway_assert(handlerGetsXcptnObj(compiler->compCurBB->bbCatchTyp));
@@ -1458,30 +1454,6 @@ void CodeGen::genCodeForPhysReg(GenTreePhysReg* tree)
     genProduceReg(tree);
 }
 
-//---------------------------------------------------------------------
-// genCodeForNullCheck - generate code for a GT_NULLCHECK node
-//
-// Arguments
-//    tree - the GT_NULLCHECK node
-//
-// Return value:
-//    None
-//
-void CodeGen::genCodeForNullCheck(GenTreeIndir* tree)
-{
-#ifdef TARGET_ARM
-    assert(!"GT_NULLCHECK isn't supported for Arm32; use GT_IND.");
-#else
-    assert(tree->OperIs(GT_NULLCHECK));
-    GenTree* op1 = tree->gtOp1;
-
-    genConsumeRegs(op1);
-    regNumber targetReg = REG_ZR;
-
-    GetEmitter()->emitInsLoadStoreOp(ins_Load(tree->TypeGet()), emitActualTypeSize(tree), targetReg, tree);
-#endif
-}
-
 //------------------------------------------------------------------------
 // genCodeForArrIndex: Generates code to bounds check the index for one dimension of an array reference,
 //                     producing the effective index by subtracting the lower bound.
@@ -1775,9 +1747,13 @@ void CodeGen::genCodeForIndir(GenTreeIndir* tree)
     }
 #endif // FEATURE_SIMD
 
-    var_types   type      = tree->TypeGet();
-    instruction ins       = ins_Load(type);
-    regNumber   targetReg = tree->GetRegNum();
+    var_types   type = tree->TypeGet();
+    instruction ins  = ins_Load(type);
+#ifdef TARGET_ARM64
+    regNumber targetReg = tree->IsUnusedValue() ? REG_ZR : tree->GetRegNum();
+#else
+    regNumber targetReg = tree->GetRegNum();
+#endif
 
     genConsumeAddress(tree->Addr());
 

src/coreclr/jit/codegenloongarch64.cpp

@@ -5574,10 +5574,6 @@ void CodeGen::genCodeForTreeNode(GenTree* treeNode)
             genCodeForPhysReg(treeNode->AsPhysReg());
             break;
 
-        case GT_NULLCHECK:
-            genCodeForNullCheck(treeNode->AsIndir());
-            break;
-
         case GT_CATCH_ARG:
 
             noway_assert(handlerGetsXcptnObj(compiler->compCurBB->bbCatchTyp));
@@ -6423,24 +6419,6 @@ void CodeGen::genCodeForPhysReg(GenTreePhysReg* tree)
     genProduceReg(tree);
 }
 
-//---------------------------------------------------------------------
-// genCodeForNullCheck - generate code for a GT_NULLCHECK node
-//
-// Arguments
-//    tree - the GT_NULLCHECK node
-//
-// Return value:
-//    None
-//
-void CodeGen::genCodeForNullCheck(GenTreeIndir* tree)
-{
-    assert(tree->OperIs(GT_NULLCHECK));
-
-    genConsumeRegs(tree->gtOp1);
-
-    GetEmitter()->emitInsLoadStoreOp(ins_Load(tree->TypeGet()), emitActualTypeSize(tree), REG_R0, tree);
-}
-
 //------------------------------------------------------------------------
 // genCodeForArrIndex: Generates code to bounds check the index for one dimension of an array reference,
 //                     producing the effective index by subtracting the lower bound.
@@ -6760,7 +6738,7 @@ void CodeGen::genCodeForIndir(GenTreeIndir* tree)
     var_types   type      = tree->TypeGet();
     instruction ins       = ins_Load(type);
     instruction ins2      = INS_none;
-    regNumber   targetReg = tree->GetRegNum();
+    regNumber   targetReg = tree->IsUnusedValue() ? REG_R0 : tree->GetRegNum();
     regNumber   tmpReg    = targetReg;
     emitAttr    attr      = emitActualTypeSize(type);
     int         offset    = 0;

src/coreclr/jit/codegenxarch.cpp

@@ -1862,10 +1862,6 @@ void CodeGen::genCodeForTreeNode(GenTree* treeNode)
             genCodeForPhysReg(treeNode->AsPhysReg());
             break;
 
-        case GT_NULLCHECK:
-            genCodeForNullCheck(treeNode->AsIndir());
-            break;
-
         case GT_CATCH_ARG:
 
             noway_assert(handlerGetsXcptnObj(compiler->compCurBB->bbCatchTyp));
@@ -4205,24 +4201,6 @@ void CodeGen::genCodeForPhysReg(GenTreePhysReg* tree)
     genProduceReg(tree);
 }
 
-//---------------------------------------------------------------------
-// genCodeForNullCheck - generate code for a GT_NULLCHECK node
-//
-// Arguments
-//    tree - the GT_NULLCHECK node
-//
-// Return value:
-//    None
-//
-void CodeGen::genCodeForNullCheck(GenTreeIndir* tree)
-{
-    assert(tree->OperIs(GT_NULLCHECK));
-
-    assert(tree->gtOp1->isUsedFromReg());
-    regNumber reg = genConsumeReg(tree->gtOp1);
-    GetEmitter()->emitIns_AR_R(INS_cmp, emitTypeSize(tree), reg, reg, 0);
-}
-
 //------------------------------------------------------------------------
 // genCodeForArrIndex: Generates code to bounds check the index for one dimension of an array reference,
 //                     producing the effective index by subtracting the lower bound.
@@ -5115,13 +5093,51 @@ void CodeGen::genCodeForIndir(GenTreeIndir* tree)
     else
     {
         genConsumeAddress(addr);
-        instruction loadIns = tree->DontExtend() ? INS_mov : ins_Load(targetType);
-        emit->emitInsLoadInd(loadIns, emitTypeSize(tree), tree->GetRegNum(), tree);
+
+        if (tree->IsUnusedValue())
+        {
+            genEmitCodeForUnusedIndir(tree);
+        }
+        else
+        {
+            instruction loadIns = tree->DontExtend() ? INS_mov : ins_Load(targetType);
+            emit->emitInsLoadInd(loadIns, emitTypeSize(tree), tree->GetRegNum(), tree);
+        }
     }
 
     genProduceReg(tree);
 }
 
+//---------------------------------------------------------------------
+// genEmitCodeForUnusedIndir - emit code for an unused indirection
+//
+// Arguments
+//    tree - the indirection
+//
+// Return value:
+//    None
+//
+void CodeGen::genEmitCodeForUnusedIndir(GenTreeIndir* tree)
+{
+    GenTree* addr = tree->Addr();
+    if (!addr->isContained())
+    {
+        GetEmitter()->emitIns_AR_R(INS_cmp, emitTypeSize(tree), addr->GetRegNum(), addr->GetRegNum(), 0);
+        return;
+    }
+
+    if (addr->OperIsLocalAddr())
+    {
+        GenTreeLclVarCommon* varNode = addr->AsLclVarCommon();
+        unsigned             offset  = varNode->GetLclOffs();
+        GetEmitter()->emitIns_S_R(INS_cmp, emitTypeSize(tree), REG_EAX, varNode->GetLclNum(), offset);
+        return;
+    }
+
+    assert(addr->OperIsAddrMode() || addr->IsCnsIntOrI());
+    GetEmitter()->emitIns_R_A(INS_cmp, emitTypeSize(tree), REG_EAX, tree);
+}
+
 //------------------------------------------------------------------------
 // genCodeForStoreInd: Produce code for a GT_STOREIND node.
 //

src/coreclr/jit/compiler.cpp

@@ -10027,7 +10027,7 @@ var_types Compiler::gtTypeForNullCheck(GenTree* tree)
 void Compiler::gtChangeOperToNullCheck(GenTree* tree, BasicBlock* block)
 {
     assert(tree->OperIs(GT_FIELD, GT_IND, GT_OBJ, GT_BLK));
-    tree->ChangeOper(GT_NULLCHECK);
+    tree->ChangeOper(GT_IND);
     tree->ChangeType(gtTypeForNullCheck(tree));
     block->bbFlags |= BBF_HAS_NULLCHECK;
     optMethodFlags |= OMF_HAS_NULLCHECK;

src/coreclr/jit/compiler.h

@@ -10818,7 +10818,6 @@ class GenTreeVisitor
             case GT_INIT_VAL:
             case GT_JTRUE:
             case GT_SWITCH:
-            case GT_NULLCHECK:
             case GT_PUTARG_REG:
             case GT_PUTARG_STK:
             case GT_RETURNTRAP:

src/coreclr/jit/compiler.hpp

@@ -1300,12 +1300,11 @@ inline GenTreeIndir* Compiler::gtNewIndir(var_types typ, GenTree* addr)
 //    basicBlock  -  Basic block of the node
 //
 // Return Value:
-//    New GT_NULLCHECK node
-
+//    New GT_IND node
 inline GenTree* Compiler::gtNewNullCheck(GenTree* addr, BasicBlock* basicBlock)
 {
     assert(fgAddrCouldBeNull(addr));
-    GenTree* nullCheck = gtNewOperNode(GT_NULLCHECK, TYP_BYTE, addr);
+    GenTree* nullCheck = gtNewOperNode(GT_IND, TYP_BYTE, addr);
     nullCheck->gtFlags |= GTF_EXCEPT;
     basicBlock->bbFlags |= BBF_HAS_NULLCHECK;
     optMethodFlags |= OMF_HAS_NULLCHECK;
@@ -4245,7 +4244,6 @@ void GenTree::VisitOperands(TVisitor visitor)
         case GT_ARR_ADDR:
         case GT_JTRUE:
         case GT_SWITCH:
-        case GT_NULLCHECK:
         case GT_PUTARG_REG:
         case GT_PUTARG_STK:
 #if FEATURE_ARG_SPLIT