[TableGen] Fix all remaining memory leaks of Init and RecTy objects.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@235696 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/TableGen/Record.h b/include/llvm/TableGen/Record.h
index 3c5723155eb3b4cd175faea36459355675b7aa84..fb5a6573526943a3d1e98c46b982043c7a399d45 100644 (file)
--- a/include/llvm/TableGen/Record.h
+++ b/include/llvm/TableGen/Record.h
@@ -81,7 +81,7 @@ public:
 
 private:
   RecTyKind Kind;
 
 private:
   RecTyKind Kind;

-  ListRecTy *ListTy;
+  std::unique_ptr<ListRecTy> ListTy;

   virtual void anchor();
 
 public:
   virtual void anchor();
 
 public:


@@ -566,6 +566,11 @@ class TypedInit : public Init {
 
 protected:
   explicit TypedInit(InitKind K, RecTy *T) : Init(K), Ty(T) {}
 
 protected:
   explicit TypedInit(InitKind K, RecTy *T) : Init(K), Ty(T) {}

+  ~TypedInit() {
+    // If this is a DefInit we need to delete the RecordRecTy.
+    if (getKind() == IK_DefInit)
+      delete Ty;
+  }

 
 public:
   static bool classof(const Init *I) {
 
 public:
   static bool classof(const Init *I) {

diff --git a/lib/TableGen/Record.cpp b/lib/TableGen/Record.cpp
index 5698de02d68a255dfce036c1289c2805b4217820..560e7c991d9b50b9f014b96d33f86291dc00a59c 100644 (file)
--- a/lib/TableGen/Record.cpp
+++ b/lib/TableGen/Record.cpp
@@ -91,8 +91,8 @@ void RecTy::dump() const { print(errs()); }
 
 ListRecTy *RecTy::getListTy() {
   if (!ListTy)
 
 ListRecTy *RecTy::getListTy() {
   if (!ListTy)

-    ListTy = new ListRecTy(this);
-  return ListTy;
+    ListTy.reset(new ListRecTy(this));
+  return ListTy.get();

 }
 
 bool RecTy::baseClassOf(const RecTy *RHS) const{
 }
 
 bool RecTy::baseClassOf(const RecTy *RHS) const{


@@ -141,13 +141,13 @@ bool BitRecTy::baseClassOf(const RecTy *RHS) const{
 }
 
 BitsRecTy *BitsRecTy::get(unsigned Sz) {
 }
 
 BitsRecTy *BitsRecTy::get(unsigned Sz) {

-  static std::vector<BitsRecTy*> Shared;
+  static std::vector<std::unique_ptr<BitsRecTy>> Shared;

   if (Sz >= Shared.size())
     Shared.resize(Sz + 1);
   if (Sz >= Shared.size())
     Shared.resize(Sz + 1);

-  BitsRecTy *&Ty = Shared[Sz];
+  std::unique_ptr<BitsRecTy> &Ty = Shared[Sz];

   if (!Ty)
   if (!Ty)

-    Ty = new BitsRecTy(Sz);
-  return Ty;
+    Ty.reset(new BitsRecTy(Sz));
+  return Ty.get();

 }
 
 std::string BitsRecTy::getAsString() const {
 }
 
 std::string BitsRecTy::getAsString() const {


@@ -451,8 +451,8 @@ ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
 }
 
 BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
 }
 
 BitsInit *BitsInit::get(ArrayRef<Init *> Range) {

-  typedef FoldingSet<BitsInit> Pool;
-  static Pool ThePool;  
+  static FoldingSet<BitsInit> ThePool;
+  static std::vector<std::unique_ptr<BitsInit>> TheActualPool;

 
   FoldingSetNodeID ID;
   ProfileBitsInit(ID, Range);
 
   FoldingSetNodeID ID;
   ProfileBitsInit(ID, Range);


@@ -463,7 +463,7 @@ BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
 
   BitsInit *I = new BitsInit(Range);
   ThePool.InsertNode(I, IP);
 
   BitsInit *I = new BitsInit(Range);
   ThePool.InsertNode(I, IP);

-
+  TheActualPool.push_back(std::unique_ptr<BitsInit>(I));

   return I;
 }
 
   return I;
 }
 


@@ -601,8 +601,7 @@ static void ProfileListInit(FoldingSetNodeID &ID,
 }
 
 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
 }
 
 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {

-  typedef FoldingSet<ListInit> Pool;
-  static Pool ThePool;
+  static FoldingSet<ListInit> ThePool;

   static std::vector<std::unique_ptr<ListInit>> TheActualPool;
 
   FoldingSetNodeID ID;
   static std::vector<std::unique_ptr<ListInit>> TheActualPool;
 
   FoldingSetNodeID ID;


@@ -995,8 +994,7 @@ TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs,
     Init *
     > Key;
 
     Init *
     > Key;
 

-  typedef DenseMap<Key, TernOpInit *> Pool;
-  static Pool ThePool;
+  static DenseMap<Key, std::unique_ptr<TernOpInit>> ThePool;

 
   Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc,
                                                                          Type),
 
   Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc,
                                                                          Type),


@@ -1004,9 +1002,9 @@ TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs,
                                            mhs),
                             rhs));
 
                                            mhs),
                             rhs));
 

-  TernOpInit *&I = ThePool[TheKey];
-  if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type);
-  return I;
+  std::unique_ptr<TernOpInit> &I = ThePool[TheKey];
+  if (!I) I.reset(new TernOpInit(opc, lhs, mhs, rhs, Type));
+  return I.get();

 }
 
 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
 }
 
 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,


@@ -1402,15 +1400,13 @@ Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const {
 VarListElementInit *VarListElementInit::get(TypedInit *T,
                                             unsigned E) {
   typedef std::pair<TypedInit *, unsigned> Key;
 VarListElementInit *VarListElementInit::get(TypedInit *T,
                                             unsigned E) {
   typedef std::pair<TypedInit *, unsigned> Key;

-  typedef DenseMap<Key, VarListElementInit *> Pool;
-
-  static Pool ThePool;
+  static DenseMap<Key, std::unique_ptr<VarListElementInit>> ThePool;

 
   Key TheKey(std::make_pair(T, E));
 
 
   Key TheKey(std::make_pair(T, E));
 

-  VarListElementInit *&I = ThePool[TheKey];
-  if (!I) I = new VarListElementInit(T, E);
-  return I;
+  std::unique_ptr<VarListElementInit> &I = ThePool[TheKey];
+  if (!I) I.reset(new VarListElementInit(T, E));
+  return I.get();

 }
 
 std::string VarListElementInit::getAsString() const {
 }
 
 std::string VarListElementInit::getAsString() const {


@@ -1440,7 +1436,7 @@ Init *VarListElementInit:: resolveListElementReference(Record &R,
     if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) {
       Init *Result2 = TInit->resolveListElementReference(R, RV, Elt);
       if (Result2) return Result2;
     if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) {
       Init *Result2 = TInit->resolveListElementReference(R, RV, Elt);
       if (Result2) return Result2;

-      return new VarListElementInit(TInit, Elt);
+      return VarListElementInit::get(TInit, Elt);

     }
     return Result;
   }
     }
     return Result;
   }


@@ -1470,14 +1466,13 @@ std::string DefInit::getAsString() const {
 
 FieldInit *FieldInit::get(Init *R, const std::string &FN) {
   typedef std::pair<Init *, TableGenStringKey> Key;
 
 FieldInit *FieldInit::get(Init *R, const std::string &FN) {
   typedef std::pair<Init *, TableGenStringKey> Key;

-  typedef DenseMap<Key, FieldInit *> Pool;
-  static Pool ThePool;  
+  static DenseMap<Key, std::unique_ptr<FieldInit>> ThePool;

 
   Key TheKey(std::make_pair(R, FN));
 
 
   Key TheKey(std::make_pair(R, FN));
 

-  FieldInit *&I = ThePool[TheKey];
-  if (!I) I = new FieldInit(R, FN);
-  return I;
+  std::unique_ptr<FieldInit> &I = ThePool[TheKey];
+  if (!I) I.reset(new FieldInit(R, FN));
+  return I.get();

 }
 
 Init *FieldInit::getBit(unsigned Bit) const {
 }
 
 Init *FieldInit::getBit(unsigned Bit) const {


@@ -1537,8 +1532,8 @@ DagInit *
 DagInit::get(Init *V, const std::string &VN,
              ArrayRef<Init *> ArgRange,
              ArrayRef<std::string> NameRange) {
 DagInit::get(Init *V, const std::string &VN,
              ArrayRef<Init *> ArgRange,
              ArrayRef<std::string> NameRange) {

-  typedef FoldingSet<DagInit> Pool;
-  static Pool ThePool;  
+  static FoldingSet<DagInit> ThePool;
+  static std::vector<std::unique_ptr<DagInit>> TheActualPool;

 
   FoldingSetNodeID ID;
   ProfileDagInit(ID, V, VN, ArgRange, NameRange);
 
   FoldingSetNodeID ID;
   ProfileDagInit(ID, V, VN, ArgRange, NameRange);


@@ -1549,7 +1544,7 @@ DagInit::get(Init *V, const std::string &VN,
 
   DagInit *I = new DagInit(V, VN, ArgRange, NameRange);
   ThePool.InsertNode(I, IP);
 
   DagInit *I = new DagInit(V, VN, ArgRange, NameRange);
   ThePool.InsertNode(I, IP);

-
+  TheActualPool.push_back(std::unique_ptr<DagInit>(I));

   return I;
 }
 
   return I;
 }
 


@@ -1661,9 +1656,13 @@ void Record::checkName() {
 }
 
 DefInit *Record::getDefInit() {
 }
 
 DefInit *Record::getDefInit() {

-  if (!TheInit)
-    TheInit = new DefInit(this, new RecordRecTy(this));
-  return TheInit;
+  static DenseMap<Record *, std::unique_ptr<DefInit>> ThePool;
+  if (TheInit)
+    return TheInit;
+
+  std::unique_ptr<DefInit> &I = ThePool[this];
+  if (!I) I.reset(new DefInit(this, new RecordRecTy(this)));
+  return I.get();

 }
 
 const std::string &Record::getName() const {
 }
 
 const std::string &Record::getName() const {