Subzero. Fixes memory leaks.

src/IceInst.h

Index: src/IceInst.h
diff --git a/src/IceInst.h b/src/IceInst.h
index 99a86539a2aade5f5258ed799526ef860b315473..b5413fe02f916a2f6d813b52e9187c637a7f13a9 100644
--- a/src/IceInst.h
+++ b/src/IceInst.h
@@ -161,8 +161,6 @@ public:
   void dumpDest(const Cfg *Func) const;
   virtual bool isRedundantAssign() const { return false; }
 
-  virtual ~Inst() {}
-
 protected:
   Inst(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest);
   void addSource(Operand *Src) {
@@ -229,7 +227,6 @@ protected:
   void emitIAS(const Cfg * /*Func*/) const override {
     llvm_unreachable("emitIAS() called on a non-lowered instruction");
   }
-  ~InstHighLevel() override {}
 };
 
 // Alloca instruction.  This captures the size in bytes as getSrc(0),
@@ -254,7 +251,7 @@ public:
 private:
   InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
              Variable *Dest);
-  ~InstAlloca() override {}
+
   const uint32_t AlignInBytes;
 };
 
@@ -289,7 +286,6 @@ public:
 private:
   InstArithmetic(Cfg *Func, OpKind Op, Variable *Dest, Operand *Source1,
                  Operand *Source2);
-  ~InstArithmetic() override {}
 
   const OpKind Op;
 };
@@ -315,7 +311,6 @@ public:
 
 private:
   InstAssign(Cfg *Func, Variable *Dest, Operand *Source);
-  ~InstAssign() override {}
 };
 
 // Branch instruction.  This represents both conditional and
@@ -359,7 +354,6 @@ private:
   InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue, CfgNode *TargetFalse);
   // Unconditional branch
   InstBr(Cfg *Func, CfgNode *Target);
-  ~InstBr() override {}
 
   CfgNode *TargetFalse; // Doubles as unconditional branch target
   CfgNode *TargetTrue;  // nullptr if unconditional branch
@@ -399,7 +393,6 @@ protected:
     HasSideEffects = HasSideEff;
     addSource(CallTarget);
   }
-  ~InstCall() override {}
 
 private:
   bool HasTailCall;
@@ -432,7 +425,7 @@ public:
 
 private:
   InstCast(Cfg *Func, OpKind CastKind, Variable *Dest, Operand *Source);
-  ~InstCast() override {}
+
   const OpKind CastKind;
 };
 
@@ -457,7 +450,6 @@ public:
 private:
   InstExtractElement(Cfg *Func, Variable *Dest, Operand *Source1,
                      Operand *Source2);
-  ~InstExtractElement() override {}
 };
 
 // Floating-point comparison instruction.  The source operands are
@@ -487,7 +479,7 @@ public:
 private:
   InstFcmp(Cfg *Func, FCond Condition, Variable *Dest, Operand *Source1,
            Operand *Source2);
-  ~InstFcmp() override {}
+
   const FCond Condition;
 };
 
@@ -518,7 +510,7 @@ public:
 private:
   InstIcmp(Cfg *Func, ICond Condition, Variable *Dest, Operand *Source1,
            Operand *Source2);
-  ~InstIcmp() override {}
+
   const ICond Condition;
 };
 
@@ -543,7 +535,6 @@ public:
 private:
   InstInsertElement(Cfg *Func, Variable *Dest, Operand *Source1,
                     Operand *Source2, Operand *Source3);
-  ~InstInsertElement() override {}
 };
 
 // Call to an intrinsic function.  The call target is captured as getSrc(0),
@@ -572,7 +563,7 @@ private:
       : InstCall(Func, NumArgs, Dest, CallTarget, false, Info.HasSideEffects,
                  Inst::IntrinsicCall),
         Info(Info) {}
-  ~InstIntrinsicCall() override {}
+
   const Intrinsics::IntrinsicInfo Info;
 };
 
@@ -595,7 +586,6 @@ public:
 
 private:
   InstLoad(Cfg *Func, Variable *Dest, Operand *SourceAddr);
-  ~InstLoad() override {}
 };
 
 // Phi instruction.  For incoming edge I, the node is Labels[I] and
@@ -624,7 +614,6 @@ private:
     Func->deallocateArrayOf<CfgNode *>(Labels);
     Inst::destroy(Func);
   }
-  ~InstPhi() override {}
 
   // Labels[] duplicates the InEdges[] information in the enclosing
   // CfgNode, but the Phi instruction is created before InEdges[]
@@ -655,7 +644,6 @@ public:
 
 private:
   InstRet(Cfg *Func, Operand *RetValue);
-  ~InstRet() override {}
 };
 
 // Select instruction.  The condition, true, and false operands are captured.
@@ -679,7 +667,6 @@ public:
 private:
   InstSelect(Cfg *Func, Variable *Dest, Operand *Condition, Operand *Source1,
              Operand *Source2);
-  ~InstSelect() override {}
 };
 
 // Store instruction.  The address operand is captured, along with the
@@ -705,7 +692,6 @@ public:
 
 private:
   InstStore(Cfg *Func, Operand *Data, Operand *Addr);
-  ~InstStore() override {}
 };
 
 // Switch instruction.  The single source operand is captured as
@@ -745,7 +731,6 @@ private:
     Func->deallocateArrayOf<CfgNode *>(Labels);
     Inst::destroy(Func);
   }
-  ~InstSwitch() override {}
 
   CfgNode *LabelDefault;
   SizeT NumCases;   // not including the default case
@@ -772,7 +757,6 @@ public:
 
 private:
   explicit InstUnreachable(Cfg *Func);
-  ~InstUnreachable() override {}
 };
 
 // BundleLock instruction.  There are no operands.  Contains an option
@@ -799,7 +783,6 @@ public:
 private:
   Option BundleOption;
   InstBundleLock(Cfg *Func, Option BundleOption);
-  ~InstBundleLock() override {}
 };
 
 // BundleUnlock instruction.  There are no operands.
@@ -821,7 +804,6 @@ public:
 
 private:
   explicit InstBundleUnlock(Cfg *Func);
-  ~InstBundleUnlock() override {}
 };
 
 // FakeDef instruction.  This creates a fake definition of a variable,
@@ -853,7 +835,6 @@ public:
 
 private:
   InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src);
-  ~InstFakeDef() override {}
 };
 
 // FakeUse instruction.  This creates a fake use of a variable, to
@@ -877,7 +858,6 @@ public:
 
 private:
   InstFakeUse(Cfg *Func, Variable *Src);
-  ~InstFakeUse() override {}
 };
 
 // FakeKill instruction.  This "kills" a set of variables by modeling
@@ -907,7 +887,6 @@ public:
 
 private:
   InstFakeKill(Cfg *Func, const Inst *Linked);
-  ~InstFakeKill() override {}
 
   // This instruction is ignored if Linked->isDeleted() is true.
   const Inst *Linked;
@@ -930,7 +909,6 @@ protected:
       : Inst(Func, Kind, MaxSrcs, Dest) {
     assert(Kind >= Target);
   }
-  ~InstTarget() override {}
 };
 
 bool checkForRedundantAssign(const Variable *Dest, const Operand *Source);