[Outdated] Implementation of CSE for GT_CNS_INT benefits ARM64.

src/coreclr/src/jit/assertionprop.cpp

@@ -3236,7 +3236,8 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, Gen
         return nullptr;
     }
 
-    AssertionDsc* curAssertion = optGetAssertion(index);
+    AssertionDsc* curAssertion         = optGetAssertion(index);
+    bool          assertionKindIsEqual = (curAssertion->assertionKind == OAK_EQUAL);
 
     // Allow or not to reverse condition for OAK_NOT_EQUAL assertions.
     bool allowReverse = true;
@@ -3251,7 +3252,7 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, Gen
             printf("\nVN relop based constant assertion prop in " FMT_BB ":\n", compCurBB->bbNum);
             printf("Assertion index=#%02u: ", index);
             printTreeID(op1);
-            printf(" %s ", (curAssertion->assertionKind == OAK_EQUAL) ? "==" : "!=");
+            printf(" %s ", assertionKindIsEqual ? "==" : "!=");
             if (genActualType(op1->TypeGet()) == TYP_INT)
             {
                 printf("%d\n", vnStore->ConstantValue<int>(vnCns));
@@ -3336,8 +3337,15 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, Gen
 
         op1->gtVNPair.SetBoth(vnCns); // Preserve the ValueNumPair, as ChangeOperConst/SetOper will clear it.
 
-        // Also set the value number on the relop.
-        if (curAssertion->assertionKind == OAK_EQUAL)
+        // set foldResult to either 0 or 1
+        bool foldResult = assertionKindIsEqual;
+        if (tree->gtOper == GT_NE)
+        {
+            foldResult = !foldResult;
+        }
+
+        // Set the value number on the relop to 1 (true) or 0 (false)
+        if (foldResult)
         {
             tree->gtVNPair.SetBoth(vnStore->VNOneForType(TYP_INT));
         }
@@ -4947,6 +4955,12 @@ GenTree* Compiler::optVNConstantPropOnJTrue(BasicBlock* block, GenTree* test)
 //
 Compiler::fgWalkResult Compiler::optVNConstantPropCurStmt(BasicBlock* block, Statement* stmt, GenTree* tree)
 {
+    // Don't perform const prop on expressions marked with GTF_DONT_CSE
+    if (!tree->CanCSE())
+    {
+        return WALK_CONTINUE;
+    }
+
     // Don't propagate floating-point constants into a TYP_STRUCT LclVar
     // This can occur for HFA return values (see hfa_sf3E_r.exe)
     if (tree->TypeGet() == TYP_STRUCT)

src/coreclr/src/jit/block.cpp

@@ -309,6 +309,10 @@ void BasicBlock::dspFlags()
     {
         printf("jmp ");
     }
+    if (bbFlags & BBF_HAS_CALL)
+    {
+        printf("hascall ");
+    }
     if (bbFlags & BBF_GC_SAFE_POINT)
     {
         printf("gcsafe ");

src/coreclr/src/jit/compiler.h

@@ -6320,7 +6320,10 @@ class Compiler
     {
         CSEdsc* csdNextInBucket; // used by the hash table
 
-        unsigned csdHashKey; // the orginal hashkey
+        size_t   csdHashKey;       // the orginal hashkey
+        ssize_t  csdConstDefValue; // When we CSE similar constants this is the value that we use as the def
+        ValueNum csdConstDefVN;    // When we CSE similar constants this is the ValueNumber that we use for the LclVar
+                                   // assignment
 
         unsigned csdIndex; // 1..optCSECandidateCount
         bool     csdLiveAcrossCall;
@@ -6353,6 +6356,19 @@ class Compiler
                                    // number, this will reflect it; otherwise, NoVN.
     };
 
+#if defined(TARGET_XARCH)
+#define CSE_CONST_SHARED_LOW_BITS 16
+#else
+// ARM64 or ARM32
+#define CSE_CONST_SHARED_LOW_BITS 12
+#endif
+
+#ifdef TARGET_64BIT
+#define TARGET_SIGN_BIT (1ULL << 63)
+#else
+#define TARGET_SIGN_BIT (1ULL << 31)
+#endif
+
     static const size_t s_optCSEhashSize;
     CSEdsc**            optCSEhash;
     CSEdsc**            optCSEtab;

src/coreclr/src/jit/earlyprop.cpp

@@ -445,6 +445,14 @@ GenTree* Compiler::optEarlyPropRewriteTree(GenTree* tree, LocalNumberToNullCheck
         // actualValClone has small tree node size, it is safe to use CopyFrom here.
         tree->ReplaceWith(actualValClone, this);
 
+        // Propagating a constant may create an opportunity to use a magic number division
+        //
+        if ((tree->gtNext != nullptr) && tree->gtNext->OperIsBinary())
+        {
+            // We need to mark the parent divide/mod operation when this occurs
+            tree->gtNext->AsOp()->checkMagicNumberDivision(this);
+        }
+
 #ifdef DEBUG
         if (verbose)
         {