Subzero: Completely remove tracking of stack pointer live range.

src/IceLiveness.cpp

 //===- subzero/src/IceLiveness.cpp - Liveness analysis implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 53 matching lines @@
   // the counts to 0.
   for (auto I = FirstNode, E = Func->getNodes().end(); I != E; ++I) {
     LivenessNode &N = Nodes[(*I)->getIndex()];
     N.LiveToVarMap.assign(N.NumLocals, nullptr);
     N.NumLocals = 0;
     N.NumNonDeadPhis = 0;
   }
   if (IsFullInit)
     LiveToVarMap.assign(NumGlobals, nullptr);
 
-  // Sort each variable into the appropriate LiveToVarMap.  Also set
-  // VarToLiveMap.
+  // Initialize the bitmask of which variables to track.
+  RangeMask.resize(NumVars);
+  RangeMask.set(0, NumVars); // Track all variables by default.
+
+  // Sort each variable into the appropriate LiveToVarMap.  Set VarToLiveMap.
+  // Set RangeMask correctly for each variable.
   TmpNumGlobals = 0;
   for (auto I = FirstVar, E = Func->getVariables().end(); I != E; ++I) {
     Variable *Var = *I;
     SizeT VarIndex = Var->getIndex();
     SizeT LiveIndex;
     if (VMetadata->isMultiBlock(Var)) {
       LiveIndex = TmpNumGlobals++;
       LiveToVarMap[LiveIndex] = Var;
     } else {
       SizeT NodeIndex = VMetadata->getLocalUseNode(Var)->getIndex();
       LiveIndex = Nodes[NodeIndex].NumLocals++;
       Nodes[NodeIndex].LiveToVarMap[LiveIndex] = Var;
       LiveIndex += NumGlobals;
     }
     VarToLiveMap[VarIndex] = LiveIndex;
+    if (Var->getIgnoreLiveness() ||
+        (!IsFullInit && !Var->hasReg() && !Var->getWeight().isInf()))

[jvoung (off chromium), 2015/08/06 21:39:14]

I wasn't sure if the extra conditions here:
(!IsFullInit && !Var->hasReg && !Var->getWeight().isInf()) conflict with the
earlier change: https://codereview.chromium.org/1271923002, since this set of
vars is from FirstVar to End (could reflect new vars created from phi lowering)?

"For post phi lowering liveness analysis, all variables created from phi
lowering..., are tracked".  I thought it was just the ones before FirstVar that
had the extra conditions related to !hasReg and !isInf.

[Jim Stichnoth, 2015/08/06 22:38:50]

Yikes, thanks!  This change basically reverted that previous CL.  With the
latest patchset, the spec2k asm is identical to that in master.

+      RangeMask[VarIndex] = false;
   }
   assert(TmpNumGlobals == (IsFullInit ? NumGlobals : 0));
 
+  // Fix up RangeMask for variables before FirstVar.
+  for (auto I = Func->getVariables().begin(); I != FirstVar; ++I) {
+    Variable *Var = *I;
+    SizeT VarIndex = Var->getIndex();
+    if (Var->getIgnoreLiveness() ||
+        (!IsFullInit && !Var->hasReg() && !Var->getWeight().isInf()))
+      RangeMask[VarIndex] = false;
+  }
+
   // Process each node.
   for (auto I = FirstNode, E = Func->getNodes().end(); I != E; ++I) {
     LivenessNode &Node = Nodes[(*I)->getIndex()];
     // NumLocals, LiveToVarMap already initialized
     Node.LiveIn.resize(NumGlobals);
     Node.LiveOut.resize(NumGlobals);
     // LiveBegin and LiveEnd are reinitialized before each pass over
     // the block.
   }
-
-  // Initialize the bitmask of which variables to track.
-  RangeMask.resize(NumVars);
-  RangeMask.set(0, NumVars);
-  if (!IsFullInit) {
-    // Reset initial variables that are not pre-colored or infinite-weight.
-    for (auto I = Func->getVariables().begin(); I != FirstVar; ++I) {
-      Variable *Var = *I;
-      RangeMask[Var->getIndex()] = (Var->hasReg() || Var->getWeight().isInf());
-    }
-  }
 }
 
 void Liveness::init() {
   constexpr bool IsFullInit = true;
   NodeList::const_iterator FirstNode = Func->getNodes().begin();
   VarList::const_iterator FirstVar = Func->getVariables().begin();
   initInternal(FirstNode, FirstVar, IsFullInit);
 }
 
 void Liveness::initPhiEdgeSplits(NodeList::const_iterator FirstNode,
                                  VarList::const_iterator FirstVar) {
   constexpr bool IsFullInit = false;
   initInternal(FirstNode, FirstVar, IsFullInit);
 }
 
 Variable *Liveness::getVariable(SizeT LiveIndex, const CfgNode *Node) const {
   if (LiveIndex < NumGlobals)
     return LiveToVarMap[LiveIndex];
   SizeT NodeIndex = Node->getIndex();
   return Nodes[NodeIndex].LiveToVarMap[LiveIndex - NumGlobals];
 }
 
 } // end of namespace Ice