Optimize FMA codegen base on the overwritten

src/coreclr/jit/gentree.cpp

@@ -19791,6 +19791,32 @@ uint16_t GenTreeLclVarCommon::GetLclOffs() const
     }
 }
 
+#ifdef FEATURE_HW_INTRINSICS
+//------------------------------------------------------------------------
+//
+unsigned GenTreeHWIntrinsic::GetFMAOverwritten(GenTree* op1, GenTree* op2, GenTree* op3)
+{
+    // only FMA intrinsic node should call into this function
+    GenTreeLclVarCommon* overwritten = this->gtNext->AsLclVarCommon();
+    assert(overwritten->gtOper == GT_STORE_LCL_VAR || overwritten->gtOper == GT_LCL_VAR);
+    unsigned                  flag        = 0; // 1->op1, 2->op2, 3->op3
+    if (op1->IsLocal() && op1->AsLclVarCommon()->GetLclNum() == overwritten->GetLclNum())
+    {
+        flag = 1;
+    }
+    else if (op2->IsLocal() && op2->AsLclVarCommon()->GetLclNum() == overwritten->GetLclNum())
+    {
+        flag = 2;
+    }
+    else if (op3->IsLocal() && op3->AsLclVarCommon()->GetLclNum() == overwritten->GetLclNum())
+    {
+        flag = 3;
+    }
+
+    return flag;
+}
+#endif
+
 #ifdef TARGET_ARM
 //------------------------------------------------------------------------
 // IsOffsetMisaligned: check if the field needs a special handling on arm.

src/coreclr/jit/gentree.h

@@ -5187,6 +5187,8 @@ struct GenTreeHWIntrinsic : public GenTreeJitIntrinsic
     bool OperIsMemoryLoadOrStore() const; // Returns true for the HW Intrinsic instructions that have MemoryLoad or
                                           // MemoryStore semantics, false otherwise
 
+    unsigned GetFMAOverwritten(GenTree* op1, GenTree* op2, GenTree* op3);
+
 #if DEBUGGABLE_GENTREE
     GenTreeHWIntrinsic() : GenTreeJitIntrinsic()
     {

src/coreclr/jit/hwintrinsiccodegenxarch.cpp

@@ -2133,7 +2133,9 @@ void CodeGen::genFMAIntrinsic(GenTreeHWIntrinsic* node)
     // Intrinsics with CopyUpperBits semantics cannot have op1 be contained
     assert(!copiesUpperBits || !op1->isContained());
 
-    if (op2->isContained() || op2->isUsedFromSpillTemp())
+    unsigned flag = node->GetFMAOverwritten(op1, op2, op3);
+
+    if (flag == 1)
     {
         // 132 form: op1 = (op1 * op3) + [op2]
 
@@ -2142,7 +2144,7 @@ void CodeGen::genFMAIntrinsic(GenTreeHWIntrinsic* node)
         op2Reg = op3->GetRegNum();
         op3    = op2;
     }
-    else if (op1->isContained() || op1->isUsedFromSpillTemp())
+    else if (flag == 3)
     {
         // 231 form: op3 = (op2 * op3) + [op1]
 

src/coreclr/jit/lowerxarch.cpp

@@ -6315,37 +6315,66 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node)
                     {
                         bool supportsRegOptional = false;
 
-                        if (IsContainableHWIntrinsicOp(node, op3, &supportsRegOptional))
-                        {
-                            // 213 form: op1 = (op2 * op1) + [op3]
-                            MakeSrcContained(node, op3);
-                        }
-                        else if (IsContainableHWIntrinsicOp(node, op2, &supportsRegOptional))
-                        {
-                            // 132 form: op1 = (op1 * op3) + [op2]
-                            MakeSrcContained(node, op2);
-                        }
-                        else if (IsContainableHWIntrinsicOp(node, op1, &supportsRegOptional))
+                        unsigned flag = node->GetFMAOverwritten(op1, op2, op3);
+
+                        switch (flag)
                         {
-                            // Intrinsics with CopyUpperBits semantics cannot have op1 be contained
+                            case 1:
+                            {
+                                if (IsContainableHWIntrinsicOp(node, op2, &supportsRegOptional))
+                                {
+                                    // 132 form: op1 = (op1 * op3) + [op2]
+                                    MakeSrcContained(node, op2);
+                                }
+                                else
+                                {
+                                    assert(supportsRegOptional);
 
-                            if (!HWIntrinsicInfo::CopiesUpperBits(intrinsicId))
+                                    // 132 form: op1 = (op1 * op3) + [op2]
+                                    op2->SetRegOptional();
+                                }
+                                break;
+                            }
+                            case 3:
                             {
-                                // 231 form: op3 = (op2 * op3) + [op1]
-                                MakeSrcContained(node, op1);
+                                if (IsContainableHWIntrinsicOp(node, op1, &supportsRegOptional))
+                                {
+                                  // Intrinsics with CopyUpperBits semantics cannot have op1 be contained
+
+                                  if (!HWIntrinsicInfo::CopiesUpperBits(intrinsicId))
+                                  {
+                                      // 231 form: op1 = (op2 * op3) + [op1]
+                                      MakeSrcContained(node, op1);
+                                  }
+                                }
+                                else
+                                {
+                                    assert(supportsRegOptional);
+                                    // 231 form: op1 = (op2 * op3) + [op1]
+                                    op1->SetRegOptional();
+                                }
+                                break;
                             }
-                        }
-                        else
-                        {
-                            assert(supportsRegOptional);
+                            default:
+                            {
+                                if (IsContainableHWIntrinsicOp(node, op3, &supportsRegOptional))
+                                {
+                                    // 213 form: op1 = (op2 * op1) + [op3]
+                                    MakeSrcContained(node, op3);
+                                }
+                                else
+                                {
+                                    assert(supportsRegOptional);
 
-                            // TODO-XArch-CQ: Technically any one of the three operands can
-                            //                be reg-optional. With a limitation on op1 where
-                            //                it can only be so if CopyUpperBits is off.
-                            //                https://github.com/dotnet/runtime/issues/6358
+                                    // TODO-XArch-CQ: Technically any one of the three operands can
+                                    //                be reg-optional. With a limitation on op1 where
+                                    //                it can only be so if CopyUpperBits is off.
+                                    //                https://github.com/dotnet/runtime/issues/6358
 
-                            // 213 form: op1 = (op2 * op1) + op3
-                            op3->SetRegOptional();
+                                    // 213 form: op1 = (op2 * op1) + [op3]
+                                    op3->SetRegOptional();
+                                }
+                            }
                         }
                     }
                     else

src/coreclr/jit/lsraxarch.cpp

@@ -2334,10 +2334,12 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
 
                 const bool copiesUpperBits = HWIntrinsicInfo::CopiesUpperBits(intrinsicId);
 
+                unsigned flag = intrinsicTree->GetFMAOverwritten(op1, op2, op3);
+
                 // Intrinsics with CopyUpperBits semantics cannot have op1 be contained
                 assert(!copiesUpperBits || !op1->isContained());
 
-                if (op2->isContained())
+                if (flag == 1)
                 {
                     // 132 form: op1 = (op1 * op3) + [op2]
 
@@ -2347,9 +2349,9 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree)
                     srcCount += BuildOperandUses(op2);
                     srcCount += BuildDelayFreeUses(op3, op1);
                 }
-                else if (op1->isContained())
+                else if (flag == 3)
                 {
-                    // 231 form: op3 = (op2 * op3) + [op1]
+                    // 231 form: op1 = (op2 * op3) + [op1]
 
                     tgtPrefUse = BuildUse(op3);