[SubZero] Implement address optimization for MIPS

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 962 matching lines @@
     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 CfgNode *getSingleDefinitionNode() 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);
   void markDef(MetadataKind TrackingKind, const Inst *Instr, CfgNode *Node);
 
 private:
   MultiDefState MultiDef = MDS_Unknown;
   MultiBlockState MultiBlock = MBS_Unknown;
   CfgNode *SingleUseNode = nullptr;
   CfgNode *SingleDefNode = nullptr;
   /// All definitions of the variable are collected in Definitions[] (except for
   /// the earliest definition), in increasing order of instruction number.
   InstDefList Definitions; /// Only used if Kind==VMK_All
   const Inst *FirstOrSingleDefinition = nullptr;
+  const CfgNode *FirstOrSingleDefinitionNode = nullptr;
   RegWeight UseWeight;
 };
 
 /// VariablesMetadata analyzes and summarizes the metadata for the complete set
 /// of Variables.
 class VariablesMetadata {
   VariablesMetadata() = delete;
   VariablesMetadata(const VariablesMetadata &) = delete;
   VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 
@@ skipping 17 matching lines @@
   bool isMultiDef(const Variable *Var) const;
   /// Returns the first definition instruction of the given Variable. This is
   /// only valid for variables whose definitions are all within the same block,
   /// e.g. T after the lowered sequence "T=B; T+=C; A=T", for which
   /// getFirstDefinitionSingleBlock(T) would return the "T=B" instruction. For
   /// variables with definitions span multiple blocks, nullptr is returned.
   const Inst *getFirstDefinitionSingleBlock(const Variable *Var) const;
   /// Returns the definition instruction of the given Variable, when the
   /// variable has exactly one definition. Otherwise, nullptr is returned.
   const Inst *getSingleDefinition(const Variable *Var) const;
+  const CfgNode *getSingleDefinitionNode(const Variable *Var) const;
   /// getFirstDefinition() and getLatterDefinitions() are used together to
   /// return the complete set of instructions that define the given Variable,
   /// regardless of whether the definitions are within the same block (in
   /// contrast to getFirstDefinitionSingleBlock).
   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
@@ skipping 42 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H