Subzero: Ignore variables with no actual uses.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 643 matching lines @@
       return;
     Name = VariableString::createWithString(Func, NewName);
   }
 
   bool getIsArg() const { return IsArgument; }
   virtual void setIsArg(bool Val = true) { IsArgument = Val; }
   bool getIsImplicitArg() const { return IsImplicitArgument; }
   void setIsImplicitArg(bool Val = true) { IsImplicitArgument = Val; }
 
   void setIgnoreLiveness() { IgnoreLiveness = true; }
-  bool getIgnoreLiveness() const { return IgnoreLiveness; }
+  bool getIgnoreLiveness() const {
+    return IgnoreLiveness || IsRematerializable;
+  }
 
   int32_t getStackOffset() const { return StackOffset; }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
   std::string getSymbolicStackOffset(const Cfg *Func) const {
     if (!BuildDefs::dump())
       return "";
     return "lv$" + getName(Func);
   }
@@ skipping 181 matching lines @@
 enum MetadataKind {
   VMK_Uses,       /// Track only uses, not defs
   VMK_SingleDefs, /// Track uses+defs, but only record single def
   VMK_All         /// Track uses+defs, including full def list
 };
 using InstDefList = CfgVector<const Inst *>;
 
 /// VariableTracking tracks the metadata for a single variable.  It is
 /// only meant to be used internally by VariablesMetadata.
 class VariableTracking {
-  VariableTracking &operator=(const VariableTracking &) = delete;
-
 public:
   enum MultiDefState {
     // TODO(stichnot): Consider using just a simple counter.
     MDS_Unknown,
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     MDS_MultiDefMultiBlock
   };
-  enum MultiBlockState { MBS_Unknown, MBS_SingleBlock, MBS_MultiBlock };
+  enum MultiBlockState {
+    MBS_Unknown,     // Not yet initialized, so be conservative
+    MBS_NoUses,      // Known to have no uses
+    MBS_SingleBlock, // All uses in are in a single block
+    MBS_MultiBlock   // Several uses across several blocks
+  };
   VariableTracking() = default;
   VariableTracking(const VariableTracking &) = default;
+  VariableTracking &operator=(const VariableTracking &) = default;
+  VariableTracking(MultiBlockState MultiBlock) : MultiBlock(MultiBlock) {}
   MultiDefState getMultiDef() const { return MultiDef; }
   MultiBlockState getMultiBlock() const { return MultiBlock; }
   const Inst *getFirstDefinitionSingleBlock() const;
   const Inst *getSingleDefinition() const;
   const Inst *getFirstDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
   CfgNode *getNode() const { return SingleUseNode; }
   RegWeight getUseWeight() const { return UseWeight; }
   void markUse(MetadataKind TrackingKind, const Inst *Instr, CfgNode *Node,
                bool IsImplicit);
@@ skipping 52 matching lines @@
   const Inst *getFirstDefinition(const Variable *Var) const;
   const InstDefList &getLatterDefinitions(const Variable *Var) const;
 
   /// Returns whether the given Variable is live across multiple blocks. Mainly,
   /// this is used to partition Variables into single-block versus multi-block
   /// sets for leveraging sparsity in liveness analysis, and for implementing
   /// simple stack slot coalescing. As a special case, function arguments are
   /// always considered multi-block because they are live coming into the entry
   /// block.
   bool isMultiBlock(const Variable *Var) const;
+  bool isSingleBlock(const Variable *Var) const;
   /// Returns the node that the given Variable is used in, assuming
   /// isMultiBlock() returns false. Otherwise, nullptr is returned.
   CfgNode *getLocalUseNode(const Variable *Var) const;
 
   /// Returns the total use weight computed as the sum of uses multiplied by a
   /// loop nest depth factor for each use.
   RegWeight getUseWeight(const Variable *Var) const;
 
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H