Subzero: Local variable splitting.

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
 /// \brief Implements the TargetLoweringX86Base class, which consists almost
 /// entirely of the lowering sequence for each high-level instruction.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H
 #define SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalInits.h"
 #include "IceInstVarIter.h"
+#include "IceInstX86Base.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IcePhiLoweringImpl.h"
 #include "IceUtils.h"
-#include "IceInstX86Base.h"
+#include "IceVariableSplitting.h"
+
 #include "llvm/Support/MathExtras.h"
 
 #include <stack>
 
 namespace Ice {
 namespace X86 {
 template <typename T> struct PoolTypeConverter {};
 
 template <> struct PoolTypeConverter<float> {
   using PrimitiveIntType = uint32_t;
@@ skipping 473 matching lines @@
     BoolFlagSaver B(RandomizationPoolingPaused, true);
     doLoadOpt();
   }
   Func->genCode();
   if (Func->hasError())
     return;
   if (SandboxingType != ST_None) {
     initSandbox();
   }
   Func->dump("After x86 codegen");
+  splitBlockLocalVariables(Func);
 
   // Register allocation. This requires instruction renumbering and full
   // liveness analysis. Loops must be identified before liveness so variable
   // use weights are correct.
   Func->renumberInstructions();
   if (Func->hasError())
     return;
   Func->liveness(Liveness_Intervals);
   if (Func->hasError())
     return;
@@ skipping 501 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 (Var->getLinkedTo() != nullptr) {
-          // TODO(stichnot): This assert won't necessarily be true in the
-          // future.
-          assert(Var->mustNotHaveReg());
-          if (!Var->getLinkedTo()->hasReg()) {
+        // TODO(stichnot): Refactor this into the base class.
+        Variable *Root = Var->getLinkedToStackRoot();
+        if (Root != nullptr) {
+          assert(!Root->hasReg());
+          if (!Root->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) {
-    const Variable *Root = Var->getLinkedToRoot();
+    const Variable *Root = Var->getLinkedToStackRoot();
     assert(Root != nullptr);
     Var->setStackOffset(Root->getStackOffset());
   }
   this->HasComputedFrame = true;
 
   if (BuildDefs::dump() && Func->isVerbose(IceV_Frame)) {
     OstreamLocker L(Func->getContext());
     Ostream &Str = Func->getContext()->getStrDump();
 
     Str << "Stack layout:\n";
@@ skipping 119 matching lines @@
     return;
   }
   emitSandboxedReturn();
   if (RI->getSrcSize()) {
     auto *RetValue = llvm::cast<Variable>(RI->getSrc(0));
     Context.insert<InstFakeUse>(RetValue);
   }
   RI->setDeleted();
 }
 
+template <typename TraitsType>
+Inst *TargetX86Base<TraitsType>::createLoweredMove(Variable *Dest,
+                                                   Variable *SrcVar) {
+  if (isVectorType(Dest->getType())) {
+    return Traits::Insts::Movp::create(Func, Dest, SrcVar);
+  }
+  return Traits::Insts::Mov::create(Func, Dest, SrcVar);
+}
+
 template <typename TraitsType> Type TargetX86Base<TraitsType>::stackSlotType() {
   return Traits::WordType;
 }
 
 template <typename TraitsType>
 template <typename T>
 typename std::enable_if<!T::Is64Bit, Operand>::type *
 TargetX86Base<TraitsType>::loOperand(Operand *Operand) {
   assert(Operand->getType() == IceType_i64 ||
          Operand->getType() == IceType_f64);
@@ skipping 1754 matching lines @@
     case IceType_f64: {
       assert(Src0->getType() == IceType_i64);
       if (Traits::Is64Bit) {
         Operand *Src0RM = legalize(Src0, Legal_Reg | Legal_Mem);
         Variable *T = makeReg(IceType_f64);
         _movd(T, Src0RM);
         _mov(Dest, T);
       } else {
         Src0 = legalize(Src0);
         if (llvm::isa<X86OperandMem>(Src0)) {
-          Variable *T = Func->makeVariable(DestTy);
+          Variable *T = makeReg(DestTy);
           _movq(T, Src0);
           _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
@@ skipping 4933 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H