Subzero: Control memory growth from local label fixups.

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 252 matching lines @@
 }
 
 /// RelocOffset allows symbolic references in ConstantRelocatables' offsets,
 /// e.g., 8 + LabelOffset, where label offset is the location (code or data)
 /// of a Label that is only determinable during ELF emission.
 class RelocOffset final {
   RelocOffset(const RelocOffset &) = delete;
   RelocOffset &operator=(const RelocOffset &) = delete;
 
 public:
-  static RelocOffset *create(GlobalContext *Ctx) {
-    return new (Ctx->allocate<RelocOffset>()) RelocOffset();
+  template <typename T> static RelocOffset *create(T *AllocOwner) {
+    return new (AllocOwner->template allocate<RelocOffset>()) RelocOffset();
   }
 
   static RelocOffset *create(GlobalContext *Ctx, RelocOffsetT Value) {
     return new (Ctx->allocate<RelocOffset>()) RelocOffset(Value);
   }
 
   void setSubtract(bool Value) { Subtract = Value; }
   bool hasOffset() const { return HasOffset; }
 
   RelocOffsetT getOffset() const {
@@ skipping 50 matching lines @@
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
-  static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
+  template <typename T>
+  static ConstantRelocatable *create(T *AllocOwner, Type Ty,
                                      const RelocatableTuple &Tuple) {
-    return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
-        Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name, Tuple.EmitString);
+    return new (AllocOwner->template allocate<ConstantRelocatable>())
+        ConstantRelocatable(Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name,
+                            Tuple.EmitString);
   }
 
   RelocOffsetT getOffset() const {
     RelocOffsetT Ret = Offset;
     for (const auto *const OffsetReloc : OffsetExpr) {
       Ret += OffsetReloc->getOffset();
     }
     return Ret;
   }
 
@@ skipping 582 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H