Subzero: Improve performance of liveness analysis and live range construction.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides some of the support for the Liveness class.  In
@@ skipping 14 matching lines @@
 #include "IceInst.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 
 namespace Ice {
 
 void Liveness::init() {
   // Initialize most of the container sizes.
   SizeT NumVars = Func->getVariables().size();
   SizeT NumNodes = Func->getNumNodes();
+  VariablesMetadata *VMetadata = Func->getVMetadata();
   Nodes.resize(NumNodes);
   VarToLiveMap.resize(NumVars);
   if (Mode == Liveness_Intervals)
     LiveRanges.resize(NumVars);
 
   // Count the number of globals, and the number of locals for each
   // block.
   for (SizeT i = 0; i < NumVars; ++i) {
     Variable *Var = Func->getVariables()[i];
-    if (Func->getVMetadata()->isMultiBlock(Var)) {
+    if (VMetadata->isMultiBlock(Var)) {
       ++NumGlobals;
     } else {
-      SizeT Index = Func->getVMetadata()->getLocalUseNode(Var)->getIndex();
+      SizeT Index = VMetadata->getLocalUseNode(Var)->getIndex();
       ++Nodes[Index].NumLocals;
     }
   }
 
   // Resize each LivenessNode::LiveToVarMap, and the global
   // LiveToVarMap.  Reset the counts to 0.
   for (SizeT i = 0; i < NumNodes; ++i) {
     Nodes[i].LiveToVarMap.assign(Nodes[i].NumLocals, NULL);
     Nodes[i].NumLocals = 0;
   }
   LiveToVarMap.assign(NumGlobals, NULL);
 
   // Sort each variable into the appropriate LiveToVarMap.  Also set
   // VarToLiveMap.
   SizeT TmpNumGlobals = 0;
   for (SizeT i = 0; i < NumVars; ++i) {
     Variable *Var = Func->getVariables()[i];
     SizeT VarIndex = Var->getIndex();
     SizeT LiveIndex;
-    if (Func->getVMetadata()->isMultiBlock(Var)) {
+    if (VMetadata->isMultiBlock(Var)) {
       LiveIndex = TmpNumGlobals++;
       LiveToVarMap[LiveIndex] = Var;
     } else {
-      SizeT NodeIndex = Func->getVMetadata()->getLocalUseNode(Var)->getIndex();
+      SizeT NodeIndex = VMetadata->getLocalUseNode(Var)->getIndex();
       LiveIndex = Nodes[NodeIndex].NumLocals++;
       Nodes[NodeIndex].LiveToVarMap[LiveIndex] = Var;
       LiveIndex += NumGlobals;
     }
     VarToLiveMap[VarIndex] = LiveIndex;
   }
   assert(NumGlobals == TmpNumGlobals);
 
   // Process each node.
   const NodeList &LNodes = Func->getNodes();
   SizeT NumLNodes = LNodes.size();
   for (SizeT i = 0; i < NumLNodes; ++i) {
     LivenessNode &Node = Nodes[LNodes[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.
   }
 }
 
 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];
 }
 
-SizeT Liveness::getLiveIndex(const Variable *Var) const {
-  return VarToLiveMap[Var->getIndex()];
-}
-
 void Liveness::addLiveRange(Variable *Var, InstNumberT Start, InstNumberT End,
                             uint32_t WeightDelta) {
   LiveRange &LiveRange = LiveRanges[Var->getIndex()];
   assert(WeightDelta != RegWeight::Inf);
   LiveRange.addSegment(Start, End);
   LiveRange.addWeight(WeightDelta);
 }
 
 LiveRange &Liveness::getLiveRange(Variable *Var) {
   return LiveRanges[Var->getIndex()];
 }
 
 } // end of namespace Ice