[NFC][IntrRefLDV] Some code clean up

[djtodoro]

Summary

While I was reading the source code, I've found some minor nits:

• Use using instead of typedef
• Fix a comment
• Refactor

[jmorse]

LGTM; thanks for diving in!

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

 class MLocTracker {
 public:
   MachineFunction &MF;
   const TargetInstrInfo &TII;
   const TargetRegisterInfo &TRI;
   const TargetLowering &TLI;
 
   /// IndexedMap type, mapping from LocIdx to ValueIDNum.
-  typedef IndexedMap<ValueIDNum, LocIdxToIndexFunctor> LocToValueType;
+  using LocToValueType = IndexedMap<ValueIDNum, LocIdxToIndexFunctor>;
 
   /// Map of LocIdxes to the ValueIDNums that they store. This is tightly
   /// packed, entries only exist for locations that are being tracked.
   LocToValueType LocIdxToIDNum;
 
   /// "Map" of machine location IDs (i.e., raw register or spill number) to the
   /// LocIdx key / number for that location. There are always at least as many
   /// as the number of registers on the target -- if the value in the register
private:
   using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;
 
   // Helper while building OverlapMap, a map of all fragments seen for a given
   // DILocalVariable.
   using VarToFragments =
       DenseMap<const DILocalVariable *, SmallSet<FragmentInfo, 4>>;
 
   /// Machine location/value transfer function, a mapping of which locations
-  // are assigned which new values.
-  typedef std::map<LocIdx, ValueIDNum> MLocTransferMap;
+  /// are assigned which new values.
+  using MLocTransferMap = std::map<LocIdx, ValueIDNum>;
 
   /// Live in/out structure for the variable values: a per-block map of
   /// variables to their values. XXX, better name?
-  typedef DenseMap<const MachineBasicBlock *,
-                   DenseMap<DebugVariable, DbgValue> *>
-      LiveIdxT;
+  using LiveIdxT =
+      DenseMap<const MachineBasicBlock *, DenseMap<DebugVariable, DbgValue> *>;
 
-  typedef std::pair<DebugVariable, DbgValue> VarAndLoc;
+  using VarAndLoc = std::pair<DebugVariable, DbgValue>;
 
   /// Type for a live-in value: the predecessor block, and its value.
-  typedef std::pair<MachineBasicBlock *, DbgValue *> InValueT;
+  using InValueT = std::pair<MachineBasicBlock *, DbgValue *>;
 
   /// Vector (per block) of a collection (inner smallvector) of live-ins.
   /// Used as the result type for the variable value dataflow problem.
-  typedef SmallVector<SmallVector<VarAndLoc, 8>, 8> LiveInsT;
+  using LiveInsT = SmallVector<SmallVector<VarAndLoc, 8>, 8>;
 
   const TargetRegisterInfo *TRI;
   const TargetInstrInfo *TII;
   const TargetFrameLowering *TFI;
   BitVector CalleeSavedRegs;
   LexicalScopes LS;
   TargetPassConfig *TPC;
 
private:
   SmallPtrSet<const MachineBasicBlock *, 16> ArtificialBlocks;
 
   // Mapping of blocks to and from their RPOT order.
   DenseMap<unsigned int, MachineBasicBlock *> OrderToBB;
   DenseMap<MachineBasicBlock *, unsigned int> BBToOrder;
   DenseMap<unsigned, unsigned> BBNumToRPO;
 
   /// Pair of MachineInstr, and its 1-based offset into the containing block.
-  typedef std::pair<const MachineInstr *, unsigned> InstAndNum;
+  using InstAndNum = std::pair<const MachineInstr *, unsigned>;
   /// Map from debug instruction number to the MachineInstr labelled with that
   /// number, and its location within the function. Used to transform
   /// instruction numbers in DBG_INSTR_REFs into machine value numbers.
   std::map<uint64_t, InstAndNum> DebugInstrNumToInstr;
 
   // Map of overlapping variable fragments.
   OverlapMap OverlapFragments;
   VarToFragments SeenFragments;
for (auto &MBB : MF) {
     for (auto &MI : MBB) {
       process(MI);
       // Also accumulate fragment map.
       if (MI.isDebugValue())
         accumulateFragmentMap(MI);
 
       // Create a map from the instruction number (if present) to the
       // MachineInstr and its position.
-      if (MI.peekDebugInstrNum()) {
-        uint64_t InstrNo = MI.peekDebugInstrNum();
+      if (uint64_t InstrNo = MI.peekDebugInstrNum()) {
         auto InstrAndPos = std::make_pair(&MI, CurInst);
         auto InsertResult =
             DebugInstrNumToInstr.insert(std::make_pair(InstrNo, InstrAndPos));
 
         // There should never be duplicate instruction numbers.
         assert(InsertResult.second);
         (void)InsertResult;
       }
for (auto Location : MTracker->locations()) {
     ValueIDNum PHI = {(uint64_t)MBB.getNumber(), 0, Idx};
     ValueIDNum NewVal = (Disagree && !OverRide) ? PHI : BaseVal;
     if (InLocs[Idx.asU64()] != NewVal) {
       Changed |= true;
       InLocs[Idx.asU64()] = NewVal;
     }
   }
 
-  // Uhhhhhh, reimplement NumInserted and NumRemoved pls.
+  // TODO: Reimplement NumInserted and NumRemoved.
   return std::tuple<bool, bool>(Changed, DowngradeOccurred);
 }
 
 void InstrRefBasedLDV::mlocDataflow(
     ValueIDNum **MInLocs, ValueIDNum **MOutLocs,
     SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
for (auto p : BlockOrders) {
     }
   }
 
   // If there were no locations at all, return an empty result.
   if (Locs.empty())
     return std::tuple<Optional<ValueIDNum>, bool>(None, false);
 
   // Lambda for seeking a common location within a range of location-sets.
-  typedef SmallVector<SmallVector<LocIdx, 4>, 8>::iterator LocsIt;
+  using LocsIt = SmallVector<SmallVector<LocIdx, 4>, 8>::iterator;
   auto SeekLocation =
       [&Locs](llvm::iterator_range<LocsIt> SearchRange) -> Optional<LocIdx> {
     // Starting with the first set of locations, take the intersection with
     // subsequent sets.
     SmallVector<LocIdx, 4> base = Locs[0];
     for (auto &S : SearchRange) {
       SmallVector<LocIdx, 4> new_base;
       std::set_intersection(base.begin(), base.end(), S.begin(), S.end(),