Subzero: Fix a bug in register allocator overlap computation.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 20 matching lines @@
 // live ranges are trimmed, since all the overlapsDefs() tests are whether some
 // variable's definitions overlap Cur, and trimming is with respect Cur.start.
 // Initial tests show no measurable performance difference, so we'll keep the
 // code simple for now.
 bool overlapsDefs(const Cfg *Func, const Variable *Item, const Variable *Var) {
   constexpr bool UseTrimmed = true;
   VariablesMetadata *VMetadata = Func->getVMetadata();
   if (const Inst *FirstDef = VMetadata->getFirstDefinition(Var))
     if (Item->getLiveRange().overlapsInst(FirstDef->getNumber(), UseTrimmed))
       return true;
-  const InstDefList &Defs = VMetadata->getLatterDefinitions(Var);
-  for (size_t i = 0; i < Defs.size(); ++i) {
-    if (Item->getLiveRange().overlapsInst(Defs[i]->getNumber(), UseTrimmed))
+  for (const Inst *Def : VMetadata->getLatterDefinitions(Var)) {
+    if (Item->getLiveRange().overlapsInst(Def->getNumber(), UseTrimmed))
       return true;
   }
   return false;
 }
 
 void dumpDisableOverlap(const Cfg *Func, const Variable *Var,
                         const char *Reason) {
   if (!BuildDefs::dump())
     return;
   if (Func->isVerbose(IceV_LinearScan)) {
@@ skipping 402 matching lines @@
 // assignment - i.e., the register gets copied/aliased but is never modified.
 // Furthermore, overlap is only allowed when preferred Variable definition
 // instructions do not appear within the current Variable's live range.
 void LinearScan::findRegisterPreference(IterationState &Iter) {
   Iter.Prefer = nullptr;
   Iter.PreferReg = Variable::NoRegister;
   Iter.AllowOverlap = false;
 
   if (FindPreference) {
     VariablesMetadata *VMetadata = Func->getVMetadata();
-    if (const Inst *DefInst = VMetadata->getFirstDefinition(Iter.Cur)) {
+    if (const Inst *DefInst =
+            VMetadata->getFirstDefinitionSingleBlock(Iter.Cur)) {
       assert(DefInst->getDest() == Iter.Cur);
       bool IsAssign = DefInst->isSimpleAssign();
       bool IsSingleDef = !VMetadata->isMultiDef(Iter.Cur);
       for (SizeT i = 0; i < DefInst->getSrcSize(); ++i) {
         // TODO(stichnot): Iterate through the actual Variables of the
         // instruction, not just the source operands. This could capture Load
         // instructions, including address mode optimization, for Prefer (but
         // not for AllowOverlap).
         if (Variable *SrcVar = llvm::dyn_cast<Variable>(DefInst->getSrc(i))) {
           int32_t SrcReg = SrcVar->getRegNumTmp();
@@ skipping 467 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice