Measure last use struct copies

Author: jakobbotsch

src/coreclr/jit/codegenxarch.cpp

@@ -5441,6 +5441,8 @@ bool CodeGen::genEmitOptimizedGCWriteBarrier(GCInfo::WriteBarrierForm writeBarri
 #endif // !defined(TARGET_X86) || !NOGC_WRITE_BARRIERS
 }
 
+int s_numUnnecessaryLastUseStructCopies;
+
 // Produce code for a GT_CALL node
 void CodeGen::genCall(GenTreeCall* call)
 {
@@ -5518,6 +5520,73 @@ void CodeGen::genCall(GenTreeCall* call)
         }
     }
 
+    for (CallArg& arg : call->gtArgs.Args())
+    {
+        assert((arg.GetEarlyNode() == nullptr) != (arg.GetLateNode() == nullptr));
+        if (!arg.AbiInfo.PassedByRef)
+            continue;
+
+        GenTree* putArg = arg.GetNode();
+        GenTree* arg = putArg->gtGetOp1();
+        if (!arg->OperIs(GT_LCL_VAR_ADDR))
+            continue;
+
+        unsigned lclNum = arg->AsLclVarCommon()->GetLclNum();
+        if ((arg->gtFlags & GTF_VAR_DEATH) != 0)
+            continue;
+
+        GenTree* curNode = arg;
+        do
+        {
+            curNode = curNode->gtPrev;
+
+            GenTree* storeData = nullptr;
+            if (curNode->OperIsStoreBlk() && curNode->AsIndir()->Addr()->OperIsLocalAddr())
+            {
+                GenTreeLclVarCommon* addr = curNode->AsIndir()->Addr()->AsLclVarCommon();
+                if (addr->AsLclVarCommon()->GetLclNum() == lclNum && addr->AsLclVarCommon()->GetLclOffs() == 0)
+                    storeData = curNode->AsIndir()->Data();
+            }
+            else if (curNode->OperIsLocalStore())
+            {
+                GenTreeLclVarCommon* addr = curNode->AsLclVarCommon();
+                if (addr->GetLclNum() == lclNum && addr->GetLclOffs() == 0)
+                    storeData = curNode->AsLclVarCommon()->Data();
+            }
+            else
+            {
+                assert(!curNode->OperIsLocal() || curNode->AsLclVarCommon()->GetLclNum() != lclNum);
+            }
+
+            if (storeData != nullptr)
+            {
+                GenTreeLclVarCommon* srcLcl = nullptr;
+                if (storeData->OperIsIndir() && storeData->AsIndir()->Addr()->OperIsLocal())
+                {
+                    GenTreeLclVarCommon* lcl = storeData->AsIndir()->Addr()->AsLclVarCommon();
+                    if (compiler->lvaGetDesc(lcl)->lvIsImplicitByRef && !compiler->lvaGetDesc(lcl)->lvImplicitByRefAddrExposed)
+                        srcLcl = lcl;
+                }
+                else if (storeData->OperIsLocal())
+                {
+                    GenTreeLclVarCommon* lcl = storeData->AsLclVarCommon();
+                    if (!compiler->lvaGetDesc(lcl)->IsAddressExposed())
+                        srcLcl = lcl;
+                }
+
+                if (srcLcl != nullptr)
+                {
+                    if ((compiler->lvaGetPromotionType(srcLcl->GetLclNum()) != Compiler::PROMOTION_TYPE_INDEPENDENT) && (srcLcl->gtFlags & GTF_VAR_DEATH) != 0)
+                    {
+                        s_numUnnecessaryLastUseStructCopies++;
+                    }
+                }
+
+                break;
+            }
+        } while (curNode != LIR::AsRange(compiler->compCurBB).FirstNode());
+    }
+
 #if defined(TARGET_X86) || defined(UNIX_AMD64_ABI)
     // The call will pop its arguments.
     // for each putarg_stk:

src/coreclr/jit/compiler.cpp

@@ -1333,6 +1333,8 @@ void Compiler::compStartup()
  *  One time finalization code
  */
 
+extern int s_numUnnecessaryLastUseStructCopies;
+
 /* static */
 void Compiler::compShutdown()
 {
@@ -1490,6 +1492,8 @@ void Compiler::compShutdown()
 
 #endif // COUNT_AST_OPERS
 
+    fprintf(fout, "Number of unnecessary struct copies: %d\n", s_numUnnecessaryLastUseStructCopies);
+
 #if DISPLAY_SIZES
 
     if (grossVMsize && grossNCsize)

src/coreclr/jit/compiler.h

@@ -461,6 +461,7 @@ class LclVarDsc
 
     unsigned char lvMustInit : 1; // must be initialized
 
+    bool lvImplicitByRefAddrExposed : 1;
 private:
     bool m_addrExposed : 1; // The address of this variable is "exposed" -- passed as an argument, stored in a
                             // global location, etc.

src/coreclr/jit/morph.cpp

@@ -16666,6 +16666,8 @@ PhaseStatus Compiler::fgRetypeImplicitByRefArgs()
             // Since the parameter in this position is really a pointer, its type is TYP_BYREF.
             varDsc->lvType = TYP_BYREF;
 
+            // 1 if the value of an implicit byref variable is exposed.
+            varDsc->lvImplicitByRefAddrExposed = varDsc->IsAddressExposed();
             // The struct parameter may have had its address taken, but the pointer parameter
             // cannot -- any uses of the struct parameter's address are uses of the pointer
             // parameter's value, and there's no way for the MSIL to reference the pointer