Enable more general BITCAST folding in local morph (#84144)

* Enable the bitcast transform more generally

* Enable general BITCAST support in the backend

Correctness fixes:
1) The hacky way which contained indirections were handled
   will not work for targets where address containment has
   special rules that depends on the type being loaded.
2) Small-typed sources were not handled correctly.
3) Interference checks. This has some regressions attached
   to it because we now contain locals with optimizations
   disabled and that can lead to using double stores instead
   of integer ones when the user is a store itself.

Author: SingleAccretion

src/coreclr/jit/assertionprop.cpp

@@ -5709,6 +5709,7 @@ Compiler::fgWalkResult Compiler::optVNConstantPropCurStmt(BasicBlock* block, Sta
         case GT_RSZ:
         case GT_NEG:
         case GT_CAST:
+        case GT_BITCAST:
         case GT_INTRINSIC:
 #ifdef FEATURE_HW_INTRINSICS
         case GT_HWINTRINSIC:

src/coreclr/jit/codegencommon.cpp

@@ -9377,28 +9377,18 @@ void CodeGen::genBitCast(var_types targetType, regNumber targetReg, var_types sr
 //
 void CodeGen::genCodeForBitCast(GenTreeOp* treeNode)
 {
+    assert(treeNode->TypeGet() == genActualType(treeNode));
     regNumber targetReg  = treeNode->GetRegNum();
     var_types targetType = treeNode->TypeGet();
     GenTree*  op1        = treeNode->gtGetOp1();
     genConsumeRegs(op1);
 
     if (op1->isContained())
     {
-        assert(op1->IsLocal() || op1->isIndir());
-        if (genIsRegCandidateLocal(op1))
-        {
-            unsigned lclNum = op1->AsLclVar()->GetLclNum();
-            GetEmitter()->emitIns_R_S(ins_Load(treeNode->TypeGet(), compiler->isSIMDTypeLocalAligned(lclNum)),
-                                      emitTypeSize(treeNode), targetReg, lclNum, 0);
-        }
-        else
-        {
-            op1->gtType = treeNode->TypeGet();
-            op1->SetRegNum(targetReg);
-            op1->ClearContained();
-            JITDUMP("Changing type of BITCAST source to load directly.\n");
-            genCodeForTreeNode(op1);
-        }
+        assert(op1->OperIs(GT_LCL_VAR));
+        unsigned    lclNum  = op1->AsLclVarCommon()->GetLclNum();
+        instruction loadIns = ins_Load(targetType, compiler->isSIMDTypeLocalAligned(lclNum));
+        GetEmitter()->emitIns_R_S(loadIns, emitTypeSize(targetType), targetReg, lclNum, 0);
     }
     else
     {

src/coreclr/jit/compiler.h

@@ -5937,6 +5937,7 @@ class Compiler
     void fgTryReplaceStructLocalWithField(GenTree* tree);
     GenTree* fgOptimizeCast(GenTreeCast* cast);
     GenTree* fgOptimizeCastOnAssignment(GenTreeOp* asg);
+    GenTree* fgOptimizeBitCast(GenTreeUnOp* bitCast);
     GenTree* fgOptimizeEqualityComparisonWithConst(GenTreeOp* cmp);
     GenTree* fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp);
     GenTree* fgOptimizeRelationalComparisonWithFullRangeConst(GenTreeOp* cmp);

src/coreclr/jit/lclmorph.cpp

@@ -1354,17 +1354,15 @@ class LocalAddressVisitor final : public GenTreeVisitor<LocalAddressVisitor>
             }
 #endif // FEATURE_HW_INTRINSICS
 
-            // Turn this into a narrow-cast if we can.
-            if (!isDef && varTypeIsIntegral(indir) && varTypeIsIntegral(varDsc))
+            if (!isDef)
             {
-                return IndirTransform::NarrowCast;
-            }
+                if (varTypeIsIntegral(indir) && varTypeIsIntegral(varDsc))
+                {
+                    return IndirTransform::NarrowCast;
+                }
 
-            // Turn this into a bitcast if we can.
-            if ((genTypeSize(indir) == genTypeSize(varDsc)) && (varTypeIsFloating(indir) || varTypeIsFloating(varDsc)))
-            {
-                // TODO-ADDR: enable this optimization for all users and all targets.
-                if (user->OperIs(GT_RETURN) && (genTypeSize(indir) <= TARGET_POINTER_SIZE))
+                if ((genTypeSize(indir) == genTypeSize(varDsc)) && (genTypeSize(indir) <= TARGET_POINTER_SIZE) &&
+                    (varTypeIsFloating(indir) || varTypeIsFloating(varDsc)))
                 {
                     return IndirTransform::BitCast;
                 }

src/coreclr/jit/lower.cpp

@@ -524,11 +524,15 @@ GenTree* Lowering::LowerNode(GenTree* node)
             LowerCast(node);
             break;
 
+        case GT_BITCAST:
+            ContainCheckBitCast(node);
+            break;
+
 #if defined(TARGET_XARCH) || defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
         case GT_BOUNDS_CHECK:
             ContainCheckBoundsChk(node->AsBoundsChk());
             break;
-#endif // TARGET_XARCH
+#endif // defined(TARGET_XARCH) || defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64)
 
         case GT_ARR_ELEM:
             noway_assert(!comp->opts.compJitEarlyExpandMDArrays);
@@ -7659,6 +7663,12 @@ void Lowering::ContainCheckNode(GenTree* node)
 #endif
             ContainCheckShiftRotate(node->AsOp());
             break;
+        case GT_CAST:
+            ContainCheckCast(node->AsCast());
+            break;
+        case GT_BITCAST:
+            ContainCheckBitCast(node);
+            break;
         case GT_ARR_OFFSET:
             ContainCheckArrOffset(node->AsArrOffs());
             break;
@@ -7801,32 +7811,17 @@ void Lowering::ContainCheckRet(GenTreeUnOp* ret)
 void Lowering::ContainCheckBitCast(GenTree* node)
 {
     GenTree* const op1 = node->AsOp()->gtOp1;
-    if (op1->isMemoryOp())
+    if (op1->OperIs(GT_LCL_VAR) && (genTypeSize(op1) == genTypeSize(node)))
     {
-        op1->SetContained();
-    }
-    else if (op1->OperIs(GT_LCL_VAR))
-    {
-        if (!m_lsra->willEnregisterLocalVars())
-        {
-            op1->SetContained();
-        }
-        const LclVarDsc* varDsc = comp->lvaGetDesc(op1->AsLclVar());
-        // TODO-Cleanup: we want to check if the local is already known not
-        // to be on reg, for example, because local enreg is disabled.
-        if (varDsc->lvDoNotEnregister)
+        if (IsContainableMemoryOp(op1) && IsSafeToContainMem(node, op1))
         {
-            op1->SetContained();
+            MakeSrcContained(node, op1);
         }
-        else
+        else if (IsSafeToMarkRegOptional(node, op1))
         {
-            op1->SetRegOptional();
+            MakeSrcRegOptional(node, op1);
         }
     }
-    else if (op1->IsLocal())
-    {
-        op1->SetContained();
-    }
 }
 
 //------------------------------------------------------------------------

src/coreclr/jit/morph.cpp

@@ -9491,6 +9491,16 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac, bool* optA
             op2  = tree->gtGetOp2IfPresent();
             break;
 
+        case GT_BITCAST:
+        {
+            GenTree* optimizedTree = fgOptimizeBitCast(tree->AsUnOp());
+            if (optimizedTree != nullptr)
+            {
+                return optimizedTree;
+            }
+        }
+        break;
+
         case GT_EQ:
         case GT_NE:
             // It is not safe to reorder/delete CSE's
@@ -10317,6 +10327,35 @@ GenTree* Compiler::fgOptimizeCastOnAssignment(GenTreeOp* asg)
     return asg;
 }
 
+//------------------------------------------------------------------------
+// fgOptimizeBitCast: Optimizes the supplied BITCAST node.
+//
+// Retypes the source node and removes the cast if possible.
+//
+// Arguments:
+//    bitCast - the BITCAST node
+//
+// Return Value:
+//    The optimized tree or "nullptr" if no transformations were performed.
+//
+GenTree* Compiler::fgOptimizeBitCast(GenTreeUnOp* bitCast)
+{
+    if (opts.OptimizationDisabled() || optValnumCSE_phase)
+    {
+        return nullptr;
+    }
+
+    GenTree* op1 = bitCast->gtGetOp1();
+    if (op1->OperIs(GT_IND, GT_LCL_FLD) && (genTypeSize(op1) == genTypeSize(bitCast)))
+    {
+        op1->ChangeType(bitCast->TypeGet());
+        op1->SetVNsFromNode(bitCast);
+        return op1;
+    }
+
+    return nullptr;
+}
+
 //------------------------------------------------------------------------
 // fgOptimizeEqualityComparisonWithConst: optimizes various EQ/NE(OP, CONST) patterns.
 //

src/coreclr/jit/optcse.cpp

@@ -3560,6 +3560,7 @@ bool Compiler::optIsCSEcandidate(GenTree* tree)
         case GT_BSWAP:
         case GT_BSWAP16:
         case GT_CAST:
+        case GT_BITCAST:
             return true; // CSE these Unary Operators
 
         case GT_SUB: