[DebugInfo][InstrRef][NFC] Use unique_ptr instead of raw pointers for value tables

[jmorse]

Summary

InstrRefBasedLDV allocates some big tables of ValueIDNum, to store live-in and live-out block values in, that then get passed around as pointers everywhere. This patch wraps the allocation in a std::unique_ptr, names some types based on unique_ptr, and passes references to those around instead. There's no functional change, but it makes it clearer to the reader that references to these tables are borrowed rather than owned, and we get some extra validity assertions too.

[Orlando]

Nice. I have a few questions / nits but I'm a fan of the change.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

3256–3257

I don't think you need this explicit clean-up on this code path any longer, since the unique_ptr dtor will handle it for you?

3257–3258

If I'm reading this correctly, emitLocations is becomes responsible for managing the object lifetimes (it deletes things from MOutLocs and MInLocs); should you std::move MOutLocs and MInLocs to signify this?

3265–3266

You don't need to call reset since MOutLocs is scoped to this function (the unqiue_ptr's dtor will clean up for you).

[dblaikie]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

2980–2982

if functions like these took their argument by reference instead of pointer this code might be simpler (*MInLocs[bbnum] instead of needing the .get() call)

3159–3166

prefer std::make_unique if possible

3159–3166

Hmm, this causes a lot of allocations - any chance of this being a single allocation of MaxNumBlocks x NumLocs? (of course C++ doesn't support this via "new ValueIDNum[MaxNumBlocks][NumLocs]" (can't have multiple dynamic dimensions) - but a small wrapper type could allocate a flat array and do the x * width + y indexing via operator overloading))

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

Looks like this adds an extra level of indirection that's not needed? FuncValueTable itself could be null (since it's a unique_ptr) rather than needing a pointer to it that is null?

[jmorse]

Jeremy's journey:

• Orlando: "This allocation/free code looks sketchy now,"
• dblaikie: "You should use std::unique_ptr!,"
• asan buildbots: "YOU SHOULD REALLY USE STD::UNIQUE_PTR"

Rebased onto main -- I cut out some dead code paths which now don't need to be updated, removed some un-necessary indirection, and some un-necessary calls to reset() that will now happen automagically due to unique_ptr-ness. I've also updated the unit tests, a purely mechanical change that alters what allocate the value tables.

[jmorse]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

3159–3166

That'd certainly be quicker -- however then it'd be more difficult to reduce peak memory consumption, as the whole table could only be freed in one go.

There's probably a better representation of this information than "big tables in memory", it's not something I've gone near optimising for yet.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

This is true, unfortunately it runs into some technical debt -- in an early phase, InstrRefBasedLDV steps through all instructions but it's too early to know how many registers/slots are going to be tracked, so these value tables aren't allocated yet. That's the only reason why these variables are pointers, so that on the early phase the tables can be optional.

The root cause is that the early phase shares code with later phases: something that can be fixed, but as part of a larger refactor.

[Orlando]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

3257–3258

What did you think of this (for depthFirstVLocAndEmit since emitLocations no longer exists)?

[dblaikie]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

Sorry, I'm not following.

If you remove the extra indirection - concretely, what breaks? The FuncValueTable type is std::unique_ptr, so it can be null when the tables aren't allocated yet, right?

I guess maybe because these are being passed by non-const ref, so they can't have an rvalue as a default argument? They could be passed by const ref instead (since unique_ptr has shallow const). That'd allow the nullptr default argument value.

Though, having tried that manually/locally, and made that compile - maybe going a step further: Pass this as ValueTable* (pointer to the unique_ptr's buffer) since the ownership isn't relevant to the callees here, they just care about a buffer of ValueTables? (call site would have to use X.get() rather than the current &X - so it doesn't make the call site tidier, but does remove the extra indirection)

[jmorse]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

If you remove the extra indirection - concretely, what breaks? The FuncValueTable type is std::unique_ptr, so it can be null when the tables aren't allocated yet, right?

/me scratches head -- apparently I'd never considered unique_ptr acting like a ... normal pointer, which can be null. Yes, that'd work, I'll revise it in.

[jmorse]

Switch to passing an empty unique_ptr for value table arguments, instead of an optional raw pointer to a unique_ptr. This avoids un-necessary raw pointer usage.

[jmorse]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

3257–3258

This is a possibility -- however this will only automatically free the outer dimension, and it'll change deallocation from happening when ExtendRanges returns, to when depthFirstVLocalAndEmit returns, which isn't substantial period of time.

IMO, YMMV, having the outer dimension of value tables allocated/freed by ExtendRanges and always passed by reference to everything else, is cleaner to my mind that passing ownership in so that it can be freed. (I don't think it really matters one way or the other).

[dblaikie]

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

Thoughts on lowering this further, to ValueTable*? (since the clients know the length (unique_ptr doesn't carry the length anyway) & don't need to change the ownership/null out the original unique_ptr, etc)

If it is going to stay as unique_ptr/FuncValueTable - should probably add const on these, since the unique_ptrs themselves aren't changing, only the things they point to, and unique_ptr doesn't have deep const, so it's sort of misleading/makes the reader think maybe the unique_ptr will change?

[jmorse]

clang-format and downgrade arguments to "process" to being ValueTable pointers -- no need to pass in the whole UniquePtr. Add const too.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

925–927

Done and done; the values are only read, so I've both made it ValueTable* and const.

[dblaikie]

Looks good on my side - might be worth checking with @Orlando too before submitting.

[Orlando]

In D118774#3349045, @dblaikie wrote:

Looks good on my side - might be worth checking with @Orlando too before submitting.

LGTM to me too, thanks for checking.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

return Twine("Value{bb: ")
                                             .concat(Twine("}")))))
         .str();
   }
 
   static ValueIDNum EmptyValue;
   static ValueIDNum TombstoneValue;
 };
 
+/// Type for a table of values in a block.
+using ValueTable = std::unique_ptr<ValueIDNum[]>;
+
+/// Type for a table-of-table-of-values, i.e., the collection of either
+/// live-in or live-out values for each block in the function.
+using FuncValueTable = std::unique_ptr<ValueTable[]>;
+
 /// Thin wrapper around an integer -- designed to give more type safety to
 /// spill location numbers.
 class SpillLocationNo {
 public:
   explicit SpillLocationNo(unsigned SpillNo) : SpillNo(SpillNo) {}
   unsigned SpillNo;
   unsigned id() const { return SpillNo; }
 
public:
   void setMPhis(unsigned NewCurBB) {
     CurBB = NewCurBB;
     for (auto Location : locations())
       Location.Value = {CurBB, 0, Location.Idx};
   }
 
   /// Load values for each location from array of ValueIDNums. Take current
   /// bbnum just in case we read a value from a hitherto untouched register.
-  void loadFromArray(ValueIDNum *Locs, unsigned NewCurBB) {
+  void loadFromArray(ValueTable &Locs, unsigned NewCurBB) {
     CurBB = NewCurBB;
     // Iterate over all tracked locations, and load each locations live-in
     // value into our local index.
     for (auto Location : locations())
       Location.Value = Locs[Location.Idx.asU64()];
   }
 
   /// Wipe any un-necessary location records after traversing a block.
Optional<SpillLocationNo> isRestoreInstruction(const MachineInstr &MI,
                                           MachineFunction *MF, unsigned &Reg);
 
   /// Given a spill instruction, extract the spill slot information, ensure it's
   /// tracked, and return the spill number.
   Optional<SpillLocationNo>
   extractSpillBaseRegAndOffset(const MachineInstr &MI);
 
   /// Observe a single instruction while stepping through a block.
-  void process(MachineInstr &MI, ValueIDNum **MLiveOuts = nullptr,
-               ValueIDNum **MLiveIns = nullptr);
+  void process(MachineInstr &MI, const ValueTable *MLiveOuts,
+               const ValueTable *MLiveIns);
 
   /// Examines whether \p MI is a DBG_VALUE and notifies trackers.
   /// \returns true if MI was recognized and processed.
   bool transferDebugValue(const MachineInstr &MI);
 
   /// Examines whether \p MI is a DBG_INSTR_REF and notifies trackers.
   /// \returns true if MI was recognized and processed.
-  bool transferDebugInstrRef(MachineInstr &MI, ValueIDNum **MLiveOuts,
-                             ValueIDNum **MLiveIns);
+  bool transferDebugInstrRef(MachineInstr &MI, const ValueTable *MLiveOuts,
+                             const ValueTable *MLiveIns);
 
   /// Stores value-information about where this PHI occurred, and what
   /// instruction number is associated with it.
   /// \returns true if MI was recognized and processed.
   bool transferDebugPHI(MachineInstr &MI);
 
   /// Examines whether \p MI is copy instruction, and notifies trackers.
   /// \returns true if MI was recognized and processed.
private:
   /// Determine the machine value number referred to by (potentially several)
   /// DBG_PHI instructions. Block duplication and tail folding can duplicate
   /// DBG_PHIs, shifting the position where values in registers merge, and
   /// forming another mini-ssa problem to solve.
   /// \p Here the position of a DBG_INSTR_REF seeking a machine value number
   /// \p InstrNum Debug instruction number defined by DBG_PHI instructions.
   /// \returns The machine value number at position Here, or None.
   Optional<ValueIDNum> resolveDbgPHIs(MachineFunction &MF,
-                                      ValueIDNum **MLiveOuts,
-                                      ValueIDNum **MLiveIns, MachineInstr &Here,
-                                      uint64_t InstrNum);
+                                      const ValueTable *MLiveOuts,
+                                      const ValueTable *MLiveIns,
+                                      MachineInstr &Here, uint64_t InstrNum);
 
   Optional<ValueIDNum> resolveDbgPHIsImpl(MachineFunction &MF,
-                                          ValueIDNum **MLiveOuts,
-                                          ValueIDNum **MLiveIns,
+                                          const ValueTable *MLiveOuts,
+                                          const ValueTable *MLiveIns,
                                           MachineInstr &Here,
                                           uint64_t InstrNum);
 
   /// Step through the function, recording register definitions and movements
   /// in an MLocTracker. Convert the observations into a per-block transfer
   /// function in \p MLocTransfer, suitable for using with the machine value
   /// location dataflow problem.
   void
   produceMLocTransferFunction(MachineFunction &MF,
                               SmallVectorImpl<MLocTransferMap> &MLocTransfer,
                               unsigned MaxNumBlocks);
 
   /// Solve the machine value location dataflow problem. Takes as input the
   /// transfer functions in \p MLocTransfer. Writes the output live-in and
   /// live-out arrays to the (initialized to zero) multidimensional arrays in
   /// \p MInLocs and \p MOutLocs. The outer dimension is indexed by block
   /// number, the inner by LocIdx.
-  void buildMLocValueMap(MachineFunction &MF, ValueIDNum **MInLocs,
-                         ValueIDNum **MOutLocs,
+  void buildMLocValueMap(MachineFunction &MF, FuncValueTable &MInLocs,
+                         FuncValueTable &MOutLocs,
                          SmallVectorImpl<MLocTransferMap> &MLocTransfer);
 
   /// Examine the stack indexes (i.e. offsets within the stack) to find the
   /// basic units of interference -- like reg units, but for the stack.
   void findStackIndexInterference(SmallVectorImpl<unsigned> &Slots);
 
   /// Install PHI values into the live-in array for each block, according to
   /// the IDF of each register.
   void placeMLocPHIs(MachineFunction &MF,
                      SmallPtrSetImpl<MachineBasicBlock *> &AllBlocks,
-                     ValueIDNum **MInLocs,
+                     FuncValueTable &MInLocs,
                      SmallVectorImpl<MLocTransferMap> &MLocTransfer);
 
   /// Propagate variable values to blocks in the common case where there's
   /// only one value assigned to the variable. This function has better
   /// performance as it doesn't have to find the dominance frontier between
   /// different assignments.
   void placePHIsForSingleVarDefinition(
           const SmallPtrSetImpl<MachineBasicBlock *> &InScopeBlocks,
private:
   /// locations at \p MBB. Follows the algorithm described in the file-comment,
   /// reading live-outs of predecessors from \p OutLocs, the current live ins
   /// from \p InLocs, and assigning the newly computed live ins back into
   /// \p InLocs. \returns two bools -- the first indicates whether a change
   /// was made, the second whether a lattice downgrade occurred. If the latter
   /// is true, revisiting this block is necessary.
   bool mlocJoin(MachineBasicBlock &MBB,
                 SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
-                ValueIDNum **OutLocs, ValueIDNum *InLocs);
+                FuncValueTable &OutLocs, ValueTable &InLocs);
 
   /// Produce a set of blocks that are in the current lexical scope. This means
   /// those blocks that contain instructions "in" the scope, blocks where
   /// assignments to variables in scope occur, and artificial blocks that are
   /// successors to any of the earlier blocks. See https://llvm.org/PR48091 for
   /// more commentry on what "in scope" means.
   /// \p DILoc A location in the scope that we're fetching blocks for.
   /// \p Output Set to put in-scope-blocks into.
private:
   /// Live-in and Live-out variable values are stored locally, with the live-ins
   /// permanently stored to \p Output once a fixedpoint is reached.
   /// \p VarsWeCareAbout contains a collection of the variables in \p Scope
   /// that we should be tracking.
   /// \p AssignBlocks contains the set of blocks that aren't in \p DILoc's
   /// scope, but which do contain DBG_VALUEs, which VarLocBasedImpl tracks
   /// locations through.
   void buildVLocValueMap(const DILocation *DILoc,
                          const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
                          SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks,
-                    LiveInsT &Output, ValueIDNum **MOutLocs,
-                    ValueIDNum **MInLocs,
+                         LiveInsT &Output, FuncValueTable &MOutLocs,
+                         FuncValueTable &MInLocs,
                          SmallVectorImpl<VLocTracker> &AllTheVLocs);
 
   /// Attempt to eliminate un-necessary PHIs on entry to a block. Examines the
   /// live-in values coming from predecessors live-outs, and replaces any PHIs
   /// already present in this blocks live-ins with a live-through value if the
   /// PHI isn't needed.
   /// \p LiveIn Old live-in value, overwritten with new one if live-in changes.
   /// \returns true if any live-ins change value, either from value propagation
   ///          or PHI elimination.
   bool vlocJoin(MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
                 DbgValue &LiveIn);
 
   /// For the given block and live-outs feeding into it, try to find a
   /// machine location where all the variable values join together.
   /// \returns Value ID of a machine PHI if an appropriate one is available.
   Optional<ValueIDNum>
   pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
-              const LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
+              const LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders);
 
   /// Take collections of DBG_VALUE instructions stored in TTracker, and
   /// install them into their output blocks. Preserves a stable order of
   /// DBG_VALUEs produced (which would otherwise cause nondeterminism) through
   /// the AllVarsNumbering order.
   bool emitTransfers(DenseMap<DebugVariable, unsigned> &AllVarsNumbering);
 
private:
   /// When determining per-block variable values and emitting to DBG_VALUEs,
   /// this function explores by lexical scope depth. Doing so means that per
   /// block information can be fully computed before exploration finishes,
   /// allowing us to emit it and free data structures earlier than otherwise.
   /// It's also good for locality.
   bool depthFirstVLocAndEmit(
       unsigned MaxNumBlocks, const ScopeToDILocT &ScopeToDILocation,
       const ScopeToVarsT &ScopeToVars, ScopeToAssignBlocksT &ScopeToBlocks,
-      LiveInsT &Output, ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
+      LiveInsT &Output, FuncValueTable &MOutLocs, FuncValueTable &MInLocs,
       SmallVectorImpl<VLocTracker> &AllTheVLocs, MachineFunction &MF,
       DenseMap<DebugVariable, unsigned> &AllVarsNumbering,
       const TargetPassConfig &TPC);
 
   bool ExtendRanges(MachineFunction &MF, MachineDominatorTree *DomTree,
                     TargetPassConfig *TPC, unsigned InputBBLimit,
                     unsigned InputDbgValLimit) override;
 

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

public:
 
   /// Load object with live-in variable values. \p mlocs contains the live-in
   /// values in each machine location, while \p vlocs the live-in variable
   /// values. This method picks variable locations for the live-in variables,
   /// creates DBG_VALUEs and puts them in #Transfers, then prepares the other
   /// object fields to track variable locations as we step through the block.
   /// FIXME: could just examine mloctracker instead of passing in \p mlocs?
   void
-  loadInlocs(MachineBasicBlock &MBB, ValueIDNum *MLocs,
+  loadInlocs(MachineBasicBlock &MBB, ValueTable &MLocs,
              const SmallVectorImpl<std::pair<DebugVariable, DbgValue>> &VLocs,
              unsigned NumLocs) {
     ActiveMLocs.clear();
     ActiveVLocs.clear();
     VarLocs.clear();
     VarLocs.reserve(NumLocs);
     UseBeforeDefs.clear();
     UseBeforeDefVariables.clear();
bool InstrRefBasedLDV::transferDebugValue(const MachineInstr &MI) {
   // If performing final tracking of transfers, report this variable definition
   // to the TransferTracker too.
   if (TTracker)
     TTracker->redefVar(MI);
   return true;
 }
 
 bool InstrRefBasedLDV::transferDebugInstrRef(MachineInstr &MI,
-                                             ValueIDNum **MLiveOuts,
-                                             ValueIDNum **MLiveIns) {
+                                             const ValueTable *MLiveOuts,
+                                             const ValueTable *MLiveIns) {
   if (!MI.isDebugRef())
     return false;
 
   // Only handle this instruction when we are building the variable value
   // transfer function.
   if (!VTracker && !TTracker)
     return false;
 
if (DIExpression::fragmentsOverlap(ThisFragment, ASeenFragment)) {
              "Previously seen var fragment has no vector of overlaps");
       ASeenFragmentsOverlaps->second.push_back(ThisFragment);
     }
   }
 
   AllSeenFragments.insert(ThisFragment);
 }
 
-void InstrRefBasedLDV::process(MachineInstr &MI, ValueIDNum **MLiveOuts,
-                               ValueIDNum **MLiveIns) {
+void InstrRefBasedLDV::process(MachineInstr &MI, const ValueTable *MLiveOuts,
+                               const ValueTable *MLiveIns) {
   // Try to interpret an MI as a debug or transfer instruction. Only if it's
   // none of these should we interpret it's register defs as new value
   // definitions.
   if (transferDebugValue(MI))
     return;
   if (transferDebugInstrRef(MI, MLiveOuts, MLiveIns))
     return;
   if (transferDebugPHI(MI))
for (auto &MBB : MF) {
 
     // Set all machine locations to a PHI value. For transfer function
     // production only, this signifies the live-in value to the block.
     MTracker->reset();
     MTracker->setMPhis(CurBB);
 
     // Step through each instruction in this block.
     for (auto &MI : MBB) {
-      process(MI);
+      // Pass in an empty unique_ptr for the value tables when accumulating the
+      // machine transfer function.
+      process(MI, nullptr, nullptr);
+
       // Also accumulate fragment map.
       if (MI.isDebugValue() || MI.isDebugRef())
         accumulateFragmentMap(MI);
 
       // Create a map from the instruction number (if present) to the
       // MachineInstr and its position.
       if (uint64_t InstrNo = MI.peekDebugInstrNum()) {
         auto InstrAndPos = std::make_pair(&MI, CurInst);
for (unsigned Bit : BV.set_bits()) {
           ValueID = NotGeneratedNum;
       }
     }
   }
 }
 
 bool InstrRefBasedLDV::mlocJoin(
     MachineBasicBlock &MBB, SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
-    ValueIDNum **OutLocs, ValueIDNum *InLocs) {
+    FuncValueTable &OutLocs, ValueTable &InLocs) {
   LLVM_DEBUG(dbgs() << "join MBB: " << MBB.getNumber() << "\n");
   bool Changed = false;
 
   // Handle value-propagation when control flow merges on entry to a block. For
   // any location without a PHI already placed, the location has the same value
   // as its predecessors. If a PHI is placed, test to see whether it's now a
   // redundant PHI that we can eliminate.
 
for (auto &Pair : MTracker->StackSlotIdxes) {
     if (!Pair.first.second)
       continue;
     Slots.push_back(Pair.second);
   }
 }
 
 void InstrRefBasedLDV::placeMLocPHIs(
     MachineFunction &MF, SmallPtrSetImpl<MachineBasicBlock *> &AllBlocks,
-    ValueIDNum **MInLocs, SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
+    FuncValueTable &MInLocs, SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
   SmallVector<unsigned, 4> StackUnits;
   findStackIndexInterference(StackUnits);
 
   // To avoid repeatedly running the PHI placement algorithm, leverage the
   // fact that a def of register MUST also def its register units. Find the
   // units for registers, place PHIs for them, and then replicate them for
   // aliasing registers. Some inputs that are never def'd (DBG_PHIs of
   // arguments) don't lead to register units being tracked, just place PHIs for
for (MCRegAliasIterator RAI(R, TRI, true); RAI.isValid(); ++RAI) {
 
       LocIdx AliasLoc = MTracker->lookupOrTrackRegister(*RAI);
       InstallPHIsAtLoc(AliasLoc);
     }
   }
 }
 
 void InstrRefBasedLDV::buildMLocValueMap(
-    MachineFunction &MF, ValueIDNum **MInLocs, ValueIDNum **MOutLocs,
+    MachineFunction &MF, FuncValueTable &MInLocs, FuncValueTable &MOutLocs,
     SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
       Worklist, Pending;
 
   // We track what is on the current and pending worklist to avoid inserting
   // the same thing twice. We could avoid this with a custom priority queue,
   // but this is probably not worth it.
void InstrRefBasedLDV::BlockPHIPlacement(
 
   IDF.setLiveInBlocks(AllBlocks);
   IDF.setDefiningBlocks(DefBlocks);
   IDF.calculate(PHIBlocks);
 }
 
 Optional<ValueIDNum> InstrRefBasedLDV::pickVPHILoc(
     const MachineBasicBlock &MBB, const DebugVariable &Var,
-    const LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
+    const LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
     const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
   // Collect a set of locations from predecessor where its live-out value can
   // be found.
   SmallVector<SmallVector<LocIdx, 4>, 8> Locs;
   SmallVector<const DbgValueProperties *, 4> Properties;
   unsigned NumLocs = MTracker->getNumLocs();
 
   // No predecessors means no PHIs.
void InstrRefBasedLDV::getBlocksForScope(
   };
 
   BlocksToExplore.insert(ToAdd.begin(), ToAdd.end());
 }
 
 void InstrRefBasedLDV::buildVLocValueMap(
     const DILocation *DILoc, const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
     SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks, LiveInsT &Output,
-    ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
+    FuncValueTable &MOutLocs, FuncValueTable &MInLocs,
     SmallVectorImpl<VLocTracker> &AllTheVLocs) {
   // This method is much like buildMLocValueMap: but focuses on a single
   // LexicalScope at a time. Pick out a set of blocks and variables that are
   // to have their value assignments solved, then run our dataflow algorithm
   // until a fixedpoint is reached.
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
       Worklist, Pending;
if (ChildNum >= 0) {
       }
     }
   }
 }
 
 bool InstrRefBasedLDV::depthFirstVLocAndEmit(
     unsigned MaxNumBlocks, const ScopeToDILocT &ScopeToDILocation,
     const ScopeToVarsT &ScopeToVars, ScopeToAssignBlocksT &ScopeToAssignBlocks,
-    LiveInsT &Output, ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
+    LiveInsT &Output, FuncValueTable &MOutLocs, FuncValueTable &MInLocs,
     SmallVectorImpl<VLocTracker> &AllTheVLocs, MachineFunction &MF,
     DenseMap<DebugVariable, unsigned> &AllVarsNumbering,
     const TargetPassConfig &TPC) {
   TTracker = new TransferTracker(TII, MTracker, MF, *TRI, CalleeSavedRegs, TPC);
   unsigned NumLocs = MTracker->getNumLocs();
   VTracker = nullptr;
 
   // No scopes? No variable locations.
-  if (!LS.getCurrentFunctionScope()) {
-    // FIXME: this is a sticking plaster to prevent a memory leak, these
-    // pointers will be automagically freed by being unique pointers, shortly.
-    for (unsigned int I = 0; I < MaxNumBlocks; ++I) {
-      delete[] MInLocs[I];
-      delete[] MOutLocs[I];
-    }
+  if (!LS.getCurrentFunctionScope())
     return false;
-  }
 
   // Build map from block number to the last scope that uses the block.
   SmallVector<unsigned, 16> EjectionMap;
   EjectionMap.resize(MaxNumBlocks, 0);
   makeDepthFirstEjectionMap(EjectionMap, ScopeToDILocation,
                             ScopeToAssignBlocks);
 
   // Helper lambda for ejecting a block -- if nothing is going to use the block,
   // we can translate the variable location information into DBG_VALUEs and then
   // free all of InstrRefBasedLDV's data structures.
   auto EjectBlock = [&](MachineBasicBlock &MBB) -> void {
     unsigned BBNum = MBB.getNumber();
     AllTheVLocs[BBNum].clear();
 
     // Prime the transfer-tracker, and then step through all the block
     // instructions, installing transfers.
     MTracker->reset();
     MTracker->loadFromArray(MInLocs[BBNum], BBNum);
     TTracker->loadInlocs(MBB, MInLocs[BBNum], Output[BBNum], NumLocs);
 
     CurBB = BBNum;
     CurInst = 1;
     for (auto &MI : MBB) {
-      process(MI, MOutLocs, MInLocs);
+      process(MI, MOutLocs.get(), MInLocs.get());
       TTracker->checkInstForNewValues(CurInst, MI.getIterator());
       ++CurInst;
     }
 
     // Free machine-location tables for this block.
-    delete[] MInLocs[BBNum];
-    delete[] MOutLocs[BBNum];
-    // Make ourselves brittle to use-after-free errors.
-    MInLocs[BBNum] = nullptr;
-    MOutLocs[BBNum] = nullptr;
+    MInLocs[BBNum].reset();
+    MOutLocs[BBNum].reset();
     // We don't need live-in variable values for this block either.
     Output[BBNum].clear();
     AllTheVLocs[BBNum].clear();
   };
 
   SmallPtrSet<const MachineBasicBlock *, 8> BlocksToExplore;
   SmallVector<std::pair<LexicalScope *, ssize_t>, 4> WorkStack;
   WorkStack.push_back({LS.getCurrentFunctionScope(), 0});
bool InstrRefBasedLDV::depthFirstVLocAndEmit(
   // connected to an actual legitimate scope. This can technically happen
   // with things like the entry block. In theory, we shouldn't need to do
   // anything for such out-of-scope blocks, but for the sake of being similar
   // to VarLocBasedLDV, eject these too.
   for (auto *MBB : ArtificialBlocks)
     if (MOutLocs[MBB->getNumber()])
       EjectBlock(*MBB);
 
-  // Finally, there might have been gaps in the block numbering, from dead
-  // blocks being deleted or folded. In those scenarios, we might allocate a
-  // block-table that's never ejected, meaning we have to free it at the end.
-  for (unsigned int I = 0; I < MaxNumBlocks; ++I) {
-    if (MInLocs[I]) {
-      delete[] MInLocs[I];
-      delete[] MOutLocs[I];
-    }
-  }
-
   return emitTransfers(AllVarsNumbering);
 }
 
 bool InstrRefBasedLDV::emitTransfers(
     DenseMap<DebugVariable, unsigned> &AllVarsNumbering) {
   // Go through all the transfers recorded in the TransferTracker -- this is
   // both the live-ins to a block, and any movements of values that happen
   // in the middle.
bool InstrRefBasedLDV::ExtendRanges(MachineFunction &MF,
 
   initialSetup(MF);
 
   produceMLocTransferFunction(MF, MLocTransfer, MaxNumBlocks);
 
   // Allocate and initialize two array-of-arrays for the live-in and live-out
   // machine values. The outer dimension is the block number; while the inner
   // dimension is a LocIdx from MLocTracker.
-  ValueIDNum **MOutLocs = new ValueIDNum *[MaxNumBlocks];
-  ValueIDNum **MInLocs = new ValueIDNum *[MaxNumBlocks];
+  FuncValueTable MOutLocs = std::make_unique<ValueTable[]>(MaxNumBlocks);
+  FuncValueTable MInLocs = std::make_unique<ValueTable[]>(MaxNumBlocks);
   unsigned NumLocs = MTracker->getNumLocs();
   for (int i = 0; i < MaxNumBlocks; ++i) {
     // These all auto-initialize to ValueIDNum::EmptyValue
-    MOutLocs[i] = new ValueIDNum[NumLocs];
-    MInLocs[i] = new ValueIDNum[NumLocs];
+    MOutLocs[i] = std::make_unique<ValueIDNum[]>(NumLocs);
+    MInLocs[i] = std::make_unique<ValueIDNum[]>(NumLocs);
   }
 
   // Solve the machine value dataflow problem using the MLocTransfer function,
   // storing the computed live-ins / live-outs into the array-of-arrays. We use
   // both live-ins and live-outs for decision making in the variable value
   // dataflow problem.
   buildMLocValueMap(MF, MInLocs, MOutLocs, MLocTransfer);
 
   // Patch up debug phi numbers, turning unknown block-live-in values into
bool InstrRefBasedLDV::ExtendRanges(MachineFunction &MF,
   for (auto &OrderPair : OrderToBB) {
     MachineBasicBlock &MBB = *OrderPair.second;
     CurBB = MBB.getNumber();
     VTracker = &vlocs[CurBB];
     VTracker->MBB = &MBB;
     MTracker->loadFromArray(MInLocs[CurBB], CurBB);
     CurInst = 1;
     for (auto &MI : MBB) {
-      process(MI, MOutLocs, MInLocs);
+      process(MI, MOutLocs.get(), MInLocs.get());
       ++CurInst;
     }
     MTracker->reset();
   }
 
   // Number all variables in the order that they appear, to be used as a stable
   // insertion order later.
   DenseMap<DebugVariable, unsigned> AllVarsNumbering;
bool InstrRefBasedLDV::ExtendRanges(MachineFunction &MF,
   // If we have an extremely large number of variable assignments and blocks,
   // bail out at this point. We've burnt some time doing analysis already,
   // however we should cut our losses.
   if ((unsigned)MaxNumBlocks > InputBBLimit &&
       VarAssignCount > InputDbgValLimit) {
     LLVM_DEBUG(dbgs() << "Disabling InstrRefBasedLDV: " << MF.getName()
                       << " has " << MaxNumBlocks << " basic blocks and "
                       << VarAssignCount
                       << " variable assignments, exceeding limits.\n");
-
-    // Perform memory cleanup that emitLocations would do otherwise.
-    for (int Idx = 0; Idx < MaxNumBlocks; ++Idx) {
-      delete[] MOutLocs[Idx];
-      delete[] MInLocs[Idx];
-    }
   } else {
     // Optionally, solve the variable value problem and emit to blocks by using
     // a lexical-scope-depth search. It should be functionally identical to
     // the "else" block of this condition.
     Changed = depthFirstVLocAndEmit(
         MaxNumBlocks, ScopeToDILocation, ScopeToVars, ScopeToAssignBlocks,
         SavedLiveIns, MOutLocs, MInLocs, vlocs, MF, AllVarsNumbering, *TPC);
   }
 
-  // Elements of these arrays will be deleted by emitLocations.
-  delete[] MOutLocs;
-  delete[] MInLocs;
-
   delete MTracker;
   delete TTracker;
   MTracker = nullptr;
   VTracker = nullptr;
   TTracker = nullptr;
 
   ArtificialBlocks.clear();
   OrderToBB.clear();
   BBToOrder.clear();
public:
   /// Map of which blocks generate Undef values -- blocks that are not
   /// dominated by any Def.
   DenseMap<MachineBasicBlock *, BlockValueNum> UndefMap;
   /// Map of machine blocks to our own records of them.
   DenseMap<MachineBasicBlock *, LDVSSABlock *> BlockMap;
   /// Machine location where any PHI must occur.
   LocIdx Loc;
   /// Table of live-in machine value numbers for blocks / locations.
-  ValueIDNum **MLiveIns;
+  const ValueTable *MLiveIns;
 
-  LDVSSAUpdater(LocIdx L, ValueIDNum **MLiveIns) : Loc(L), MLiveIns(MLiveIns) {}
+  LDVSSAUpdater(LocIdx L, const ValueTable *MLiveIns)
+      : Loc(L), MLiveIns(MLiveIns) {}
 
   void reset() {
     for (auto &Block : BlockMap)
       delete Block.second;
 
     PHIs.clear();
     UndefMap.clear();
     BlockMap.clear();
public:
 
   /// GetPHIValue - For the specified PHI instruction, return the value
   /// that it defines.
   static BlockValueNum GetPHIValue(LDVSSAPhi *PHI) { return PHI->PHIValNum; }
 };
 
 } // end namespace llvm
 
-Optional<ValueIDNum> InstrRefBasedLDV::resolveDbgPHIs(MachineFunction &MF,
-                                                      ValueIDNum **MLiveOuts,
-                                                      ValueIDNum **MLiveIns,
-                                                      MachineInstr &Here,
-                                                      uint64_t InstrNum) {
+Optional<ValueIDNum> InstrRefBasedLDV::resolveDbgPHIs(
+    MachineFunction &MF, const ValueTable *MLiveOuts,
+    const ValueTable *MLiveIns, MachineInstr &Here, uint64_t InstrNum) {
+  assert(MLiveOuts && MLiveIns &&
+         "Tried to resolve DBG_PHI before location "
+         "tables allocated?");
+
   // This function will be called twice per DBG_INSTR_REF, and might end up
   // computing lots of SSA information: memoize it.
   auto SeenDbgPHIIt = SeenDbgPHIs.find(&Here);
   if (SeenDbgPHIIt != SeenDbgPHIs.end())
     return SeenDbgPHIIt->second;
 
   Optional<ValueIDNum> Result =
       resolveDbgPHIsImpl(MF, MLiveOuts, MLiveIns, Here, InstrNum);
   SeenDbgPHIs.insert({&Here, Result});
   return Result;
 }
 
 Optional<ValueIDNum> InstrRefBasedLDV::resolveDbgPHIsImpl(
-    MachineFunction &MF, ValueIDNum **MLiveOuts, ValueIDNum **MLiveIns,
-    MachineInstr &Here, uint64_t InstrNum) {
+    MachineFunction &MF, const ValueTable *MLiveOuts,
+    const ValueTable *MLiveIns, MachineInstr &Here, uint64_t InstrNum) {
   // Pick out records of DBG_PHI instructions that have been observed. If there
   // are none, then we cannot compute a value number.
   auto RangePair = std::equal_range(DebugPHINumToValue.begin(),
                                     DebugPHINumToValue.end(), InstrNum);
   auto LowerIt = RangePair.first;
   auto UpperIt = RangePair.second;
 
   // No DBG_PHI means there can be no location.
for (auto &PHI : SortedPHIs) {
 
     // Are all these things actually defined?
     for (auto &PHIIt : PHI->IncomingValues) {
       // Any undef input means DBG_PHIs didn't dominate the use point.
       if (Updater.UndefMap.find(&PHIIt.first->BB) != Updater.UndefMap.end())
         return None;
 
       ValueIDNum ValueToCheck;
-      ValueIDNum *BlockLiveOuts = MLiveOuts[PHIIt.first->BB.getNumber()];
+      const ValueTable &BlockLiveOuts = MLiveOuts[PHIIt.first->BB.getNumber()];
 
       auto VVal = ValidatedValues.find(PHIIt.first);
       if (VVal == ValidatedValues.end()) {
         // We cross a loop, and this is a backedge. LLVMs tail duplication
         // happens so late that DBG_PHI instructions should not be able to
         // migrate into loops -- meaning we can only be live-through this
         // loop.
         ValueToCheck = ThisBlockValueNum;

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

public:
 
   void addVTracker() {
     ASSERT_TRUE(LDV);
     VTracker = std::make_unique<VLocTracker>(Overlaps, EmptyExpr);
     LDV->VTracker = &*VTracker;
   }
 
   // Some routines for bouncing into LDV,
-  void buildMLocValueMap(ValueIDNum **MInLocs, ValueIDNum **MOutLocs,
+  void buildMLocValueMap(FuncValueTable &MInLocs, FuncValueTable &MOutLocs,
                          SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
     LDV->buildMLocValueMap(*MF, MInLocs, MOutLocs, MLocTransfer);
   }
 
   void placeMLocPHIs(MachineFunction &MF,
                      SmallPtrSetImpl<MachineBasicBlock *> &AllBlocks,
-                     ValueIDNum **MInLocs,
+                     FuncValueTable &MInLocs,
                      SmallVectorImpl<MLocTransferMap> &MLocTransfer) {
     LDV->placeMLocPHIs(MF, AllBlocks, MInLocs, MLocTransfer);
   }
 
   Optional<ValueIDNum>
   pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
-              const InstrRefBasedLDV::LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
+              const InstrRefBasedLDV::LiveIdxT &LiveOuts, FuncValueTable &MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
     return LDV->pickVPHILoc(MBB, Var, LiveOuts, MOutLocs, BlockOrders);
   }
 
   bool vlocJoin(MachineBasicBlock &MBB, InstrRefBasedLDV::LiveIdxT &VLOCOutLocs,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
                 DbgValue &InLoc) {
     return LDV->vlocJoin(MBB, VLOCOutLocs, BlocksToExplore, InLoc);
   }
 
   void buildVLocValueMap(const DILocation *DILoc,
                     const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
                     SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks,
-                    InstrRefBasedLDV::LiveInsT &Output, ValueIDNum **MOutLocs,
-                    ValueIDNum **MInLocs,
+                    InstrRefBasedLDV::LiveInsT &Output, FuncValueTable &MOutLocs,
+                    FuncValueTable &MInLocs,
                     SmallVectorImpl<VLocTracker> &AllTheVLocs) {
     LDV->buildVLocValueMap(DILoc, VarsWeCareAbout, AssignBlocks, Output,
                            MOutLocs, MInLocs, AllTheVLocs);
   }
 
-  void initValueArray(ValueIDNum **Nums, unsigned Blks, unsigned Locs) {
+  void initValueArray(FuncValueTable &Nums, unsigned Blks, unsigned Locs) {
     for (unsigned int I = 0; I < Blks; ++I)
       for (unsigned int J = 0; J < Locs; ++J)
         Nums[I][J] = ValueIDNum::EmptyValue;
   }
 
   void setupSingleBlock() {
     // Add an entry block with nothing but 'ret void' in it.
     Function &F = const_cast<llvm::Function &>(MF->getFunction());
)MIR") + Twine(Input) + Twine("...\n"))
   }
 
   void
   produceMLocTransferFunction(MachineFunction &MF,
                               SmallVectorImpl<MLocTransferMap> &MLocTransfer,
                               unsigned MaxNumBlocks) {
     LDV->produceMLocTransferFunction(MF, MLocTransfer, MaxNumBlocks);
   }
+
+  std::pair<FuncValueTable, FuncValueTable>
+  allocValueTables(unsigned Blocks, unsigned Locs) {
+    FuncValueTable MOutLocs = std::make_unique<ValueTable[]>(Blocks);
+    FuncValueTable MInLocs = std::make_unique<ValueTable[]>(Blocks);
+
+    for (unsigned int I = 0; I < Blocks; ++I) {
+      MOutLocs[I] = std::make_unique<ValueIDNum[]>(Locs);
+      MInLocs[I] = std::make_unique<ValueIDNum[]>(Locs);
+    }
+
+    return std::make_pair(std::move(MOutLocs), std::move(MInLocs));
+  }
 };
 
 TEST_F(InstrRefLDVTest, MTransferDefs) {
   MachineFunction *MF = readMIRBlock(
    "    $rax = MOV64ri 0\n"
    "    RET64 $rax\n");
   setupLDVObj(MF);
 
TEST_F(InstrRefLDVTest, MLocSingleBlock) {
   setupSingleBlock();
 
   // We should start with a single location, the stack pointer.
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
 
   // Set up live-in and live-out tables for this function: two locations (we
   // add one later) in a single block.
-  ValueIDNum InLocs[2], OutLocs[2];
-  ValueIDNum *InLocsPtr[1] = {&InLocs[0]};
-  ValueIDNum *OutLocsPtr[1] = {&OutLocs[0]};
+  FuncValueTable MOutLocs, MInLocs;
+  std::tie(MOutLocs, MInLocs) = allocValueTables(1, 2);
 
   // Transfer function: nothing.
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(1);
 
   // Try and build value maps...
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
 
   // The result should be that RSP is marked as a live-in-PHI -- this represents
   // an argument. And as there's no transfer function, the block live-out should
   // be the same.
-  EXPECT_EQ(InLocs[0], ValueIDNum(0, 0, RspLoc));
-  EXPECT_EQ(OutLocs[0], ValueIDNum(0, 0, RspLoc));
+  EXPECT_EQ(MInLocs[0][0], ValueIDNum(0, 0, RspLoc));
+  EXPECT_EQ(MOutLocs[0][0], ValueIDNum(0, 0, RspLoc));
 
   // Try again, this time initialising the in-locs to be defined by an
   // instruction. The entry block should always be re-assigned to be the
   // arguments.
-  initValueArray(InLocsPtr, 1, 2);
-  initValueArray(OutLocsPtr, 1, 2);
-  InLocs[0] = ValueIDNum(0, 1, RspLoc);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0], ValueIDNum(0, 0, RspLoc));
-  EXPECT_EQ(OutLocs[0], ValueIDNum(0, 0, RspLoc));
+  initValueArray(MInLocs, 1, 2);
+  initValueArray(MOutLocs, 1, 2);
+  MInLocs[0][0] = ValueIDNum(0, 1, RspLoc);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], ValueIDNum(0, 0, RspLoc));
+  EXPECT_EQ(MOutLocs[0][0], ValueIDNum(0, 0, RspLoc));
 
   // Now insert something into the transfer function to assign to the single
   // machine location.
   TransferFunc[0].insert({RspLoc, ValueIDNum(0, 1, RspLoc)});
-  initValueArray(InLocsPtr, 1, 2);
-  initValueArray(OutLocsPtr, 1, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0], ValueIDNum(0, 0, RspLoc));
-  EXPECT_EQ(OutLocs[0], ValueIDNum(0, 1, RspLoc));
+  initValueArray(MInLocs, 1, 2);
+  initValueArray(MOutLocs, 1, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], ValueIDNum(0, 0, RspLoc));
+  EXPECT_EQ(MOutLocs[0][0], ValueIDNum(0, 1, RspLoc));
   TransferFunc[0].clear();
 
   // Add a new register to be tracked, and insert it into the transfer function
   // as a copy. The output of $rax should be the live-in value of $rsp.
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
   TransferFunc[0].insert({RspLoc, ValueIDNum(0, 1, RspLoc)});
   TransferFunc[0].insert({RaxLoc, ValueIDNum(0, 0, RspLoc)});
-  initValueArray(InLocsPtr, 1, 2);
-  initValueArray(OutLocsPtr, 1, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0], ValueIDNum(0, 0, RspLoc));
-  EXPECT_EQ(InLocs[1], ValueIDNum(0, 0, RaxLoc));
-  EXPECT_EQ(OutLocs[0], ValueIDNum(0, 1, RspLoc));
-  EXPECT_EQ(OutLocs[1], ValueIDNum(0, 0, RspLoc)); // Rax contains RspLoc.
+  initValueArray(MInLocs, 1, 2);
+  initValueArray(MOutLocs, 1, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], ValueIDNum(0, 0, RspLoc));
+  EXPECT_EQ(MInLocs[0][1], ValueIDNum(0, 0, RaxLoc));
+  EXPECT_EQ(MOutLocs[0][0], ValueIDNum(0, 1, RspLoc));
+  EXPECT_EQ(MOutLocs[0][1], ValueIDNum(0, 0, RspLoc)); // Rax contains RspLoc.
   TransferFunc[0].clear();
 }
 
 TEST_F(InstrRefLDVTest, MLocDiamondBlocks) {
   // Test that information flows from the entry block to two successors.
   //        entry
   //        /  \
   //      br1  br2
   //        \  /
   //         ret
   setupDiamondBlocks();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum InLocs[4][2], OutLocs[4][2];
-  ValueIDNum *InLocsPtr[4] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3]};
-  ValueIDNum *OutLocsPtr[4] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(4, 2);
 
   // Transfer function: start with nothing.
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(4);
 
   // Name some values.
   unsigned EntryBlk = 0, BrBlk1 = 1, BrBlk2 = 2, RetBlk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum RspDefInBlk0(EntryBlk, 1, RspLoc);
   ValueIDNum RspDefInBlk1(BrBlk1, 1, RspLoc);
   ValueIDNum RspDefInBlk2(BrBlk2, 1, RspLoc);
   ValueIDNum RspPHIInBlk3(RetBlk, 0, RspLoc);
   ValueIDNum RaxLiveInBlk1(BrBlk1, 0, RaxLoc);
   ValueIDNum RaxLiveInBlk2(BrBlk2, 0, RaxLoc);
 
   // With no transfer function, the live-in values to the entry block should
   // propagate to all live-outs and the live-ins to the two successor blocks.
   // IN ADDITION: this checks that the exit block doesn't get a PHI put in it.
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
   // (Skipped writing out locations for $rax).
 
   // Check that a def of $rsp in the entry block will likewise reach all the
   // successors.
   TransferFunc[0].insert({RspLoc, RspDefInBlk0});
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[0][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk0);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[0][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk0);
   TransferFunc[0].clear();
 
   // Def in one branch of the diamond means that we need a PHI in the ret block
   TransferFunc[0].insert({RspLoc, RspDefInBlk0});
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
   // This value map: like above, where RspDefInBlk0 is propagated through one
   // branch of the diamond, but is def'ed in the live-outs of the other. The
   // ret / merging block should have a PHI in its live-ins.
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[0][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[3][0], RspPHIInBlk3);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
 
   // If we have differeing defs in either side of the diamond, we should
   // continue to produce a PHI,
   TransferFunc[0].insert({RspLoc, RspDefInBlk0});
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[2].insert({RspLoc, RspDefInBlk2});
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[0][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspPHIInBlk3);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspPHIInBlk3);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
   TransferFunc[2].clear();
 
   // If we have defs of the same value on either side of the branch, a PHI will
   // initially be created, however value propagation should then eliminate it.
   // Encode this by copying the live-in value to $rax, and copying it to $rsp
   // from $rax in each branch of the diamond. We don't allow the definition of
   // arbitary values in transfer functions.
   TransferFunc[0].insert({RspLoc, RspDefInBlk0});
   TransferFunc[0].insert({RaxLoc, LiveInRsp});
   TransferFunc[1].insert({RspLoc, RaxLiveInBlk1});
   TransferFunc[2].insert({RspLoc, RaxLiveInBlk2});
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk0);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], RspDefInBlk0);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk0);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], RspDefInBlk0);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
   TransferFunc[2].clear();
 }
 
 TEST_F(InstrRefLDVTest, MLocDiamondSpills) {
   // Test that defs in stack locations that require PHIs, cause PHIs to be
   // installed in aliasing locations. i.e., if there's a PHI in the lower
TEST_F(InstrRefLDVTest, MLocDiamondSpills) {
   LocIdx AHStackLoc = MTracker->getSpillMLoc(AHID);
   LocIdx AXStackLoc = MTracker->getSpillMLoc(AXID);
   LocIdx EAXStackLoc = MTracker->getSpillMLoc(EAXID);
   LocIdx HAXStackLoc = MTracker->getSpillMLoc(HAXID);
   LocIdx RAXStackLoc = MTracker->getSpillMLoc(RAXID);
   // There are other locations, for things like xmm0, which we're going to
   // ignore here.
 
-  ValueIDNum InLocs[4][10];
-  ValueIDNum *InLocsPtr[4] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(4, 10);
 
   // Transfer function: start with nothing.
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(4);
 
   // Name some values.
   unsigned EntryBlk = 0, Blk1 = 1, RetBlk = 3;
 
TEST_F(InstrRefLDVTest, MLocDiamondSpills) {
   // to reduce IDF calculation does the right thing.
   // AH should not be def'd: it don't alias AL or HAX.
   //
   // NB: we don't call buildMLocValueMap, because it will try to eliminate the
   // upper-slot PHIs, and succeed because of our slightly cooked transfer
   // function.
   TransferFunc[1].insert({ALStackLoc, ALDefInBlk1});
   TransferFunc[1].insert({HAXStackLoc, HAXDefInBlk1});
-  initValueArray(InLocsPtr, 4, 10);
-  placeMLocPHIs(*MF, AllBlocks, InLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[3][ALStackLoc.asU64()], ALPHI);
-  EXPECT_EQ(InLocs[3][AXStackLoc.asU64()], AXPHI);
-  EXPECT_EQ(InLocs[3][EAXStackLoc.asU64()], EAXPHI);
-  EXPECT_EQ(InLocs[3][HAXStackLoc.asU64()], HAXPHI);
-  EXPECT_EQ(InLocs[3][RAXStackLoc.asU64()], RAXPHI);
+  initValueArray(MInLocs, 4, 10);
+  placeMLocPHIs(*MF, AllBlocks, MInLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[3][ALStackLoc.asU64()], ALPHI);
+  EXPECT_EQ(MInLocs[3][AXStackLoc.asU64()], AXPHI);
+  EXPECT_EQ(MInLocs[3][EAXStackLoc.asU64()], EAXPHI);
+  EXPECT_EQ(MInLocs[3][HAXStackLoc.asU64()], HAXPHI);
+  EXPECT_EQ(MInLocs[3][RAXStackLoc.asU64()], RAXPHI);
   // AH should be left untouched,
-  EXPECT_EQ(InLocs[3][AHStackLoc.asU64()], ValueIDNum::EmptyValue);
-
+  EXPECT_EQ(MInLocs[3][AHStackLoc.asU64()], ValueIDNum::EmptyValue);
 }
 
 TEST_F(InstrRefLDVTest, MLocSimpleLoop) {
   //    entry
   //     |
   //     |/-----\
   //    loopblk |
   //     |\-----/
   //     |
   //     ret
   setupSimpleLoop();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum InLocs[3][2], OutLocs[3][2];
-  ValueIDNum *InLocsPtr[3] = {InLocs[0], InLocs[1], InLocs[2]};
-  ValueIDNum *OutLocsPtr[3] = {OutLocs[0], OutLocs[1], OutLocs[2]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(3, 2);
 
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(3);
 
   // Name some values.
   unsigned EntryBlk = 0, LoopBlk = 1, RetBlk = 2;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum RspPHIInBlk1(LoopBlk, 0, RspLoc);
   ValueIDNum RspDefInBlk1(LoopBlk, 1, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk1(LoopBlk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk2(RetBlk, 0, RaxLoc);
 
   // Begin test with all locations being live-through.
-  initValueArray(InLocsPtr, 3, 2);
-  initValueArray(OutLocsPtr, 3, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
+  initValueArray(MInLocs, 3, 2);
+  initValueArray(MOutLocs, 3, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
 
   // Add a def of $rsp to the loop block: it should be in the live-outs, but
   // should cause a PHI to be placed in the live-ins. Test the transfer function
   // by copying that PHI into $rax in the loop, then back to $rsp in the ret
   // block.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[1].insert({RaxLoc, RspPHIInBlk1});
   TransferFunc[2].insert({RspLoc, RaxPHIInBlk2});
-  initValueArray(InLocsPtr, 3, 2);
-  initValueArray(OutLocsPtr, 3, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk1);
+  initValueArray(MInLocs, 3, 2);
+  initValueArray(MOutLocs, 3, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk1);
   // Check rax as well,
-  EXPECT_EQ(InLocs[0][1], LiveInRax);
-  EXPECT_EQ(InLocs[1][1], RaxPHIInBlk1);
-  EXPECT_EQ(InLocs[2][1], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[0][1], LiveInRax);
-  EXPECT_EQ(OutLocs[1][1], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][1], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[0][1], LiveInRax);
+  EXPECT_EQ(MInLocs[1][1], RaxPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][1], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[0][1], LiveInRax);
+  EXPECT_EQ(MOutLocs[1][1], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][1], RspPHIInBlk1);
   TransferFunc[1].clear();
   TransferFunc[2].clear();
 
   // As with the diamond case, a PHI will be created if there's a (implicit)
   // def in the entry block and loop block; but should be value propagated away
   // if it copies in the same value. Copy live-in $rsp to $rax, then copy it
   // into $rsp in the loop. Encoded as copying the live-in $rax value in block 1
   // to $rsp.
   TransferFunc[0].insert({RaxLoc, LiveInRsp});
   TransferFunc[1].insert({RspLoc, RaxPHIInBlk1});
-  initValueArray(InLocsPtr, 3, 2);
-  initValueArray(OutLocsPtr, 3, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
+  initValueArray(MInLocs, 3, 2);
+  initValueArray(MOutLocs, 3, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
   // Check $rax's values.
-  EXPECT_EQ(InLocs[0][1], LiveInRax);
-  EXPECT_EQ(InLocs[1][1], LiveInRsp);
-  EXPECT_EQ(InLocs[2][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[0][1], LiveInRax);
+  EXPECT_EQ(MInLocs[1][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][1], LiveInRsp);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
 }
 
 TEST_F(InstrRefLDVTest, MLocNestedLoop) {
   //    entry
   //     |
   //    loop1
   //     ^\
   //     | \    /-\
   //     |  loop2  |
   //     |  /   \-/
   //     ^ /
   //     join
   //     |
   //     ret
   setupNestedLoops();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum InLocs[5][2], OutLocs[5][2];
-  ValueIDNum *InLocsPtr[5] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3],
-                              InLocs[4]};
-  ValueIDNum *OutLocsPtr[5] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3],
-                               OutLocs[4]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(5, 2);
 
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(5);
 
   unsigned EntryBlk = 0, Loop1Blk = 1, Loop2Blk = 2, JoinBlk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum RspPHIInBlk1(Loop1Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk1(Loop1Blk, 1, RspLoc);
   ValueIDNum RspPHIInBlk2(Loop2Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk2(Loop2Blk, 1, RspLoc);
   ValueIDNum RspDefInBlk3(JoinBlk, 1, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk1(Loop1Blk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk2(Loop2Blk, 0, RaxLoc);
 
   // Like the other tests: first ensure that if there's nothing in the transfer
   // function, then everything is live-through (check $rsp).
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(InLocs[4][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][0], LiveInRsp);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][0], LiveInRsp);
 
   // A def in the inner loop means we should get PHIs at the heads of both
   // loops. Live-outs of the last three blocks will be the def, as it dominates
   // those.
   TransferFunc[2].insert({RspLoc, RspDefInBlk2});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk2);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk2);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk2);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk2);
   TransferFunc[2].clear();
 
   // Adding a def to the outer loop header shouldn't affect this much -- the
   // live-out of block 1 changes.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[2].insert({RspLoc, RspDefInBlk2});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk2);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk2);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk2);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk2);
   TransferFunc[1].clear();
   TransferFunc[2].clear();
 
   // Likewise, putting a def in the outer loop tail shouldn't affect where
   // the PHIs go, and should propagate into the ret block.
 
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[2].insert({RspLoc, RspDefInBlk2});
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk2);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk2);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[1].clear();
   TransferFunc[2].clear();
   TransferFunc[3].clear();
 
   // However: if we don't def in the inner-loop, then we just have defs in the
   // head and tail of the outer loop. The inner loop should be live-through.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[1].clear();
   TransferFunc[3].clear();
 
   // Check that this still works if we copy RspDefInBlk1 to $rax and then
   // copy it back into $rsp in the inner loop.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
   TransferFunc[1].insert({RaxLoc, RspDefInBlk1});
   TransferFunc[2].insert({RspLoc, RaxPHIInBlk2});
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   // Look at raxes value in the relevant blocks,
-  EXPECT_EQ(InLocs[2][1], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[1][1], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[2][1], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[1][1], RspDefInBlk1);
   TransferFunc[1].clear();
   TransferFunc[2].clear();
   TransferFunc[3].clear();
 
   // If we have a single def in the tail of the outer loop, that should produce
   // a PHI at the loop head, and be live-through the inner loop.
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[3].clear();
 
   // And if we copy from $rsp to $rax in block 2, it should resolve to the PHI
   // in block 1, and we should keep that value in rax until the ret block.
   // There'll be a PHI in block 1 and 2, because we're putting a def in the
   // inner loop.
   TransferFunc[2].insert({RaxLoc, RspPHIInBlk2});
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
   // Examining the values of rax,
-  EXPECT_EQ(InLocs[0][1], LiveInRax);
-  EXPECT_EQ(InLocs[1][1], RaxPHIInBlk1);
-  EXPECT_EQ(InLocs[2][1], RaxPHIInBlk2);
-  EXPECT_EQ(InLocs[3][1], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[4][1], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[0][1], LiveInRax);
-  EXPECT_EQ(OutLocs[1][1], RaxPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][1], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[3][1], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[4][1], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[0][1], LiveInRax);
+  EXPECT_EQ(MInLocs[1][1], RaxPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][1], RaxPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][1], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[4][1], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[0][1], LiveInRax);
+  EXPECT_EQ(MOutLocs[1][1], RaxPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][1], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[3][1], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[4][1], RspPHIInBlk1);
   TransferFunc[2].clear();
   TransferFunc[3].clear();
 }
 
 TEST_F(InstrRefLDVTest, MLocNoDominatingLoop) {
   //           entry
   //            / \
   //           /   \
   //          /     \
   //        head1   head2
   //        ^  \   /   ^
   //        ^   \ /    ^
   //        \-joinblk -/
   //             |
   //            ret
   setupNoDominatingLoop();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum InLocs[5][2], OutLocs[5][2];
-  ValueIDNum *InLocsPtr[5] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3],
-                              InLocs[4]};
-  ValueIDNum *OutLocsPtr[5] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3],
-                               OutLocs[4]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(5, 2);
 
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(5);
 
   unsigned EntryBlk = 0, Head1Blk = 1, Head2Blk = 2, JoinBlk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum RspPHIInBlk1(Head1Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk1(Head1Blk, 1, RspLoc);
   ValueIDNum RspPHIInBlk2(Head2Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk2(Head2Blk, 1, RspLoc);
   ValueIDNum RspPHIInBlk3(JoinBlk, 0, RspLoc);
   ValueIDNum RspDefInBlk3(JoinBlk, 1, RspLoc);
   ValueIDNum RaxPHIInBlk1(Head1Blk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk2(Head2Blk, 0, RaxLoc);
 
   // As ever, test that everything is live-through if there are no defs.
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(InLocs[4][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][0], LiveInRsp);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][0], LiveInRsp);
 
   // Putting a def in the 'join' block will cause us to have two distinct
   // PHIs in each loop head, then on entry to the join block.
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[3].clear();
 
   // We should get the same behaviour if we put the def in either of the
   // loop heads -- it should force the other head to be a PHI.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(InLocs[4][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspPHIInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[4][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspPHIInBlk3);
   TransferFunc[1].clear();
 
   // Check symmetry,
   TransferFunc[2].insert({RspLoc, RspDefInBlk2});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(InLocs[4][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspPHIInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[4][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspPHIInBlk3);
   TransferFunc[2].clear();
 
   // Test some scenarios where there _shouldn't_ be any PHIs created at heads.
   // These are those PHIs are created, but value propagation eliminates them.
   // For example, lets copy rsp-livein to $rsp inside each loop head, so that
   // there's no need for a PHI in the join block. Put a def of $rsp in block 3
   // to force PHIs elsewhere.
   TransferFunc[0].insert({RaxLoc, LiveInRsp});
   TransferFunc[1].insert({RspLoc, RaxPHIInBlk1});
   TransferFunc[2].insert({RspLoc, RaxPHIInBlk2});
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
   TransferFunc[2].clear();
   TransferFunc[3].clear();
 
   // In fact, if we eliminate the def in block 3, none of those PHIs are
   // necessary, as we're just repeatedly copying LiveInRsp into $rsp. They
   // should all be value propagated out.
   TransferFunc[0].insert({RaxLoc, LiveInRsp});
   TransferFunc[1].insert({RspLoc, RaxPHIInBlk1});
   TransferFunc[2].insert({RspLoc, RaxPHIInBlk2});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(InLocs[4][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][0], LiveInRsp);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][0], LiveInRsp);
   TransferFunc[0].clear();
   TransferFunc[1].clear();
   TransferFunc[2].clear();
 }
 
 TEST_F(InstrRefLDVTest, MLocBadlyNestedLoops) {
   //           entry
   //             |
   //           loop1 -o
   //             | ^
   //             | ^
   //           loop2 -o
   //             | ^
   //             | ^
   //           loop3 -o
   //             |
   //            ret
   setupBadlyNestedLoops();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum InLocs[5][2], OutLocs[5][2];
-  ValueIDNum *InLocsPtr[5] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3],
-                              InLocs[4]};
-  ValueIDNum *OutLocsPtr[5] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3],
-                               OutLocs[4]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(5, 2);
 
   SmallVector<MLocTransferMap, 1> TransferFunc;
   TransferFunc.resize(5);
 
   unsigned EntryBlk = 0, Loop1Blk = 1, Loop2Blk = 2, Loop3Blk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum RspPHIInBlk1(Loop1Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk1(Loop1Blk, 1, RspLoc);
   ValueIDNum RspPHIInBlk2(Loop2Blk, 0, RspLoc);
   ValueIDNum RspPHIInBlk3(Loop3Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk3(Loop3Blk, 1, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RaxPHIInBlk3(Loop3Blk, 0, RaxLoc);
 
   // As ever, test that everything is live-through if there are no defs.
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], LiveInRsp);
-  EXPECT_EQ(InLocs[2][0], LiveInRsp);
-  EXPECT_EQ(InLocs[3][0], LiveInRsp);
-  EXPECT_EQ(InLocs[4][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][0], LiveInRsp);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][0], LiveInRsp);
 
   // A def in loop3 should cause PHIs in every loop block: they're all
   // reachable from each other.
   TransferFunc[3].insert({RspLoc, RspDefInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk3);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk3);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk3);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk3);
   TransferFunc[3].clear();
 
   // A def in loop1 should cause a PHI in loop1, but not the other blocks.
   // loop2 and loop3 are dominated by the def in loop1, so they should have
   // that value live-through.
   TransferFunc[1].insert({RspLoc, RspDefInBlk1});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[3][0], RspDefInBlk1);
-  EXPECT_EQ(InLocs[4][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[3][0], RspDefInBlk1);
-  EXPECT_EQ(OutLocs[4][0], RspDefInBlk1);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[3][0], RspDefInBlk1);
+  EXPECT_EQ(MInLocs[4][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[3][0], RspDefInBlk1);
+  EXPECT_EQ(MOutLocs[4][0], RspDefInBlk1);
   TransferFunc[1].clear();
 
   // As with earlier tricks: copy $rsp to $rax in the entry block, then $rax
   // to $rsp in block 3. The only def of $rsp is simply copying the same value
   // back into itself, and the value of $rsp is LiveInRsp all the way through.
   // PHIs should be created, then value-propagated away...  however this
   // doesn't work in practice.
   // Consider the entry to loop3: we can determine that there's an incoming
TEST_F(InstrRefLDVTest, MLocBadlyNestedLoops) {
   //     through branch folding to no longer be at a CFG join,
   //  c) The register allocator can spot this kind of redundant COPY easily,
   //     and eliminate it.
   //
   // This unit test left in as a reference for the limitations of this
   // approach. PHIs will be left in $rsp on entry to each block.
   TransferFunc[0].insert({RaxLoc, LiveInRsp});
   TransferFunc[3].insert({RspLoc, RaxPHIInBlk3});
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
-  buildMLocValueMap(InLocsPtr, OutLocsPtr, TransferFunc);
-  EXPECT_EQ(InLocs[0][0], LiveInRsp);
-  EXPECT_EQ(InLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(InLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(InLocs[3][0], RspPHIInBlk3);
-  EXPECT_EQ(InLocs[4][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][0], RspPHIInBlk1);
-  EXPECT_EQ(OutLocs[2][0], RspPHIInBlk2);
-  EXPECT_EQ(OutLocs[3][0], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][0], LiveInRsp);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
+  buildMLocValueMap(MInLocs, MOutLocs, TransferFunc);
+  EXPECT_EQ(MInLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MInLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MInLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MInLocs[3][0], RspPHIInBlk3);
+  EXPECT_EQ(MInLocs[4][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][0], RspPHIInBlk1);
+  EXPECT_EQ(MOutLocs[2][0], RspPHIInBlk2);
+  EXPECT_EQ(MOutLocs[3][0], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][0], LiveInRsp);
   // Check $rax's value. It should have $rsps value from the entry block
   // onwards.
-  EXPECT_EQ(InLocs[0][1], LiveInRax);
-  EXPECT_EQ(InLocs[1][1], LiveInRsp);
-  EXPECT_EQ(InLocs[2][1], LiveInRsp);
-  EXPECT_EQ(InLocs[3][1], LiveInRsp);
-  EXPECT_EQ(InLocs[4][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[0][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[1][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[2][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[3][1], LiveInRsp);
-  EXPECT_EQ(OutLocs[4][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[0][1], LiveInRax);
+  EXPECT_EQ(MInLocs[1][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[2][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[3][1], LiveInRsp);
+  EXPECT_EQ(MInLocs[4][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[0][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[1][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[2][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[3][1], LiveInRsp);
+  EXPECT_EQ(MOutLocs[4][1], LiveInRsp);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocDiamond) {
   //        entry
   //        /  \
   //      br1  br2
   //        \  /
   //         ret
   setupDiamondBlocks();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum OutLocs[4][2];
-  ValueIDNum *OutLocsPtr[4] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(4, 2);
 
-  initValueArray(OutLocsPtr, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
 
   unsigned EntryBlk = 0, Br2Blk = 2, RetBlk = 3;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk2(Br2Blk, 0, RspLoc);
   ValueIDNum RspPHIInBlk3(RetBlk, 0, RspLoc);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(4, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
   VLiveOutIdx[MBB3] = &VLiveOuts[3];
 
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB3->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block.
-  OutLocs[1][0] = LiveInRsp;
-  OutLocs[2][0] = LiveInRax;
+  MOutLocs[1][0] = LiveInRsp;
+  MOutLocs[2][0] = LiveInRax;
 
   Optional<ValueIDNum> Result;
 
   // Simple case: join two distinct values on entry to the block.
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 3.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk3);
   }
 
   // If the incoming values are swapped between blocks, we should not
   // successfully join. The CFG merge would select the right values, but in
   // the wrong conditions.
   std::swap(VLiveOuts[1], VLiveOuts[2]);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Swap back,
   std::swap(VLiveOuts[1], VLiveOuts[2]);
   // Setting one of these to being a constant should prohibit merging.
   VLiveOuts[1].Kind = DbgValue::Const;
   VLiveOuts[1].MO = MachineOperand::CreateImm(0);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Seeing both to being a constant -> still prohibit, it shouldn't become
   // a value in the register file anywhere.
   VLiveOuts[2] = VLiveOuts[1];
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // NoVals shouldn't join with anything else.
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::NoVal);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // We might merge in another VPHI in such a join. Present pickVPHILoc with
   // such a scenario: first, where one incoming edge has a VPHI with no known
   // value. This represents an edge where there was a PHI value that can't be
   // found in the register file -- we can't subsequently find a PHI here.
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
   EXPECT_EQ(VLiveOuts[2].ID, ValueIDNum::EmptyValue);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // However, if we know the value of the incoming VPHI, we can search for its
   // location. Use a PHI machine-value for doing this, as VPHIs should always
   // have PHI values, or they should have been eliminated.
-  OutLocs[2][0] = RspPHIInBlk2;
+  MOutLocs[2][0] = RspPHIInBlk2;
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(2, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2].ID = RspPHIInBlk2; // Set location where PHI happens.
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk3);
   }
 
   // If that value isn't available from that block, don't join.
-  OutLocs[2][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[2][0] = LiveInRsp;
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Check that we don't pick values when the properties disagree, for example
   // different indirectness or DIExpression.
   DIExpression *NewExpr =
       DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false);
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithExpr, DbgValue::Def);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   DbgValueProperties PropsWithIndirect(EmptyExpr, true);
   VLiveOuts[1] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def);
-  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB3, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocLoops) {
   setupSimpleLoop();
   //    entry
   //     |
   //     |/-----\
   //    loopblk |
   //     |\-----/
   //     |
   //     ret
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
-  ValueIDNum OutLocs[3][2];
-  ValueIDNum *OutLocsPtr[4] = {OutLocs[0], OutLocs[1], OutLocs[2]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(3, 2);
 
-  initValueArray(OutLocsPtr, 3, 2);
+  initValueArray(MOutLocs, 3, 2);
 
   unsigned EntryBlk = 0, LoopBlk = 1;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1(LoopBlk, 0, RspLoc);
   ValueIDNum RaxPHIInBlk1(LoopBlk, 0, RaxLoc);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
   SmallVector<DbgValue, 32> VLiveOuts;
   VLiveOuts.resize(3, DbgValue(EmptyProps, DbgValue::Undef));
   InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
 
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block.
-  OutLocs[0][0] = LiveInRsp;
-  OutLocs[1][0] = LiveInRax;
+  MOutLocs[0][0] = LiveInRsp;
+  MOutLocs[1][0] = LiveInRax;
 
   Optional<ValueIDNum> Result;
 
   // See that we can merge as normal on a backedge.
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // And that, if the desired values aren't available, we don't merge.
-  OutLocs[1][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[1][0] = LiveInRsp;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Test the backedge behaviour: PHIs that feed back into themselves can
   // carry this variables value. Feed in LiveInRsp in both $rsp and $rax
   // from the entry block, but only put an appropriate backedge PHI in $rax.
   // Only the $rax location can form the correct PHI.
-  OutLocs[0][0] = LiveInRsp;
-  OutLocs[0][1] = LiveInRsp;
-  OutLocs[1][0] = RaxPHIInBlk1;
-  OutLocs[1][1] = RaxPHIInBlk1;
+  MOutLocs[0][0] = LiveInRsp;
+  MOutLocs[0][1] = LiveInRsp;
+  MOutLocs[1][0] = RaxPHIInBlk1;
+  MOutLocs[1][1] = RaxPHIInBlk1;
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   // Crucially, a VPHI originating in this block:
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RaxPHIInBlk1);
   }
 
   // Merging should not be permitted if there's a usable PHI on the backedge,
   // but it's in the wrong place. (Overwrite $rax).
-  OutLocs[1][1] = LiveInRax;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[1][1] = LiveInRax;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Additionally, if the VPHI coming back on the loop backedge isn't from
   // this block (block 1), we can't merge it.
-  OutLocs[1][1] = RaxPHIInBlk1;
+  MOutLocs[1][1] = RaxPHIInBlk1;
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[1] = DbgValue(0, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 }
 
 TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   // Run some tests similar to pickVPHILocLoops, with more than one backedge,
   // and check that we merge correctly over many candidate locations.
   setupBadlyNestedLoops();
   //           entry
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
   //            ret
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
   Register RBX = getRegByName("RBX");
   LocIdx RbxLoc = MTracker->lookupOrTrackRegister(RBX);
 
-  ValueIDNum OutLocs[5][3];
-  ValueIDNum *OutLocsPtr[5] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3], OutLocs[4]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(5, 3);
 
-  initValueArray(OutLocsPtr, 5, 3);
+  initValueArray(MOutLocs, 5, 3);
 
   unsigned EntryBlk = 0, Loop1Blk = 1;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum LiveInRbx(EntryBlk, 0, RbxLoc);
   ValueIDNum RspPHIInBlk1(Loop1Blk, 0, RspLoc);
   ValueIDNum RaxPHIInBlk1(Loop1Blk, 0, RaxLoc);
TEST_F(InstrRefLDVTest, pickVPHILocBadlyNestedLoops) {
 
   // We're going to focus on block 1.
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   // Specify the live-outs around the joining block. Incoming edges from the
   // entry block, self, and loop2.
-  OutLocs[0][0] = LiveInRsp;
-  OutLocs[1][0] = LiveInRax;
-  OutLocs[2][0] = LiveInRbx;
+  MOutLocs[0][0] = LiveInRsp;
+  MOutLocs[1][0] = LiveInRax;
+  MOutLocs[2][0] = LiveInRbx;
 
   Optional<ValueIDNum> Result;
 
   // See that we can merge as normal on a backedge.
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[1] = DbgValue(LiveInRax, EmptyProps, DbgValue::Def);
   VLiveOuts[2] = DbgValue(LiveInRbx, EmptyProps, DbgValue::Def);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   // Should have picked a PHI in $rsp in block 1.
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // Check too that permuting the live-out locations prevents merging
-  OutLocs[0][0] = LiveInRax;
-  OutLocs[1][0] = LiveInRbx;
-  OutLocs[2][0] = LiveInRsp;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[0][0] = LiveInRax;
+  MOutLocs[1][0] = LiveInRbx;
+  MOutLocs[2][0] = LiveInRsp;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
-  OutLocs[0][0] = LiveInRsp;
-  OutLocs[1][0] = LiveInRax;
-  OutLocs[2][0] = LiveInRbx;
+  MOutLocs[0][0] = LiveInRsp;
+  MOutLocs[1][0] = LiveInRax;
+  MOutLocs[2][0] = LiveInRbx;
 
   // Feeding a PHI back on one backedge shouldn't merge (block 1 self backedge
   // wants LiveInRax).
-  OutLocs[1][0] = RspPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[1][0] = RspPHIInBlk1;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // If the variables value on that edge is a VPHI feeding into itself, that's
   // fine.
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(LiveInRbx, EmptyProps, DbgValue::Def);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // Likewise: the other backedge being a VPHI from block 1 should be accepted.
-  OutLocs[2][0] = RspPHIInBlk1;
+  MOutLocs[2][0] = RspPHIInBlk1;
   VLiveOuts[0] = DbgValue(LiveInRsp, EmptyProps, DbgValue::Def);
   VLiveOuts[1] = DbgValue(1, EmptyProps, DbgValue::VPHI);
   VLiveOuts[2] = DbgValue(1, EmptyProps, DbgValue::VPHI);
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RspPHIInBlk1);
   }
 
   // Here's where it becomes tricky: we should not merge if there are two
   // _distinct_ backedge PHIs. We can't have a PHI that happens in both rsp
   // and rax for example. We can only pick one location as the live-in.
-  OutLocs[2][0] = RaxPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[2][0] = RaxPHIInBlk1;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // The above test sources correct machine-PHI-value from two places. Now
   // try with one machine-PHI-value, but placed in two different locations
   // on the backedge. Again, we can't merge a location here, there's no
   // location that works on all paths.
-  OutLocs[0][0] = LiveInRsp;
-  OutLocs[1][0] = RspPHIInBlk1;
-  OutLocs[2][0] = LiveInRsp;
-  OutLocs[2][1] = RspPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[0][0] = LiveInRsp;
+  MOutLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[2][0] = LiveInRsp;
+  MOutLocs[2][1] = RspPHIInBlk1;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_FALSE(Result);
 
   // Scatter various PHI values across the available locations. Only rbx (loc 2)
   // has the right value in both backedges -- that's the loc that should be
   // picked.
-  OutLocs[0][2] = LiveInRsp;
-  OutLocs[1][0] = RspPHIInBlk1;
-  OutLocs[1][1] = RaxPHIInBlk1;
-  OutLocs[1][2] = RbxPHIInBlk1;
-  OutLocs[2][0] = LiveInRsp;
-  OutLocs[2][1] = RspPHIInBlk1;
-  OutLocs[2][2] = RbxPHIInBlk1;
-  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, OutLocsPtr, Preds);
+  MOutLocs[0][2] = LiveInRsp;
+  MOutLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[1][1] = RaxPHIInBlk1;
+  MOutLocs[1][2] = RbxPHIInBlk1;
+  MOutLocs[2][0] = LiveInRsp;
+  MOutLocs[2][1] = RspPHIInBlk1;
+  MOutLocs[2][2] = RbxPHIInBlk1;
+  Result = pickVPHILoc(*MBB1, Var, VLiveOutIdx, MOutLocs, Preds);
   EXPECT_TRUE(Result);
   if (Result) {
     EXPECT_EQ(*Result, RbxPHIInBlk1);
   }
 }
 
 TEST_F(InstrRefLDVTest, vlocJoinDiamond) {
   //        entry

 // Instead, pre-set some machine locations and apply buildVLocValueMap to the
 // existing CFG patterns.
 TEST_F(InstrRefLDVTest, VLocSingleBlock) {
   setupSingleBlock();
 
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
 
-  ValueIDNum InLocs[2], OutLocs[2];
-  ValueIDNum *InLocsPtr[1] = {&InLocs[0]};
-  ValueIDNum *OutLocsPtr[1] = {&OutLocs[0]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(1, 2);
 
   ValueIDNum LiveInRsp = ValueIDNum(0, 0, RspLoc);
-  InLocs[0] = OutLocs[0] = LiveInRsp;
+  MInLocs[0][0] = MOutLocs[0][0] = LiveInRsp;
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   // Mild hack: rather than constructing machine instructions in each block
   // and creating lexical scopes across them, instead just tell
   // buildVLocValueMap that there's an assignment in every block. That makes
   // every block in scope.
   SmallPtrSet<MachineBasicBlock *, 4> AssignBlocks;
   AssignBlocks.insert(MBB0);
 
   SmallVector<VLocTracker, 1> VLocs;
   VLocs.resize(1, VLocTracker(Overlaps, EmptyExpr));
 
   InstrRefBasedLDV::LiveInsT Output;
 
   // Test that, with no assignments at all, no mappings are created for the
   // variable in this function.
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output.size(), 0ul);
 
   // If we put an assignment in the transfer function, that should... well,
   // do nothing, because we don't store the live-outs.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output.size(), 0ul);
 
   // There is pretty much nothing else of interest to test with a single block.
   // It's not relevant to the SSA-construction parts of variable values.
 }
 
 TEST_F(InstrRefLDVTest, VLocDiamondBlocks) {
   setupDiamondBlocks();
TEST_F(InstrRefLDVTest, VLocDiamondBlocks) {
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
   unsigned EntryBlk = 0, RetBlk = 3;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk3 = ValueIDNum(RetBlk, 0, RspLoc);
 
-  ValueIDNum InLocs[4][2], OutLocs[4][2];
-  ValueIDNum *InLocsPtr[4] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3]};
-  ValueIDNum *OutLocsPtr[4] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(4, 2);
 
-  initValueArray(InLocsPtr, 4, 2);
-  initValueArray(OutLocsPtr, 4, 2);
+  initValueArray(MInLocs, 4, 2);
+  initValueArray(MOutLocs, 4, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   // Mild hack: rather than constructing machine instructions in each block
   // and creating lexical scopes across them, instead just tell
   // buildVLocValueMap that there's an assignment in every block. That makes
   // every block in scope.
   SmallPtrSet<MachineBasicBlock *, 4> AssignBlocks;
   AssignBlocks.insert(MBB0);
   AssignBlocks.insert(MBB1);
   AssignBlocks.insert(MBB2);
   AssignBlocks.insert(MBB3);
 
   SmallVector<VLocTracker, 1> VLocs;
   VLocs.resize(4, VLocTracker(Overlaps, EmptyExpr));
 
   InstrRefBasedLDV::LiveInsT Output;
 
   // Start off with LiveInRsp in every location.
   for (unsigned int I = 0; I < 4; ++I) {
-    InLocs[I][0] = InLocs[I][1] = LiveInRsp;
-    OutLocs[I][0] = OutLocs[I][1] = LiveInRsp;
+    MInLocs[I][0] = MInLocs[I][1] = LiveInRsp;
+    MOutLocs[I][0] = MOutLocs[I][1] = LiveInRsp;
   }
 
   auto ClearOutputs = [&]() {
     for (auto &Elem : Output)
       Elem.clear();
   };
   Output.resize(4);
 
   // No assignments -> no values.
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
 
   // An assignment in the end block should also not affect other blocks; or
   // produce any live-ins.
   VLocs[3].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   ClearOutputs();
 
   // Assignments in either of the side-of-diamond blocks should also not be
   // propagated anywhere.
   VLocs[3].Vars.clear();
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   VLocs[2].Vars.clear();
   ClearOutputs();
 
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   VLocs[1].Vars.clear();
   ClearOutputs();
 
   // However: putting an assignment in the first block should propagate variable
   // values through to all other blocks, as it dominates.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // Additionally, even if that value isn't available in the register file, it
   // should still be propagated, as buildVLocValueMap shouldn't care about
   // what's in the registers (except for PHIs).
   // values through to all other blocks, as it dominates.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // We should get a live-in to the merging block, if there are two assigns of
   // the same value in either side of the diamond.
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[1].Vars.clear();
   VLocs[2].Vars.clear();
 
   // If we assign a value in the entry block, then 'undef' on a branch, we
   // shouldn't have a live-in in the merge block.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(EmptyProps, DbgValue::Undef)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Having different values joining into the merge block should mean we have
   // no live-in in that block. Block ones LiveInRax value doesn't appear as a
   // live-in anywhere, it's block internal.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // But on the other hand, if there's a location in the register file where
   // those two values can be joined, do so.
-  OutLocs[1][0] = LiveInRax;
+  MOutLocs[1][0] = LiveInRax;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
   unsigned EntryBlk = 0, LoopBlk = 1;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1 = ValueIDNum(LoopBlk, 0, RspLoc);
   ValueIDNum RspDefInBlk1 = ValueIDNum(LoopBlk, 1, RspLoc);
   ValueIDNum RaxPHIInBlk1 = ValueIDNum(LoopBlk, 0, RaxLoc);
 
-  ValueIDNum InLocs[3][2], OutLocs[3][2];
-  ValueIDNum *InLocsPtr[3] = {InLocs[0], InLocs[1], InLocs[2]};
-  ValueIDNum *OutLocsPtr[3] = {OutLocs[0], OutLocs[1], OutLocs[2]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(3, 2);
 
-  initValueArray(InLocsPtr, 3, 2);
-  initValueArray(OutLocsPtr, 3, 2);
+  initValueArray(MInLocs, 3, 2);
+  initValueArray(MOutLocs, 3, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   SmallPtrSet<MachineBasicBlock *, 4> AssignBlocks;
   AssignBlocks.insert(MBB0);
   AssignBlocks.insert(MBB1);
   AssignBlocks.insert(MBB2);
 
   SmallVector<VLocTracker, 3> VLocs;
   VLocs.resize(3, VLocTracker(Overlaps, EmptyExpr));
 
   InstrRefBasedLDV::LiveInsT Output;
 
   // Start off with LiveInRsp in every location.
   for (unsigned int I = 0; I < 3; ++I) {
-    InLocs[I][0] = InLocs[I][1] = LiveInRsp;
-    OutLocs[I][0] = OutLocs[I][1] = LiveInRsp;
+    MInLocs[I][0] = MInLocs[I][1] = LiveInRsp;
+    MOutLocs[I][0] = MOutLocs[I][1] = LiveInRsp;
   }
 
   auto ClearOutputs = [&]() {
     for (auto &Elem : Output)
       Elem.clear();
   };
   Output.resize(3);
 
   // Easy starter: a dominating assign should propagate to all blocks.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Put an undef assignment in the loop. Should get no live-in value.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(EmptyProps, DbgValue::Undef)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Assignment of the same value should naturally join.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Assignment of different values shouldn't join with no machine PHI vals.
   // Will be live-in to exit block as it's dominated.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Install a completely unrelated PHI value, that we should not join on. Try
   // with unrelated assign in loop block again.
-  InLocs[1][0] = RspPHIInBlk1;
-  OutLocs[1][0] = RspDefInBlk1;
+  MInLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[1][0] = RspDefInBlk1;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Now, if we assign RspDefInBlk1 in the loop block, we should be able to
   // find the appropriate PHI.
-  InLocs[1][0] = RspPHIInBlk1;
-  OutLocs[1][0] = RspDefInBlk1;
+  MInLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[1][0] = RspDefInBlk1;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // If the PHI happens in a different location, the live-in should happen
   // there.
-  InLocs[1][0] = LiveInRsp;
-  OutLocs[1][0] = LiveInRsp;
-  InLocs[1][1] = RaxPHIInBlk1;
-  OutLocs[1][1] = RspDefInBlk1;
+  MInLocs[1][0] = LiveInRsp;
+  MOutLocs[1][0] = LiveInRsp;
+  MInLocs[1][1] = RaxPHIInBlk1;
+  MOutLocs[1][1] = RspDefInBlk1;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, RaxPHIInBlk1);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // The PHI happening in both places should be handled too. Exactly where
   // isn't important, but if the location picked changes, this test will let
   // you know.
-  InLocs[1][0] = RaxPHIInBlk1;
-  OutLocs[1][0] = RspDefInBlk1;
-  InLocs[1][1] = RaxPHIInBlk1;
-  OutLocs[1][1] = RspDefInBlk1;
+  MInLocs[1][0] = RaxPHIInBlk1;
+  MOutLocs[1][0] = RspDefInBlk1;
+  MInLocs[1][1] = RaxPHIInBlk1;
+  MOutLocs[1][1] = RspDefInBlk1;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(RspDefInBlk1, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   // Today, the first register is picked.
   EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, RspDefInBlk1);
TEST_F(InstrRefLDVTest, VLocSimpleLoop) {
   //    [...]
   //    DBG_INSTR_REF
   // And we would be feeding a machine PHI-value back around the loop. However:
   // this does not mean we can eliminate the variable value PHI and use the
   // variable value from the entry block: they are distinct values that must be
   // joined at some location by the control flow.
   // [This test input would never occur naturally, the machine-PHI would be
   //  eliminated]
-  InLocs[1][0] = RspPHIInBlk1;
-  OutLocs[1][0] = RspPHIInBlk1;
-  InLocs[1][1] = LiveInRax;
-  OutLocs[1][1] = LiveInRax;
+  MInLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[1][0] = RspPHIInBlk1;
+  MInLocs[1][1] = LiveInRax;
+  MOutLocs[1][1] = LiveInRax;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(RspPHIInBlk1, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, RspPHIInBlk1);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // Test that we can eliminate PHIs. A PHI will be placed at the loop head
   // because there's a def in in.
-  InLocs[1][0] = LiveInRsp;
-  OutLocs[1][0] = LiveInRsp;
+  MInLocs[1][0] = LiveInRsp;
+  MOutLocs[1][0] = LiveInRsp;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   ClearOutputs();
TEST_F(InstrRefLDVTest, VLocNestedLoop) {
   unsigned EntryBlk = 0, Loop1Blk = 1, Loop2Blk = 2;
 
   ValueIDNum LiveInRsp = ValueIDNum(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax = ValueIDNum(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1 = ValueIDNum(Loop1Blk, 0, RspLoc);
   ValueIDNum RspPHIInBlk2 = ValueIDNum(Loop2Blk, 0, RspLoc);
   ValueIDNum RspDefInBlk2 = ValueIDNum(Loop2Blk, 1, RspLoc);
 
-  ValueIDNum InLocs[5][2], OutLocs[5][2];
-  ValueIDNum *InLocsPtr[5] = {InLocs[0], InLocs[1], InLocs[2], InLocs[3], InLocs[4]};
-  ValueIDNum *OutLocsPtr[5] = {OutLocs[0], OutLocs[1], OutLocs[2], OutLocs[3], OutLocs[4]};
+  FuncValueTable MInLocs, MOutLocs;
+  std::tie(MInLocs, MOutLocs) = allocValueTables(5, 2);
 
-  initValueArray(InLocsPtr, 5, 2);
-  initValueArray(OutLocsPtr, 5, 2);
+  initValueArray(MInLocs, 5, 2);
+  initValueArray(MOutLocs, 5, 2);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   SmallPtrSet<MachineBasicBlock *, 5> AssignBlocks;
   AssignBlocks.insert(MBB0);
   AssignBlocks.insert(MBB1);
   AssignBlocks.insert(MBB2);
   AssignBlocks.insert(MBB3);
   AssignBlocks.insert(MBB4);
 
   SmallVector<VLocTracker, 5> VLocs;
   VLocs.resize(5, VLocTracker(Overlaps, EmptyExpr));
 
   InstrRefBasedLDV::LiveInsT Output;
 
   // Start off with LiveInRsp in every location.
   for (unsigned int I = 0; I < 5; ++I) {
-    InLocs[I][0] = InLocs[I][1] = LiveInRsp;
-    OutLocs[I][0] = OutLocs[I][1] = LiveInRsp;
+    MInLocs[I][0] = MInLocs[I][1] = LiveInRsp;
+    MOutLocs[I][0] = MOutLocs[I][1] = LiveInRsp;
   }
 
   auto ClearOutputs = [&]() {
     for (auto &Elem : Output)
       Elem.clear();
   };
   Output.resize(5);
 
   // A dominating assign should propagate to all blocks.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
 
   // Test that an assign in the inner loop causes unresolved PHIs at the heads
   // of both loops, and no output location. Dominated blocks do get values.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // Same test, but with no assignment in block 0. We should still get values
   // in dominated blocks.
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[2].Vars.clear();
 
   // Similarly, assignments in the outer loop gives location to dominated
   // blocks, but no PHI locations are found at the outer loop head.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[3].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   EXPECT_EQ(Output[3].size(), 0ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[3].Vars.clear();
 
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[1].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[1].Vars.clear();
 
   // With an assignment of the same value in the inner loop, we should work out
   // that all PHIs can be eliminated and the same value is live-through the
   // whole function.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 1ul);
   EXPECT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[2][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRsp);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRsp);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // If we have an assignment in the inner loop, and a PHI for it at the inner
   // loop head, we could find a live-in location for the inner loop. But because
   // the outer loop has no PHI, we can't find a variable value for outer loop
   // head, so can't have a live-in value for the inner loop head.
-  InLocs[2][0] = RspPHIInBlk2;
-  OutLocs[2][0] = LiveInRax;
+  MInLocs[2][0] = RspPHIInBlk2;
+  MOutLocs[2][0] = LiveInRax;
   // NB: all other machine locations are LiveInRsp, disallowing a PHI in block
   // one. Even though RspPHIInBlk2 isn't available later in the function, we
   // should still produce a live-in value. The fact it's unavailable is a
   // different concern.
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[2].Vars.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   EXPECT_EQ(Output[1].size(), 0ul);
   EXPECT_EQ(Output[2].size(), 0ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[3][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[3][0].second.ID, LiveInRax);
   EXPECT_EQ(Output[4][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[4][0].second.ID, LiveInRax);
   ClearOutputs();
   VLocs[0].Vars.clear();
   VLocs[2].Vars.clear();
 
   // Have an assignment in inner loop that can have a PHI resolved; and add a
   // machine value PHI to the outer loop head, so that we can find a location
   // all the way through the function.
-  InLocs[1][0] = RspPHIInBlk1;
-  OutLocs[1][0] = RspPHIInBlk1;
-  InLocs[2][0] = RspPHIInBlk2;
-  OutLocs[2][0] = RspDefInBlk2;
-  InLocs[3][0] = RspDefInBlk2;
-  OutLocs[3][0] = RspDefInBlk2;
+  MInLocs[1][0] = RspPHIInBlk1;
+  MOutLocs[1][0] = RspPHIInBlk1;
+  MInLocs[2][0] = RspPHIInBlk2;
+  MOutLocs[2][0] = RspDefInBlk2;
+  MInLocs[3][0] = RspDefInBlk2;
+  MOutLocs[3][0] = RspDefInBlk2;
   VLocs[0].Vars.insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLocs[2].Vars.insert({Var, DbgValue(RspDefInBlk2, EmptyProps, DbgValue::Def)});
   buildVLocValueMap(OutermostLoc, AllVars, AssignBlocks, Output,
-                    OutLocsPtr, InLocsPtr, VLocs);
+                    MOutLocs, MInLocs, VLocs);
   EXPECT_EQ(Output[0].size(), 0ul);
   ASSERT_EQ(Output[1].size(), 1ul);
   ASSERT_EQ(Output[2].size(), 1ul);
   ASSERT_EQ(Output[3].size(), 1ul);
   ASSERT_EQ(Output[4].size(), 1ul);
   EXPECT_EQ(Output[1][0].second.Kind, DbgValue::Def);
   EXPECT_EQ(Output[1][0].second.ID, RspPHIInBlk1);
   EXPECT_EQ(Output[2][0].second.Kind, DbgValue::Def);