Subzero: Use CFG-local arena allocation for relevant containers.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 69 matching lines @@
   // object's destructor should delete this object.  Generally,
   // constants are pooled globally, variables are pooled per-CFG, and
   // target-specific operands are not pooled.
   virtual bool isPooled() const { return false; }
 
   virtual ~Operand() {}
 
 protected:
   Operand(OperandKind Kind, Type Ty)
       : Ty(Ty), Kind(Kind), NumVars(0), Vars(NULL) {}
-  Operand(Operand &&O) = default;
 
   const Type Ty;
   const OperandKind Kind;
   // Vars and NumVars are initialized by the derived class.
   SizeT NumVars;
   Variable **Vars;
 };
 
 template<class StreamType>
 inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
@@ skipping 254 matching lines @@
   void untrim() { TrimmedBegin = Range.begin(); }
   void trim(InstNumberT Lower);
 
   RegWeight getWeight() const { return Weight; }
   void setWeight(const RegWeight &NewWeight) { Weight = NewWeight; }
   void addWeight(uint32_t Delta) { Weight.addWeight(Delta); }
   void dump(Ostream &Str) const;
 
 private:
   typedef std::pair<InstNumberT, InstNumberT> RangeElementType;
-  // Assume a common case of 2 or fewer segments per live range.
-  typedef llvm::SmallVector<RangeElementType, 2> RangeType;
+  // RangeType is arena-allocated from the Cfg's allocator.
+  typedef std::vector<RangeElementType, CfgLocalAllocator<RangeElementType>>
+  RangeType;
   RangeType Range;
   RegWeight Weight;
   // TrimmedBegin is an optimization for the overlaps() computation.
   // Since the linear-scan algorithm always calls it as overlaps(Cur)
   // and Cur advances monotonically according to live range start, we
   // can optimize overlaps() by ignoring all segments that end before
   // the start of Cur's range.  The linear-scan code enables this by
   // calling trim() on the ranges of interest as Cur advances.  Note
   // that linear-scan also has to initialize TrimmedBegin at the
   // beginning by calling untrim().
   RangeType::const_iterator TrimmedBegin;
 };
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L);
 
 // Variable represents an operand that is register-allocated or
 // stack-allocated.  If it is register-allocated, it will ultimately
 // have a non-negative RegNum field.
 class Variable : public Operand {
   Variable(const Variable &) = delete;
   Variable &operator=(const Variable &) = delete;
-  Variable(Variable &&V) = default;
 
 public:
   static Variable *create(Cfg *Func, Type Ty, SizeT Index) {
     return new (Func->allocate<Variable>()) Variable(kVariable, Ty, Index);
   }
 
   SizeT getIndex() const { return Number; }
   IceString getName(const Cfg *Func) const;
   void setName(Cfg *Func, const IceString &NewName) {
     // Make sure that the name can only be set once.
@@ skipping 60 matching lines @@
   Variable *getHi() const { return HiVar; }
   void setLoHi(Variable *Lo, Variable *Hi) {
     assert(LoVar == NULL);
     assert(HiVar == NULL);
     LoVar = Lo;
     HiVar = Hi;
   }
   // Creates a temporary copy of the variable with a different type.
   // Used primarily for syntactic correctness of textual assembly
   // emission.  Note that only basic information is copied, in
-  // particular not DefInst, IsArgument, Weight, LoVar, HiVar,
-  // VarsReal.
-  Variable asType(Type Ty);
+  // particular not IsArgument, IsImplicitArgument, IgnoreLiveness,
+  // RegNumTmp, Weight, Live, LoVar, HiVar, VarsReal.
+  Variable *asType(Type Ty);
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Num;
   }
 
-  // The destructor is public because of the asType() method.
-  ~Variable() override {}
-
 protected:
   Variable(OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index), NameIndex(Cfg::IdentifierIndexInvalid),
         IsArgument(false), IsImplicitArgument(false), IgnoreLiveness(false),
         StackOffset(0), RegNum(NoRegister), RegNumTmp(NoRegister), Weight(1),
         LoVar(NULL), HiVar(NULL) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
+  ~Variable() override {}
   // Number is unique across all variables, and is used as a
   // (bit)vector index for liveness analysis.
   const SizeT Number;
   Cfg::IdentifierIndexType NameIndex;
   bool IsArgument;
   bool IsImplicitArgument;
   // IgnoreLiveness means that the variable should be ignored when
   // constructing and validating live ranges.  This is usually
   // reserved for the stack pointer.
   bool IgnoreLiveness;
@@ skipping 126 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H