Subzero: Merge SpillVariable functionality directly into Variable.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1025 matching lines @@
   SpillAreaSizeBytes = 0;
   // If there is a separate locals area, this specifies the alignment for it.
   uint32_t LocalsSlotsAlignmentBytes = 0;
   // The entire spill locations area gets aligned to largest natural alignment
   // of the variables that have a spill slot.
   uint32_t SpillAreaAlignmentBytes = 0;
   // A spill slot linked to a variable with a stack slot should reuse that
   // stack slot.
   std::function<bool(Variable *)> TargetVarHook =
       [&VariablesLinkedToSpillSlots](Variable *Var) {
-        if (auto *SpillVar =
-                llvm::dyn_cast<typename Traits::SpillVariable>(Var)) {
+        if (Var->getLinkedTo() != nullptr) {
+          // TODO(stichnot): This assert won't necessarily be true in the
+          // future.
           assert(Var->mustNotHaveReg());
-          if (SpillVar->getLinkedTo() && !SpillVar->getLinkedTo()->hasReg()) {
+          if (!Var->getLinkedTo()->hasReg()) {
             VariablesLinkedToSpillSlots.push_back(Var);
             return true;
           }
         }
         return false;
       };
 
   // Compute the list of spilled variables and bounds for GlobalsSize, etc.
   getVarStackSlotParams(SortedSpilledVariables, RegsUsed, &GlobalsSize,
                         &SpillAreaSizeBytes, &SpillAreaAlignmentBytes,
@@ skipping 143 matching lines @@
                            InArgsSizeBytes);
   }
 
   // Fill in stack offsets for locals.
   assignVarStackSlots(SortedSpilledVariables, SpillAreaPaddingBytes,
                       SpillAreaSizeBytes, GlobalsAndSubsequentPaddingSize,
                       IsEbpBasedFrame);
   // Assign stack offsets to variables that have been linked to spilled
   // variables.
   for (Variable *Var : VariablesLinkedToSpillSlots) {
-    Variable *Linked =
-        (llvm::cast<typename Traits::SpillVariable>(Var))->getLinkedTo();
+    const Variable *Linked = Var->getLinkedTo();
+    assert(Linked != nullptr);
     Var->setStackOffset(Linked->getStackOffset());
   }
   this->HasComputedFrame = true;
 
   if (BuildDefs::dump() && Func->isVerbose(IceV_Frame)) {
     OstreamLocker L(Func->getContext());
     Ostream &Str = Func->getContext()->getStrDump();
 
     Str << "Stack layout:\n";
     uint32_t EspAdjustmentPaddingSize =
@@ skipping 1854 matching lines @@
       } else {
         Operand *Src0RM = legalize(Src0, Legal_Reg | Legal_Mem);
         // a.i64 = bitcast b.f64 ==>
         //   s.f64 = spill b.f64
         //   t_lo.i32 = lo(s.f64)
         //   a_lo.i32 = t_lo.i32
         //   t_hi.i32 = hi(s.f64)
         //   a_hi.i32 = t_hi.i32
         Operand *SpillLo, *SpillHi;
         if (auto *Src0Var = llvm::dyn_cast<Variable>(Src0RM)) {
-          SpillVariable *SpillVar =
-              Func->makeVariable<SpillVariable>(IceType_f64);
-          SpillVar->setLinkedTo(Src0Var);
-          Variable *Spill = SpillVar;
+          Variable *Spill = Func->makeVariable(IceType_f64);
+          Spill->setLinkedTo(Src0Var);
           Spill->setMustNotHaveReg();
           _movq(Spill, Src0RM);
           SpillLo = Traits::VariableSplit::create(Func, Spill,
                                                   Traits::VariableSplit::Low);
           SpillHi = Traits::VariableSplit::create(Func, Spill,
                                                   Traits::VariableSplit::High);
         } else {
           SpillLo = loOperand(Src0RM);
           SpillHi = hiOperand(Src0RM);
         }
@@ skipping 24 matching lines @@
           _movq(Dest, T);
           break;
         }
         // a.f64 = bitcast b.i64 ==>
         //   t_lo.i32 = b_lo.i32
         //   FakeDef(s.f64)
         //   lo(s.f64) = t_lo.i32
         //   t_hi.i32 = b_hi.i32
         //   hi(s.f64) = t_hi.i32
         //   a.f64 = s.f64
-        SpillVariable *SpillVar =
-            Func->makeVariable<SpillVariable>(IceType_f64);
-        SpillVar->setLinkedTo(Dest);
-        Variable *Spill = SpillVar;
+        Variable *Spill = Func->makeVariable(IceType_f64);
+        Spill->setLinkedTo(Dest);
         Spill->setMustNotHaveReg();
 
         Variable *T_Lo = nullptr, *T_Hi = nullptr;
         auto *SpillLo = Traits::VariableSplit::create(
             Func, Spill, Traits::VariableSplit::Low);
         auto *SpillHi = Traits::VariableSplit::create(
             Func, Spill, Traits::VariableSplit::High);
         _mov(T_Lo, loOperand(Src0));
         // Technically, the Spill is defined after the _store happens, but
         // SpillLo is considered a "use" of Spill so define Spill before it is
@@ skipping 4884 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H