ARM64 - Add GT_CHK_DIV_BY_ZERO

src/coreclr/jit/codegen.h

@@ -1382,6 +1382,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     void genCodeForBfiz(GenTreeOp* tree);
     void genCodeForAddEx(GenTreeOp* tree);
     void genCodeForCond(GenTreeOp* tree);
+    void genCodeForChkDivByZero(GenTreeOp* tree);
 #endif // TARGET_ARM64
 
 #if defined(FEATURE_EH_FUNCLETS)

src/coreclr/jit/codegenarm64.cpp

@@ -3169,10 +3169,6 @@ void CodeGen::genCodeForDivMod(GenTreeOp* tree)
 
         if (divisorOp->IsIntegralConst(0))
         {
-            // We unconditionally throw a divide by zero exception
-            genJumpToThrowHlpBlk(EJ_jmp, SCK_DIV_BY_ZERO);
-
-            // We still need to call genProduceReg
             genProduceReg(tree);
         }
         else // the divisor is not the constant zero
@@ -3202,12 +3198,6 @@ void CodeGen::genCodeForDivMod(GenTreeOp* tree)
                         checkDividend = false; // We statically know that the dividend is not -1
                     }
                 }
-                else // insert check for divison by zero
-                {
-                    // Check if the divisor is zero throw a DivideByZeroException
-                    emit->emitIns_R_I(INS_cmp, size, divisorReg, 0);
-                    genJumpToThrowHlpBlk(EJ_eq, SCK_DIV_BY_ZERO);
-                }
 
                 if (checkDividend)
                 {
@@ -3234,19 +3224,6 @@ void CodeGen::genCodeForDivMod(GenTreeOp* tree)
             }
             else // (tree->gtOper == GT_UDIV)
             {
-                // Only one possible exception
-                //     (AnyVal /  0) => DivideByZeroException
-                //
-                // Note that division by the constant 0 was already checked for above by the
-                // op2->IsIntegralConst(0) check
-                //
-                if (!divisorOp->IsCnsIntOrI())
-                {
-                    // divisorOp is not a constant, so it could be zero
-                    //
-                    emit->emitIns_R_I(INS_cmp, size, divisorReg, 0);
-                    genJumpToThrowHlpBlk(EJ_eq, SCK_DIV_BY_ZERO);
-                }
                 genCodeForBinary(tree);
             }
         }
@@ -10213,4 +10190,22 @@ void CodeGen::genCodeForCond(GenTreeOp* tree)
     genProduceReg(tree);
 }
 
+//------------------------------------------------------------------------
+// genCodeForChkDivByZero: Generates the code for checking
+//                         if a value is zero to throw a div-by-zero exception.
+//
+// Arguments:
+//    tree - divide-by-zero check
+//
+void CodeGen::genCodeForChkDivByZero(GenTreeOp* tree)
+{
+    assert(tree->OperIs(GT_CHK_DIV_BY_ZERO));
+    genConsumeOperands(tree->AsOp());
+
+    GenTree* op1 = tree->gtGetOp1();
+
+    GetEmitter()->emitIns_R_I(INS_cmp, emitActualTypeSize(op1->TypeGet()), op1->GetRegNum(), 0);
+    genJumpToThrowHlpBlk(EJ_eq, SCK_DIV_BY_ZERO);
+}
+
 #endif // TARGET_ARM64

src/coreclr/jit/codegenarmarch.cpp

@@ -302,6 +302,10 @@ void CodeGen::genCodeForTreeNode(GenTree* treeNode)
             break;
 
 #ifdef TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+            genCodeForChkDivByZero(treeNode->AsOp());
+            break;
+
         case GT_INC_SATURATE:
             genCodeForIncSaturate(treeNode);
             break;

src/coreclr/jit/compiler.h

@@ -10727,6 +10727,9 @@ class GenTreeVisitor
             case GT_ARR_ADDR:
             case GT_KEEPALIVE:
             case GT_INC_SATURATE:
+#ifdef TARGET_ARM64
+            case GT_CHK_DIV_BY_ZERO:
+#endif
             {
                 GenTreeUnOp* const unOp = node->AsUnOp();
                 if (unOp->gtOp1 != nullptr)

src/coreclr/jit/compiler.hpp

@@ -4271,6 +4271,9 @@ void GenTree::VisitOperands(TVisitor visitor)
         case GT_RETURNTRAP:
         case GT_KEEPALIVE:
         case GT_INC_SATURATE:
+#ifdef TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+#endif
             visitor(this->AsUnOp()->gtOp1);
             return;
 

src/coreclr/jit/gentree.cpp

@@ -5099,6 +5099,13 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
                 costSz = 7; // jump to cold section
                 break;
 
+#ifdef TARGET_ARM64
+            case GT_CHK_DIV_BY_ZERO:
+                costEx = 4;
+                costSz = 7;
+                break;
+#endif
+
             case GT_COMMA:
 
                 /* Comma tosses the result of the left operand */
@@ -5895,6 +5902,9 @@ bool GenTree::TryGetUse(GenTree* operand, GenTree*** pUse)
         case GT_BSWAP16:
         case GT_KEEPALIVE:
         case GT_INC_SATURATE:
+#ifdef TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+#endif
             if (operand == this->AsUnOp()->gtOp1)
             {
                 *pUse = &this->AsUnOp()->gtOp1;
@@ -6402,6 +6412,9 @@ bool GenTree::OperMayThrow(Compiler* comp)
         case GT_CKFINITE:
         case GT_INDEX:
         case GT_INDEX_ADDR:
+#ifdef TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+#endif
             return true;
 
 #ifdef FEATURE_HW_INTRINSICS
@@ -8340,6 +8353,13 @@ GenTree* Compiler::gtCloneExpr(
                 copy->AsBoundsChk()->gtInxType      = tree->AsBoundsChk()->gtInxType;
                 break;
 
+#ifdef TARGET_ARM64
+            case GT_CHK_DIV_BY_ZERO:
+                copy = new (this, GT_CHK_DIV_BY_ZERO)
+                    GenTreeOp(GT_CHK_DIV_BY_ZERO, tree->TypeGet(), tree->AsOp()->gtOp1, nullptr);
+                break;
+#endif
+
             case GT_LEA:
             {
                 GenTreeAddrMode* addrModeOp = tree->AsAddrMode();
@@ -9120,6 +9140,9 @@ GenTreeUseEdgeIterator::GenTreeUseEdgeIterator(GenTree* node)
         case GT_PUTARG_SPLIT:
 #endif // FEATURE_ARG_SPLIT
         case GT_RETURNTRAP:
+#if TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+#endif
             m_edge = &m_node->AsUnOp()->gtOp1;
             assert(*m_edge != nullptr);
             m_advance = &GenTreeUseEdgeIterator::Terminate;

src/coreclr/jit/gtlist.h

@@ -80,6 +80,10 @@ GTNODE(ADDR             , GenTreeOp          ,0,GTK_UNOP|DBK_NOTLIR)    // addre
 
 GTNODE(BOUNDS_CHECK     , GenTreeBoundsChk   ,0,GTK_BINOP|GTK_EXOP|GTK_NOVALUE) // a bounds check - for arrays/spans/SIMDs/HWINTRINSICs
 
+#ifdef TARGET_ARM64
+GTNODE(CHK_DIV_BY_ZERO  , GenTreeOp          ,0,GTK_UNOP|GTK_NOVALUE) // a divide-by-zero check - for integers
+#endif
+
 GTNODE(IND              , GenTreeIndir       ,0,GTK_UNOP)                       // Load indirection
 GTNODE(STOREIND         , GenTreeStoreInd    ,0,GTK_BINOP|GTK_NOVALUE)          // Store indirection
 GTNODE(OBJ              , GenTreeObj         ,0,GTK_UNOP|GTK_EXOP)              // Object that MAY have gc pointers, and thus includes the relevant gc layout info.

src/coreclr/jit/importer.cpp

@@ -14025,6 +14025,24 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     }
                 }
 
+#if defined(TARGET_ARM64)
+                if ((oper == GT_DIV || oper == GT_UDIV || oper == GT_MOD || oper == GT_UMOD) &&
+                    !varTypeIsFloating(type) && (!op2->IsIntegralConst() || op2->IsIntegralConst(0)))
+                {
+                    unsigned tmpNum       = lvaGrabTemp(true DEBUGARG("divisor expr"));
+                    GenTree* divisorAsg   = gtNewTempAssign(tmpNum, op2);
+                    GenTree* divisor      = gtNewLclvNode(tmpNum, op2->TypeGet());
+                    GenTree* chkDivByZero =
+                        new (this, GT_CHK_DIV_BY_ZERO) GenTreeOp(GT_CHK_DIV_BY_ZERO, TYP_VOID, divisor, nullptr);
+
+                    chkDivByZero->gtFlags |= GTF_SIDE_EFFECT;
+
+                    op2 =
+                        gtNewOperNode(GT_COMMA, divisor->TypeGet(), divisorAsg,
+                                      gtNewOperNode(GT_COMMA, divisor->TypeGet(), chkDivByZero, gtCloneExpr(divisor)));
+                }
+#endif
+
                 // We can generate a TYP_FLOAT operation that has a TYP_DOUBLE operand
                 //
                 if (varTypeIsFloating(type) && varTypeIsFloating(op1->gtType) && varTypeIsFloating(op2->gtType))

src/coreclr/jit/liveness.cpp

@@ -2069,6 +2069,9 @@ void Compiler::fgComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VARSET_VALAR
             case GT_JMP:
             case GT_STOREIND:
             case GT_BOUNDS_CHECK:
+#ifdef TARGET_ARM64
+            case GT_CHK_DIV_BY_ZERO:
+#endif
             case GT_STORE_OBJ:
             case GT_STORE_BLK:
             case GT_STORE_DYN_BLK:

src/coreclr/jit/morph.cpp

@@ -11538,6 +11538,13 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac)
             fgSetRngChkTarget(tree);
             break;
 
+#ifdef TARGET_ARM64
+        case GT_CHK_DIV_BY_ZERO:
+            assert(!varTypeIsFloating(op1));
+            fgAddCodeRef(compCurBB, bbThrowIndex(compCurBB), SCK_DIV_BY_ZERO);
+            break;
+#endif
+
         case GT_OBJ:
         case GT_BLK:
         case GT_IND:

src/coreclr/jit/valuenum.cpp

@@ -10795,6 +10795,12 @@ void Compiler::fgValueNumberAddExceptionSet(GenTree* tree)
                 fgValueNumberAddExceptionSetForBoundsCheck(tree);
                 break;
 
+#ifdef TARGET_ARM64
+            case GT_CHK_DIV_BY_ZERO:
+                // TODO: Add impl
+                break;
+#endif
+
             case GT_LCLHEAP:
                 // It is not necessary to model the StackOverflow exception for GT_LCLHEAP
                 break;