[DebugInfo][NFC] Move out lambdas from collectCallSiteParameters()

[dstenb]

Summary

This is a preparatory patch for D75036, in which a debug expression is
associated with each parameter register in the worklist. In that patch
the two lambda functions addToWorklist() and finishCallSiteParams() grow
a bit, so move those out to separate functions. This patch also prepares
for each parameter register having their own expression moving the
creation of the DbgValueLoc into finishCallSiteParams().

[djtodoro]

Thanks!

[dstenb]

Update after review comment on child patch (use local reference variable for I.first->second).

[dstenb]

Oh, it seems that I missed to specify the repository for this patch. This was pushed as:

commit ff574ff291e73b78164aade9d456d364bbf93a03
Author: David Stenberg <[e-mail]>
Date:   Thu Feb 27 09:53:31 2020 +0100

    [DebugInfo][NFC] Move out lambdas from collectCallSiteParameters()
    
    Summary:
    This is a preparatory patch for D75036, in which a debug expression is
    associated with each parameter register in the worklist. In that patch
    the two lambda functions addToWorklist() and finishCallSiteParams() grow
    a bit, so move those out to separate functions. This patch also prepares
    for each parameter register having their own expression moving the
    creation of the DbgValueLoc into finishCallSiteParams().
    
    Reviewers: djtodoro, vsk
    
    Reviewed By: djtodoro, vsk
    
    Subscribers: hiraditya, llvm-commits
    
    Tags: #debug-info, #llvm
    
    Differential Revision: https://reviews.llvm.org/D75050

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 DIE &DwarfDebug::constructSubprogramDefinitionDIE(const DISubprogram *SP) {
   DICompileUnit *Unit = SP->getUnit();
   assert(SP->isDefinition() && "Subprogram not a definition");
   assert(Unit && "Subprogram definition without parent unit");
   auto &CU = getOrCreateDwarfCompileUnit(Unit);
   return *CU.getOrCreateSubprogramDIE(SP);
 }
 
+/// Register worklist for finding call site values.
+using FwdRegWorklist = MapVector<unsigned, SmallVector<unsigned, 2>>;
+
+/// Emit call site parameter entries that are described by the given value and
+/// debug expression.
+template <typename ValT>
+static void finishCallSiteParams(ValT Val, const DIExpression *Expr,
+                                 ArrayRef<unsigned> DescribedParams,
+                                 ParamSet &Params) {
+  DbgValueLoc DbgLocVal(Expr, Val);
+  for (auto ParamReg : DescribedParams) {
+    DbgCallSiteParam CSParm(ParamReg, DbgLocVal);
+    Params.push_back(CSParm);
+    ++NumCSParams;
+  }
+}
+
+/// Add \p Reg to the worklist, if it's not already present, and mark that the
+/// given parameter registers' values can (potentially) be described using
+/// that register.
+static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg,
+                                ArrayRef<unsigned> ParamsToAdd) {
+  auto I = Worklist.insert({Reg, {}});
+  auto &ParamsForFwdReg = I.first->second;
+  for (auto ParamReg : ParamsToAdd) {
+    assert(!is_contained(ParamsForFwdReg, ParamReg) &&
+           "Same parameter described twice by forwarding reg");
+    ParamsForFwdReg.push_back(ParamReg);
+  }
+}
+
 /// Try to interpret values loaded into registers that forward parameters
 /// for \p CallMI. Store parameters with interpreted value into \p Params.
 static void collectCallSiteParameters(const MachineInstr *CallMI,
                                       ParamSet &Params) {
   auto *MF = CallMI->getMF();
   auto CalleesMap = MF->getCallSitesInfo();
   auto CallFwdRegsInfo = CalleesMap.find(CallMI);
 
   // There is no information for the call instruction.
   if (CallFwdRegsInfo == CalleesMap.end())
     return;
 
   auto *MBB = CallMI->getParent();
   const auto &TRI = MF->getSubtarget().getRegisterInfo();
   const auto &TII = MF->getSubtarget().getInstrInfo();
   const auto &TLI = MF->getSubtarget().getTargetLowering();
 
   // Skip the call instruction.
   auto I = std::next(CallMI->getReverseIterator());
 
-  // Register worklist. Each register has an associated list of parameter
-  // registers whose call site values potentially can be described using that
-  // register.
-  using FwdRegWorklist = MapVector<unsigned, SmallVector<unsigned, 2>>;
-
   FwdRegWorklist ForwardedRegWorklist;
 
   // If an instruction defines more than one item in the worklist, we may run
   // into situations where a worklist register's value is (potentially)
   // described by the previous value of another register that is also defined
   // by that instruction.
   //
   // This can for example occur in cases like this:
static void collectCallSiteParameters(const MachineInstr *CallMI,
   // entry values, we simply postpone adding new parameter registers to the
   // worklist, by first keeping them in this temporary container until the
   // instruction has been handled.
   FwdRegWorklist NewWorklistItems;
 
   // Add all the forwarding registers into the ForwardedRegWorklist.
   for (auto ArgReg : CallFwdRegsInfo->second) {
     bool InsertedReg =
-        ForwardedRegWorklist.insert({ArgReg.Reg, {ArgReg.Reg}}).second;
+        ForwardedRegWorklist.insert({ArgReg.Reg, {{ArgReg.Reg}}}).second;
     assert(InsertedReg && "Single register used to forward two arguments?");
     (void)InsertedReg;
   }
 
   // We erase, from the ForwardedRegWorklist, those forwarding registers for
   // which we successfully describe a loaded value (by using
   // the describeLoadedValue()). For those remaining arguments in the working
   // list, for which we do not describe a loaded value by
for (const MachineOperand &MO : MI.operands()) {
           Register::isPhysicalRegister(MO.getReg())) {
         for (auto FwdReg : ForwardedRegWorklist)
           if (TRI->regsOverlap(FwdReg.first, MO.getReg()))
             Defs.insert(FwdReg.first);
       }
     }
   };
 
-  auto finishCallSiteParams = [&](DbgValueLoc DbgLocVal,
-                                  ArrayRef<unsigned> ParamRegs) {
-    for (auto FwdReg : ParamRegs) {
-      DbgCallSiteParam CSParm(FwdReg, DbgLocVal);
-      Params.push_back(CSParm);
-      ++NumCSParams;
-    }
-  };
-
-  // Add Reg to the worklist, if it's not already present, and mark that the
-  // given parameter registers' values can (potentially) be described using
-  // that register.
-  auto addToWorklist = [](FwdRegWorklist &Worklist, unsigned Reg,
-                          ArrayRef<unsigned> ParamRegs) {
-    auto I = Worklist.insert({Reg, {}});
-    for (auto ParamReg : ParamRegs) {
-      assert(!is_contained(I.first->second, ParamReg) &&
-             "Same parameter described twice by forwarding reg");
-      I.first->second.push_back(ParamReg);
-    }
-  };
-
   // Search for a loading value in forwarding registers.
   for (; I != MBB->rend(); ++I) {
     // Skip bundle headers.
     if (I->isBundle())
       continue;
 
     // If the next instruction is a call we can not interpret parameter's
     // forwarding registers or we finished the interpretation of all parameters.
for (; I != MBB->rend(); ++I) {
     getForwardingRegsDefinedByMI(*I, FwdRegDefs);
     if (FwdRegDefs.empty())
       continue;
 
     for (auto ParamFwdReg : FwdRegDefs) {
       if (auto ParamValue = TII->describeLoadedValue(*I, ParamFwdReg)) {
         if (ParamValue->first.isImm()) {
           int64_t Val = ParamValue->first.getImm();
-          DbgValueLoc DbgLocVal(ParamValue->second, Val);
-          finishCallSiteParams(DbgLocVal, ForwardedRegWorklist[ParamFwdReg]);
+          finishCallSiteParams(Val, ParamValue->second,
+                               ForwardedRegWorklist[ParamFwdReg], Params);
         } else if (ParamValue->first.isReg()) {
           Register RegLoc = ParamValue->first.getReg();
           // TODO: For now, there is no use of describing the value loaded into the
           //       register that is also the source registers (e.g. $r0 = add $r0, x).
           if (ParamFwdReg == RegLoc)
             continue;
 
           unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
           Register FP = TRI->getFrameRegister(*MF);
           bool IsSPorFP = (RegLoc == SP) || (RegLoc == FP);
           if (TRI->isCalleeSavedPhysReg(RegLoc, *MF) || IsSPorFP) {
-            DbgValueLoc DbgLocVal(ParamValue->second,
-                                  MachineLocation(RegLoc,
-                                                  /*IsIndirect=*/IsSPorFP));
-            finishCallSiteParams(DbgLocVal, ForwardedRegWorklist[ParamFwdReg]);
+            MachineLocation MLoc(RegLoc, /*IsIndirect=*/IsSPorFP);
+            finishCallSiteParams(MLoc, ParamValue->second,
+                                 ForwardedRegWorklist[ParamFwdReg], Params);
           // TODO: Add support for entry value plus an expression.
           } else if (ShouldTryEmitEntryVals &&
                      ParamValue->second->getNumElements() == 0) {
             assert(RegLoc != ParamFwdReg &&
                    "Can't handle a register that is described by itself");
             // ParamFwdReg was described by the non-callee saved register
             // RegLoc. Mark that the call site values for the parameters are
             // dependent on that register instead of ParamFwdReg. Since RegLoc
             // may be a register that will be handled in this iteration, we
             // postpone adding the items to the worklist, and instead keep them
             // in a temporary container.
-            addToWorklist(NewWorklistItems, RegLoc,
+            addToFwdRegWorklist(NewWorklistItems, RegLoc,
                                 ForwardedRegWorklist[ParamFwdReg]);
           }
         }
       }
     }
 
     // Remove all registers that this instruction defines from the worklist.
     for (auto ParamFwdReg : FwdRegDefs)
       ForwardedRegWorklist.erase(ParamFwdReg);
 
     // Now that we are done handling this instruction, add items from the
     // temporary worklist to the real one.
     for (auto New : NewWorklistItems)
-      addToWorklist(ForwardedRegWorklist, New.first, New.second);
+      addToFwdRegWorklist(ForwardedRegWorklist, New.first, New.second);
     NewWorklistItems.clear();
   }
 
   // Emit the call site parameter's value as an entry value.
   if (ShouldTryEmitEntryVals) {
     // Create an expression where the register's entry value is used.
     DIExpression *EntryExpr = DIExpression::get(
         MF->getFunction().getContext(), {dwarf::DW_OP_LLVM_entry_value, 1});
     for (auto RegEntry : ForwardedRegWorklist) {
-      DbgValueLoc DbgLocVal(EntryExpr, MachineLocation(RegEntry.first));
-      finishCallSiteParams(DbgLocVal, RegEntry.second);
+      MachineLocation MLoc(RegEntry.first);
+      finishCallSiteParams(MLoc, EntryExpr, RegEntry.second, Params);
     }
   }
 }
 
 void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
                                             DwarfCompileUnit &CU, DIE &ScopeDIE,
                                             const MachineFunction &MF) {
   // Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if