Clarify TemplateArgumentList ownership over its "flat" and

"structure" arg lists, the first step to fixing some massive
memory leaks.

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

diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index 3af89f9377eff94f5566b47b66d2cf72e0bebc9a..89eb152e857f6bc57d1d2c01e588f01e17501a83 100644 (file)
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -131,8 +131,6 @@ public:
   void BeginPack();
   void EndPack();
 
-  void ReleaseArgs();
-
   unsigned flatSize() const {
     return NumFlatArgs;
   }
@@ -165,7 +163,7 @@ class TemplateArgumentList {
   /// \brief The template argument list.
   ///
   /// The integer value will be non-zero to indicate that this
-  /// template argument list does not own the pointer.
+  /// template argument list does own the pointer.
   llvm::PointerIntPair<const TemplateArgument *, 1> FlatArguments;
 
   /// \brief The number of template arguments in this template
@@ -176,6 +174,10 @@ class TemplateArgumentList {
   unsigned NumStructuredArguments;
 
 public:
+  /// TemplateArgumentList - If this constructor is passed "true" for 'TakeArgs'
+  /// it copies them into a locally new[]'d array.  If passed "false", then it
+  /// just references the array passed in.  This is only safe if the builder
+  /// outlives it, but saves a copy.
   TemplateArgumentList(ASTContext &Context,
                        TemplateArgumentListBuilder &Builder,
                        bool TakeArgs);

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index cf4a242df79b19ac006311bd1162476b9374dd76..fe173991559c542eb5aabece4bd7c97a5609ec6b 100644 (file)
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -353,15 +353,6 @@ void TemplateArgumentListBuilder::EndPack() {
                                                       /*CopyArgs=*/false);
 }
 
-void TemplateArgumentListBuilder::ReleaseArgs() {
-  FlatArgs = 0;
-  NumFlatArgs = 0;
-  MaxFlatArgs = 0;
-  StructuredArgs = 0;
-  NumStructuredArgs = 0;
-  MaxStructuredArgs = 0;
-}
-
 //===----------------------------------------------------------------------===//
 // TemplateArgumentList Implementation
 //===----------------------------------------------------------------------===//
@@ -376,9 +367,23 @@ TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
   if (!TakeArgs)
     return;
 
-  if (Builder.getStructuredArguments() == Builder.getFlatArguments())
+  // If this does take ownership of the arguments, then we have to new them
+  // and copy over.
+  TemplateArgument *NewArgs = new TemplateArgument[Builder.flatSize()];
+  std::copy(Builder.getFlatArguments(),
+            Builder.getFlatArguments()+Builder.flatSize(), NewArgs);
+  FlatArguments.setPointer(NewArgs);
+      
+  // Just reuse the structured and flat arguments array if possible.
+  if (Builder.getStructuredArguments() == Builder.getFlatArguments()) {
+    StructuredArguments.setPointer(NewArgs);    
     StructuredArguments.setInt(0);
-  Builder.ReleaseArgs();
+  } else {
+    TemplateArgument *NewSArgs = new TemplateArgument[Builder.flatSize()];
+    std::copy(Builder.getFlatArguments(),
+              Builder.getFlatArguments()+Builder.flatSize(), NewSArgs);
+    StructuredArguments.setPointer(NewSArgs);
+  }
 }
 
 TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList &Other)
@@ -388,7 +393,10 @@ TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList &Other)
     NumStructuredArguments(Other.NumStructuredArguments) { }
 
 TemplateArgumentList::~TemplateArgumentList() {
-  // FIXME: Deallocate template arguments
+  if (FlatArguments.getInt())
+    delete [] FlatArguments.getPointer();
+  if (StructuredArguments.getInt())
+    delete [] StructuredArguments.getPointer();
 }
 
 //===----------------------------------------------------------------------===//