Handle various edge cases that were technically UB

tannergooding · tannergooding · commit 4188648508cb · 2026-05-17T20:41:06.000-07:00
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
@@ -14985,7 +14985,7 @@ GenTree* Compiler::gtFoldExpr(GenTree* tree)
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprUnary: see if an unary operation is foldable
+// gtFoldExprUnary: see if a unary operation is foldable
 //
 // Arguments:
 //    tree - tree to examine
@@ -16964,7 +16964,7 @@ GenTree* Compiler::gtFoldExprConst(GenTree* tree)
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprUnaryConst: see if an unary const operation is foldable
+// gtFoldExprUnaryConst: see if a unary const operation is foldable
 //
 // Arguments:
 //    tree - tree to examine
@@ -17013,7 +17013,7 @@ GenTree* Compiler::gtFoldExprUnaryConst(GenTreeUnOp* tree)
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprUnaryConst: see if an unary const operation for TYP_INT is foldable
+// gtFoldExprUnaryConst: see if a unary const operation for TYP_INT is foldable
 //
 // Arguments:
 //    tree   - tree to examine
@@ -17050,14 +17050,15 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int
 
         case GT_NEG:
         {
-            iconVal = -iconVal;
+            iconVal = static_cast<int32_t>(0 - static_cast<uint32_t>(iconVal));
             break;
         }
 
         case GT_BSWAP:
         {
-            iconVal = ((iconVal >> 24) & 0xFF) | ((iconVal >> 8) & 0xFF00) | ((iconVal << 8) & 0xFF0000) |
-                      ((iconVal << 24) & 0xFF000000);
+            uint32_t uconVal = static_cast<uint32_t>(iconVal);
+            iconVal          = static_cast<int32_t>(((uconVal >> 24) & 0xFF) | ((uconVal >> 8) & 0xFF00) |
+                                           ((uconVal << 8) & 0xFF0000) | ((uconVal << 24) & 0xFF000000));
             break;
         }
 
@@ -17160,6 +17161,7 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int
                     return tree;
                 }
             }
+            break;
         }
 
         default:
@@ -17172,7 +17174,7 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprUnaryConst: see if an unary const operation for TYP_LONG is foldable
+// gtFoldExprUnaryConst: see if a unary const operation for TYP_LONG is foldable
 //
 // Arguments:
 //    tree   - tree to examine
@@ -17209,16 +17211,17 @@ GenTree* Compiler::gtFoldExprUnaryConstLng(GenTreeUnOp* tree, GenTreeIntConCommo
 
         case GT_NEG:
         {
-            lconVal = -lconVal;
+            lconVal = static_cast<int64_t>(0 - static_cast<uint64_t>(lconVal));
             break;
         }
 
         case GT_BSWAP:
         {
-            lconVal = ((lconVal >> 56) & 0xFF) | ((lconVal >> 40) & 0xFF00) | ((lconVal >> 24) & 0xFF0000) |
-                      ((lconVal >> 8) & 0xFF000000) | ((lconVal << 8) & 0xFF00000000) |
-                      ((lconVal << 24) & 0xFF0000000000) | ((lconVal << 40) & 0xFF000000000000) |
-                      ((lconVal << 56) & 0xFF00000000000000);
+            uint64_t uconVal = static_cast<uint64_t>(lconVal);
+            lconVal          = static_cast<int64_t>(
+                ((uconVal >> 56) & 0xFF) | ((uconVal >> 40) & 0xFF00) | ((uconVal >> 24) & 0xFF0000) |
+                ((uconVal >> 8) & 0xFF000000) | ((uconVal << 8) & 0xFF00000000) | ((uconVal << 24) & 0xFF0000000000) |
+                ((uconVal << 40) & 0xFF000000000000) | ((uconVal << 56) & 0xFF00000000000000));
             break;
         }
 
@@ -17326,7 +17329,7 @@ GenTree* Compiler::gtFoldExprUnaryConstLng(GenTreeUnOp* tree, GenTreeIntConCommo
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprUnaryConstDbl: see if an unary const operation for TYP_DOUBLE or TYP_FLOAT is foldable
+// gtFoldExprUnaryConstDbl: see if a unary const operation for TYP_DOUBLE or TYP_FLOAT is foldable
 //
 // Arguments:
 //    tree   - tree to examine
@@ -17744,7 +17747,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
                 return gtFoldExprForOverflow(tree);
             }
 
-            iconVal1 += iconVal2;
+            iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) + static_cast<uint32_t>(iconVal2));
 
             FieldSeq* fieldSeq = GetFieldSeqStore()->Append(intCon1->gtFieldSeq, intCon2->gtFieldSeq);
             return gtBashTreeToConstInt(tree, iconVal1, fieldSeq);
@@ -17757,7 +17760,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
                 return gtFoldExprForOverflow(tree);
             }
 
-            iconVal1 -= iconVal2;
+            iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) - static_cast<uint32_t>(iconVal2));
             break;
         }
 
@@ -17768,7 +17771,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
                 return gtFoldExprForOverflow(tree);
             }
 
-            iconVal1 *= iconVal2;
+            iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) * static_cast<uint32_t>(iconVal2));
             break;
         }
 
@@ -17792,7 +17795,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
 
         case GT_LSH:
         {
-            iconVal1 <<= (iconVal2 & 0x1F);
+            iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) << (iconVal2 & 0x1F));
             break;
         }
 
@@ -17810,17 +17813,17 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
 
         case GT_ROL:
         {
+            uint32_t uconVal1 = static_cast<uint32_t>(iconVal1);
             iconVal2 &= 0x1F;
-            iconVal1 = (iconVal1 << iconVal2) |
-                       static_cast<int32_t>(static_cast<uint32_t>(iconVal1) >> ((32 - iconVal2) & 0x1F));
+            iconVal1 = static_cast<int32_t>((uconVal1 << iconVal2) | (uconVal1 >> ((32 - iconVal2) & 0x1F)));
             break;
         }
 
         case GT_ROR:
         {
+            uint32_t uconVal1 = static_cast<uint32_t>(iconVal1);
             iconVal2 &= 0x1F;
-            iconVal1 = (iconVal1 << ((32 - iconVal2) & 0x1F)) |
-                       static_cast<int32_t>(static_cast<uint32_t>(iconVal1) >> iconVal2);
+            iconVal1 = static_cast<int32_t>((uconVal1 << ((32 - iconVal2) & 0x1F)) | (uconVal1 >> iconVal2));
             break;
         }
 
@@ -17872,7 +17875,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprBinaryConstInt: see if a binary const operation for TYP_LONG is foldable
+// gtFoldExprBinaryConstLng: see if a binary const operation for TYP_LONG is foldable
 //
 // Arguments:
 //    tree          - tree to examine
@@ -17993,7 +17996,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
                 return gtFoldExprForOverflow(tree);
             }
 
-            lconVal1 += lconVal2;
+            lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) + static_cast<uint64_t>(lconVal2));
 
 #if defined(TARGET_64BIT)
             FieldSeq* fieldSeq = GetFieldSeqStore()->Append(intConCommon1->AsIntCon()->gtFieldSeq,
@@ -18011,7 +18014,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
                 return gtFoldExprForOverflow(tree);
             }
 
-            lconVal1 -= lconVal2;
+            lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) - static_cast<uint64_t>(lconVal2));
             break;
         }
 
@@ -18022,7 +18025,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
                 return gtFoldExprForOverflow(tree);
             }
 
-            lconVal1 *= lconVal2;
+            lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) * static_cast<uint64_t>(lconVal2));
             break;
         }
 
@@ -18046,7 +18049,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
 
         case GT_LSH:
         {
-            lconVal1 <<= (lconVal2 & 0x3F);
+            lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) << (lconVal2 & 0x3F));
             break;
         }
 
@@ -18064,17 +18067,17 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
 
         case GT_ROL:
         {
+            uint64_t uconVal1 = static_cast<uint64_t>(lconVal1);
             lconVal2 &= 0x3F;
-            lconVal1 = (lconVal1 << lconVal2) |
-                       static_cast<int64_t>(static_cast<uint64_t>(lconVal1) >> ((64 - lconVal2) & 0x3F));
+            lconVal1 = static_cast<int64_t>((uconVal1 << lconVal2) | (uconVal1 >> ((64 - lconVal2) & 0x3F)));
             break;
         }
 
         case GT_ROR:
         {
+            uint64_t uconVal1 = static_cast<uint64_t>(lconVal1);
             lconVal2 &= 0x3F;
-            lconVal1 = (lconVal1 << ((64 - lconVal2) & 0x3F)) |
-                       static_cast<int64_t>(static_cast<uint64_t>(lconVal1) >> lconVal2);
+            lconVal1 = static_cast<int64_t>((uconVal1 << ((64 - lconVal2) & 0x3F)) | (uconVal1 >> lconVal2));
             break;
         }
 
@@ -18126,12 +18129,12 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp*           tree,
 }
 
 //------------------------------------------------------------------------
-// gtFoldExprBinaryConstInt: see if a binary const operation for TYP_INT is foldable
+// gtFoldExprBinaryConstDbl: see if a binary const operation for TYP_DOUBLE or TYP_FLOAT is foldable
 //
 // Arguments:
 //    tree    - tree to examine
-//    intCon1 - the first integer constant operand for tree
-//    intCon2 - the second integer constant operand for tree
+//    dblCon1 - the first floating-point constant operand for tree
+//    dblCon2 - the second floating-point constant operand for tree
 //
 // Returns:
 //    The original tree if no folding happened.
@@ -18234,6 +18237,12 @@ GenTree* Compiler::gtFoldExprBinaryConstDbl(GenTreeOp* tree, GenTreeDblCon* dblC
 
         case GT_DIV:
         {
+            if (dconVal2 == 0)
+            {
+                // We do not fold division by zero, even for floating point.
+                // This is because the result will be platform-dependent for an expression like 0d / 0d.
+                return tree;
+            }
             dconVal1 /= dconVal2;
             break;
         }
@@ -18325,7 +18334,6 @@ GenTree* Compiler::gtBashTreeToConstLng(GenTree* tree, int64_t lconVal, FieldSeq
 // Arguments:
 //    tree     - the tree to bash
 //    dconVal  - the value of the constant
-//    fieldSeq - the field sequence, if any
 //
 // Returns:
 //    tree, bashed to GT_CNS_DBL node
@@ -33315,7 +33323,7 @@ bool GenTree::IsVectorPerElementMask(var_types simdBaseType, unsigned simdSize)
 
         case GT_NOT:
         {
-            // We are an unary bitwise operation where the input is a per-element mask
+            // We are a unary bitwise operation where the input is a per-element mask
             return intrinsic->Op(1)->IsVectorPerElementMask(simdBaseType, simdSize);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -14985,7 +14985,7 @@ GenTree* Compiler::gtFoldExpr(GenTree* tree)`
`14985`	`14985`	`}`
`14986`	`14986`
`14987`	`14987`	`//------------------------------------------------------------------------`
`14988`		`-// gtFoldExprUnary: see if an unary operation is foldable`
	`14988`	`+// gtFoldExprUnary: see if a unary operation is foldable`
`14989`	`14989`	`//`
`14990`	`14990`	`// Arguments:`
`14991`	`14991`	`// tree - tree to examine`
`@@ -16964,7 +16964,7 @@ GenTree* Compiler::gtFoldExprConst(GenTree* tree)`
`16964`	`16964`	`}`
`16965`	`16965`
`16966`	`16966`	`//------------------------------------------------------------------------`
`16967`		`-// gtFoldExprUnaryConst: see if an unary const operation is foldable`
	`16967`	`+// gtFoldExprUnaryConst: see if a unary const operation is foldable`
`16968`	`16968`	`//`
`16969`	`16969`	`// Arguments:`
`16970`	`16970`	`// tree - tree to examine`
`@@ -17013,7 +17013,7 @@ GenTree* Compiler::gtFoldExprUnaryConst(GenTreeUnOp* tree)`
`17013`	`17013`	`}`
`17014`	`17014`
`17015`	`17015`	`//------------------------------------------------------------------------`
`17016`		`-// gtFoldExprUnaryConst: see if an unary const operation for TYP_INT is foldable`
	`17016`	`+// gtFoldExprUnaryConst: see if a unary const operation for TYP_INT is foldable`
`17017`	`17017`	`//`
`17018`	`17018`	`// Arguments:`
`17019`	`17019`	`// tree - tree to examine`
`@@ -17050,14 +17050,15 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int`
`17050`	`17050`
`17051`	`17051`	`case GT_NEG:`
`17052`	`17052`	`{`
`17053`		`- iconVal = -iconVal;`
	`17053`	`+ iconVal = static_cast<int32_t>(0 - static_cast<uint32_t>(iconVal));`
`17054`	`17054`	`break;`
`17055`	`17055`	`}`
`17056`	`17056`
`17057`	`17057`	`case GT_BSWAP:`
`17058`	`17058`	`{`
`17059`		`- iconVal = ((iconVal >> 24) & 0xFF) \| ((iconVal >> 8) & 0xFF00) \| ((iconVal << 8) & 0xFF0000) \|`
`17060`		`- ((iconVal << 24) & 0xFF000000);`
	`17059`	`+ uint32_t uconVal = static_cast<uint32_t>(iconVal);`
	`17060`	`+ iconVal = static_cast<int32_t>(((uconVal >> 24) & 0xFF) \| ((uconVal >> 8) & 0xFF00) \|`
	`17061`	`+ ((uconVal << 8) & 0xFF0000) \| ((uconVal << 24) & 0xFF000000));`
`17061`	`17062`	`break;`
`17062`	`17063`	`}`
`17063`	`17064`
`@@ -17160,6 +17161,7 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int`
`17160`	`17161`	`return tree;`
`17161`	`17162`	`}`
`17162`	`17163`	`}`
	`17164`	`+ break;`
`17163`	`17165`	`}`
`17164`	`17166`
`17165`	`17167`	`default:`
`@@ -17172,7 +17174,7 @@ GenTree* Compiler::gtFoldExprUnaryConstInt(GenTreeUnOp* tree, GenTreeIntCon* int`
`17172`	`17174`	`}`
`17173`	`17175`
`17174`	`17176`	`//------------------------------------------------------------------------`
`17175`		`-// gtFoldExprUnaryConst: see if an unary const operation for TYP_LONG is foldable`
	`17177`	`+// gtFoldExprUnaryConst: see if a unary const operation for TYP_LONG is foldable`
`17176`	`17178`	`//`
`17177`	`17179`	`// Arguments:`
`17178`	`17180`	`// tree - tree to examine`
`@@ -17209,16 +17211,17 @@ GenTree* Compiler::gtFoldExprUnaryConstLng(GenTreeUnOp* tree, GenTreeIntConCommo`
`17209`	`17211`
`17210`	`17212`	`case GT_NEG:`
`17211`	`17213`	`{`
`17212`		`- lconVal = -lconVal;`
	`17214`	`+ lconVal = static_cast<int64_t>(0 - static_cast<uint64_t>(lconVal));`
`17213`	`17215`	`break;`
`17214`	`17216`	`}`
`17215`	`17217`
`17216`	`17218`	`case GT_BSWAP:`
`17217`	`17219`	`{`
`17218`		`- lconVal = ((lconVal >> 56) & 0xFF) \| ((lconVal >> 40) & 0xFF00) \| ((lconVal >> 24) & 0xFF0000) \|`
`17219`		`- ((lconVal >> 8) & 0xFF000000) \| ((lconVal << 8) & 0xFF00000000) \|`
`17220`		`- ((lconVal << 24) & 0xFF0000000000) \| ((lconVal << 40) & 0xFF000000000000) \|`
`17221`		`- ((lconVal << 56) & 0xFF00000000000000);`
	`17220`	`+ uint64_t uconVal = static_cast<uint64_t>(lconVal);`
	`17221`	`+ lconVal = static_cast<int64_t>(`
	`17222`	`+ ((uconVal >> 56) & 0xFF) \| ((uconVal >> 40) & 0xFF00) \| ((uconVal >> 24) & 0xFF0000) \|`
	`17223`	`+ ((uconVal >> 8) & 0xFF000000) \| ((uconVal << 8) & 0xFF00000000) \| ((uconVal << 24) & 0xFF0000000000) \|`
	`17224`	`+ ((uconVal << 40) & 0xFF000000000000) \| ((uconVal << 56) & 0xFF00000000000000));`
`17222`	`17225`	`break;`
`17223`	`17226`	`}`
`17224`	`17227`
`@@ -17326,7 +17329,7 @@ GenTree* Compiler::gtFoldExprUnaryConstLng(GenTreeUnOp* tree, GenTreeIntConCommo`
`17326`	`17329`	`}`
`17327`	`17330`
`17328`	`17331`	`//------------------------------------------------------------------------`
`17329`		`-// gtFoldExprUnaryConstDbl: see if an unary const operation for TYP_DOUBLE or TYP_FLOAT is foldable`
	`17332`	`+// gtFoldExprUnaryConstDbl: see if a unary const operation for TYP_DOUBLE or TYP_FLOAT is foldable`
`17330`	`17333`	`//`
`17331`	`17334`	`// Arguments:`
`17332`	`17335`	`// tree - tree to examine`
`@@ -17744,7 +17747,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17744`	`17747`	`return gtFoldExprForOverflow(tree);`
`17745`	`17748`	`}`
`17746`	`17749`
`17747`		`- iconVal1 += iconVal2;`
	`17750`	`+ iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) + static_cast<uint32_t>(iconVal2));`
`17748`	`17751`
`17749`	`17752`	`FieldSeq* fieldSeq = GetFieldSeqStore()->Append(intCon1->gtFieldSeq, intCon2->gtFieldSeq);`
`17750`	`17753`	`return gtBashTreeToConstInt(tree, iconVal1, fieldSeq);`
`@@ -17757,7 +17760,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17757`	`17760`	`return gtFoldExprForOverflow(tree);`
`17758`	`17761`	`}`
`17759`	`17762`
`17760`		`- iconVal1 -= iconVal2;`
	`17763`	`+ iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) - static_cast<uint32_t>(iconVal2));`
`17761`	`17764`	`break;`
`17762`	`17765`	`}`
`17763`	`17766`
`@@ -17768,7 +17771,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17768`	`17771`	`return gtFoldExprForOverflow(tree);`
`17769`	`17772`	`}`
`17770`	`17773`
`17771`		`- iconVal1 *= iconVal2;`
	`17774`	`+ iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) * static_cast<uint32_t>(iconVal2));`
`17772`	`17775`	`break;`
`17773`	`17776`	`}`
`17774`	`17777`
`@@ -17792,7 +17795,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17792`	`17795`
`17793`	`17796`	`case GT_LSH:`
`17794`	`17797`	`{`
`17795`		`- iconVal1 <<= (iconVal2 & 0x1F);`
	`17798`	`+ iconVal1 = static_cast<int32_t>(static_cast<uint32_t>(iconVal1) << (iconVal2 & 0x1F));`
`17796`	`17799`	`break;`
`17797`	`17800`	`}`
`17798`	`17801`
`@@ -17810,17 +17813,17 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17810`	`17813`
`17811`	`17814`	`case GT_ROL:`
`17812`	`17815`	`{`
	`17816`	`+ uint32_t uconVal1 = static_cast<uint32_t>(iconVal1);`
`17813`	`17817`	`iconVal2 &= 0x1F;`
`17814`		`- iconVal1 = (iconVal1 << iconVal2) \|`
`17815`		`- static_cast<int32_t>(static_cast<uint32_t>(iconVal1) >> ((32 - iconVal2) & 0x1F));`
	`17818`	`+ iconVal1 = static_cast<int32_t>((uconVal1 << iconVal2) \| (uconVal1 >> ((32 - iconVal2) & 0x1F)));`
`17816`	`17819`	`break;`
`17817`	`17820`	`}`
`17818`	`17821`
`17819`	`17822`	`case GT_ROR:`
`17820`	`17823`	`{`
	`17824`	`+ uint32_t uconVal1 = static_cast<uint32_t>(iconVal1);`
`17821`	`17825`	`iconVal2 &= 0x1F;`
`17822`		`- iconVal1 = (iconVal1 << ((32 - iconVal2) & 0x1F)) \|`
`17823`		`- static_cast<int32_t>(static_cast<uint32_t>(iconVal1) >> iconVal2);`
	`17826`	`+ iconVal1 = static_cast<int32_t>((uconVal1 << ((32 - iconVal2) & 0x1F)) \| (uconVal1 >> iconVal2));`
`17824`	`17827`	`break;`
`17825`	`17828`	`}`
`17826`	`17829`
`@@ -17872,7 +17875,7 @@ GenTree* Compiler::gtFoldExprBinaryConstInt(GenTreeOp* tree, GenTreeIntCon* intC`
`17872`	`17875`	`}`
`17873`	`17876`
`17874`	`17877`	`//------------------------------------------------------------------------`
`17875`		`-// gtFoldExprBinaryConstInt: see if a binary const operation for TYP_LONG is foldable`
	`17878`	`+// gtFoldExprBinaryConstLng: see if a binary const operation for TYP_LONG is foldable`
`17876`	`17879`	`//`
`17877`	`17880`	`// Arguments:`
`17878`	`17881`	`// tree - tree to examine`
`@@ -17993,7 +17996,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`17993`	`17996`	`return gtFoldExprForOverflow(tree);`
`17994`	`17997`	`}`
`17995`	`17998`
`17996`		`- lconVal1 += lconVal2;`
	`17999`	`+ lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) + static_cast<uint64_t>(lconVal2));`
`17997`	`18000`
`17998`	`18001`	`#if defined(TARGET_64BIT)`
`17999`	`18002`	`FieldSeq* fieldSeq = GetFieldSeqStore()->Append(intConCommon1->AsIntCon()->gtFieldSeq,`
`@@ -18011,7 +18014,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`18011`	`18014`	`return gtFoldExprForOverflow(tree);`
`18012`	`18015`	`}`
`18013`	`18016`
`18014`		`- lconVal1 -= lconVal2;`
	`18017`	`+ lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) - static_cast<uint64_t>(lconVal2));`
`18015`	`18018`	`break;`
`18016`	`18019`	`}`
`18017`	`18020`
`@@ -18022,7 +18025,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`18022`	`18025`	`return gtFoldExprForOverflow(tree);`
`18023`	`18026`	`}`
`18024`	`18027`
`18025`		`- lconVal1 *= lconVal2;`
	`18028`	`+ lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) * static_cast<uint64_t>(lconVal2));`
`18026`	`18029`	`break;`
`18027`	`18030`	`}`
`18028`	`18031`
`@@ -18046,7 +18049,7 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`18046`	`18049`
`18047`	`18050`	`case GT_LSH:`
`18048`	`18051`	`{`
`18049`		`- lconVal1 <<= (lconVal2 & 0x3F);`
	`18052`	`+ lconVal1 = static_cast<int64_t>(static_cast<uint64_t>(lconVal1) << (lconVal2 & 0x3F));`
`18050`	`18053`	`break;`
`18051`	`18054`	`}`
`18052`	`18055`
`@@ -18064,17 +18067,17 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`18064`	`18067`
`18065`	`18068`	`case GT_ROL:`
`18066`	`18069`	`{`
	`18070`	`+ uint64_t uconVal1 = static_cast<uint64_t>(lconVal1);`
`18067`	`18071`	`lconVal2 &= 0x3F;`
`18068`		`- lconVal1 = (lconVal1 << lconVal2) \|`
`18069`		`- static_cast<int64_t>(static_cast<uint64_t>(lconVal1) >> ((64 - lconVal2) & 0x3F));`
	`18072`	`+ lconVal1 = static_cast<int64_t>((uconVal1 << lconVal2) \| (uconVal1 >> ((64 - lconVal2) & 0x3F)));`
`18070`	`18073`	`break;`
`18071`	`18074`	`}`
`18072`	`18075`
`18073`	`18076`	`case GT_ROR:`
`18074`	`18077`	`{`
	`18078`	`+ uint64_t uconVal1 = static_cast<uint64_t>(lconVal1);`
`18075`	`18079`	`lconVal2 &= 0x3F;`
`18076`		`- lconVal1 = (lconVal1 << ((64 - lconVal2) & 0x3F)) \|`
`18077`		`- static_cast<int64_t>(static_cast<uint64_t>(lconVal1) >> lconVal2);`
	`18080`	`+ lconVal1 = static_cast<int64_t>((uconVal1 << ((64 - lconVal2) & 0x3F)) \| (uconVal1 >> lconVal2));`
`18078`	`18081`	`break;`
`18079`	`18082`	`}`
`18080`	`18083`
`@@ -18126,12 +18129,12 @@ GenTree* Compiler::gtFoldExprBinaryConstLng(GenTreeOp* tree,`
`18126`	`18129`	`}`
`18127`	`18130`
`18128`	`18131`	`//------------------------------------------------------------------------`
`18129`		`-// gtFoldExprBinaryConstInt: see if a binary const operation for TYP_INT is foldable`
	`18132`	`+// gtFoldExprBinaryConstDbl: see if a binary const operation for TYP_DOUBLE or TYP_FLOAT is foldable`
`18130`	`18133`	`//`
`18131`	`18134`	`// Arguments:`
`18132`	`18135`	`// tree - tree to examine`
`18133`		`-// intCon1 - the first integer constant operand for tree`
`18134`		`-// intCon2 - the second integer constant operand for tree`
	`18136`	`+// dblCon1 - the first floating-point constant operand for tree`
	`18137`	`+// dblCon2 - the second floating-point constant operand for tree`
`18135`	`18138`	`//`
`18136`	`18139`	`// Returns:`
`18137`	`18140`	`// The original tree if no folding happened.`
`@@ -18234,6 +18237,12 @@ GenTree* Compiler::gtFoldExprBinaryConstDbl(GenTreeOp* tree, GenTreeDblCon* dblC`
`18234`	`18237`
`18235`	`18238`	`case GT_DIV:`
`18236`	`18239`	`{`
	`18240`	`+ if (dconVal2 == 0)`
	`18241`	`+ {`
	`18242`	`+ // We do not fold division by zero, even for floating point.`
	`18243`	`+ // This is because the result will be platform-dependent for an expression like 0d / 0d.`
	`18244`	`+ return tree;`
	`18245`	`+ }`
`18237`	`18246`	`dconVal1 /= dconVal2;`
`18238`	`18247`	`break;`
`18239`	`18248`	`}`
`@@ -18325,7 +18334,6 @@ GenTree* Compiler::gtBashTreeToConstLng(GenTree* tree, int64_t lconVal, FieldSeq`
`18325`	`18334`	`// Arguments:`
`18326`	`18335`	`// tree - the tree to bash`
`18327`	`18336`	`// dconVal - the value of the constant`
`18328`		`-// fieldSeq - the field sequence, if any`
`18329`	`18337`	`//`
`18330`	`18338`	`// Returns:`
`18331`	`18339`	`// tree, bashed to GT_CNS_DBL node`
`@@ -33315,7 +33323,7 @@ bool GenTree::IsVectorPerElementMask(var_types simdBaseType, unsigned simdSize)`
`33315`	`33323`
`33316`	`33324`	`case GT_NOT:`
`33317`	`33325`	`{`
`33318`		`- // We are an unary bitwise operation where the input is a per-element mask`
	`33326`	`+ // We are a unary bitwise operation where the input is a per-element mask`
`33319`	`33327`	`return intrinsic->Op(1)->IsVectorPerElementMask(simdBaseType, simdSize);`
`33320`	`33328`	`}`
`33321`	`33329`