Subzero: Change the way bitcast stack slot lowering is handled.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 683 matching lines @@
       getRegisterSet(RegSet_CalleeSave, RegSet_None);
 
   size_t GlobalsSize = 0;
   std::vector<size_t> LocalsSize(Func->getNumNodes());
 
   // Prepass.  Compute RegsUsed, PreservedRegsSizeBytes, and
   // SpillAreaSizeBytes.
   RegsUsed = llvm::SmallBitVector(CalleeSaves.size());
   const VarList &Variables = Func->getVariables();
   const VarList &Args = Func->getArgs();
-  VarList SpilledVariables, SortedSpilledVariables,
-      VariablesLinkedToSpillSplots;
+  VarList SpilledVariables, SortedSpilledVariables, VariablesLinkedToSpillSlots;
 
   // 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;
   for (VarList::const_iterator I = Variables.begin(), E = Variables.end();
        I != E; ++I) {
     Variable *Var = *I;
     if (Var->hasReg()) {
       RegsUsed[Var->getRegNum()] = true;
       continue;
     }
     // An argument either does not need a stack slot (if passed in a
     // register) or already has one (if passed on the stack).
     if (Var->getIsArg())
       continue;
     // An unreferenced variable doesn't need a stack slot.
     if (ComputedLiveRanges && Var->getLiveRange().isEmpty())
       continue;
     // A spill slot linked to a variable with a stack slot should reuse
     // that stack slot.
-    if (Var->getWeight() == RegWeight::Zero && Var->getRegisterOverlap()) {
-      if (Variable *Linked = Var->getPreferredRegister()) {
-        if (!Linked->hasReg()) {
-          VariablesLinkedToSpillSplots.push_back(Var);
-          continue;
-        }
+    if (SpillVariable *SpillVar = llvm::dyn_cast<SpillVariable>(Var)) {
+      assert(Var->getWeight() == RegWeight::Zero);
+      if (!SpillVar->getLinkedTo()->hasReg()) {
+        VariablesLinkedToSpillSlots.push_back(Var);
+        continue;
       }
     }
     SpilledVariables.push_back(Var);
   }
 
   SortedSpilledVariables.reserve(SpilledVariables.size());
   sortByAlignment(SortedSpilledVariables, SpilledVariables);
   for (VarList::const_iterator I = SortedSpilledVariables.begin(),
                                E = SortedSpilledVariables.end();
        I != E; ++I) {
@@ skipping 127 matching lines @@
     if (IsEbpBasedFrame)
       Var->setStackOffset(-NextStackOffset);
     else
       Var->setStackOffset(SpillAreaSizeBytes - NextStackOffset);
   }
   this->FrameSizeLocals = NextStackOffset - SpillAreaPaddingBytes;
   this->HasComputedFrame = true;
 
   // Assign stack offsets to variables that have been linked to spilled
   // variables.
-  for (VarList::const_iterator I = VariablesLinkedToSpillSplots.begin(),
-                               E = VariablesLinkedToSpillSplots.end();
+  for (VarList::const_iterator I = VariablesLinkedToSpillSlots.begin(),
+                               E = VariablesLinkedToSpillSlots.end();
        I != E; ++I) {
     Variable *Var = *I;
-    Variable *Linked = Var->getPreferredRegister();
+    Variable *Linked = (llvm::cast<SpillVariable>(Var))->getLinkedTo();
     Var->setStackOffset(Linked->getStackOffset());
   }
 
   if (Func->getContext()->isVerbose(IceV_Frame)) {
     Ostream &Str = Func->getContext()->getStrDump();
 
     Str << "Stack layout:\n";
     uint32_t EspAdjustmentPaddingSize =
         SpillAreaSizeBytes - LocalsSpillAreaSize -
         GlobalsAndSubsequentPaddingSize - SpillAreaPaddingBytes;
@@ skipping 1375 matching lines @@
       (void)DestType;
       assert((DestType == IceType_i32 && SrcType == IceType_f32) ||
              (DestType == IceType_f32 && SrcType == IceType_i32));
       // a.i32 = bitcast b.f32 ==>
       //   t.f32 = b.f32
       //   s.f32 = spill t.f32
       //   a.i32 = s.f32
       Variable *T = NULL;
       // TODO: Should be able to force a spill setup by calling legalize() with
       // Legal_Mem and not Legal_Reg or Legal_Imm.
-      Variable *Spill = Func->makeVariable(SrcType, Context.getNode());
+      SpillVariable *SpillVar =
+          Func->makeVariable<SpillVariable>(SrcType, Context.getNode());
+      SpillVar->setLinkedTo(Dest);
+      Variable *Spill = SpillVar;
       Spill->setWeight(RegWeight::Zero);
-      Spill->setPreferredRegister(Dest, true);
       _mov(T, Src0RM);
       _mov(Spill, T);
       _mov(Dest, Spill);
     } break;
     case IceType_i64: {
       Operand *Src0RM = legalize(Src0, Legal_Reg | Legal_Mem);
       assert(Src0RM->getType() == IceType_f64);
       // 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
-      Variable *Spill = Func->makeVariable(IceType_f64, Context.getNode());
+      SpillVariable *SpillVar =
+          Func->makeVariable<SpillVariable>(IceType_f64, Context.getNode());
+      SpillVar->setLinkedTo(llvm::dyn_cast<Variable>(Src0RM));
+      Variable *Spill = SpillVar;
       Spill->setWeight(RegWeight::Zero);
-      Spill->setPreferredRegister(llvm::dyn_cast<Variable>(Src0RM), true);
       _movq(Spill, Src0RM);
 
       Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
       Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
       Variable *T_Lo = makeReg(IceType_i32);
       Variable *T_Hi = makeReg(IceType_i32);
       VariableSplit *SpillLo =
           VariableSplit::create(Func, Spill, VariableSplit::Low);
       VariableSplit *SpillHi =
           VariableSplit::create(Func, Spill, VariableSplit::High);
 
       _mov(T_Lo, SpillLo);
       _mov(DestLo, T_Lo);
       _mov(T_Hi, SpillHi);
       _mov(DestHi, T_Hi);
     } break;
     case IceType_f64: {
       Src0 = legalize(Src0);
       assert(Src0->getType() == IceType_i64);
       // 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
-      Variable *Spill = Func->makeVariable(IceType_f64, Context.getNode());
+      SpillVariable *SpillVar =
+          Func->makeVariable<SpillVariable>(IceType_f64, Context.getNode());
+      SpillVar->setLinkedTo(Dest);
+      Variable *Spill = SpillVar;
       Spill->setWeight(RegWeight::Zero);
-      Spill->setPreferredRegister(Dest, true);
 
       Variable *T_Lo = NULL, *T_Hi = NULL;
       VariableSplit *SpillLo =
           VariableSplit::create(Func, Spill, VariableSplit::Low);
       VariableSplit *SpillHi =
           VariableSplit::create(Func, Spill, 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 used.
@@ skipping 1374 matching lines @@
     Base = Var;
     Offset += MoreOffset;
     Reason = BaseInst;
     return true;
   }
   return false;
 }
 
 void computeAddressOpt(Cfg *Func, const Inst *Instr, Variable *&Base,
                        Variable *&Index, uint16_t &Shift, int32_t &Offset) {
-  Func->setCurrentNode(NULL);
+  Func->resetCurrentNode();
   if (Func->getContext()->isVerbose(IceV_AddrOpt)) {
     Ostream &Str = Func->getContext()->getStrDump();
     Str << "\nStarting computeAddressOpt for instruction:\n  ";
     Instr->dumpDecorated(Func);
   }
   (void)Offset; // TODO: pattern-match for non-zero offsets.
   if (Base == NULL)
     return;
   // If the Base has more than one use or is live across multiple
   // blocks, then don't go further.  Alternatively (?), never consider
@@ skipping 814 matching lines @@
     Str << "\t.align\t" << Align << "\n";
     Str << MangledName << ":\n";
     for (SizeT i = 0; i < Size; ++i) {
       Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
     }
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   }
 }
 
 } // end of namespace Ice