Change CXTranslationUnit to not directly cast to an ASTUnit*,

but to wrap both an ASTUnit and a "string pool"
that will be used for fast USR generation.

This requires a bunch of mechanical changes, as
there was a ton of code that assumed that CXTranslationUnit
and ASTUnit* were the same.

Along with this change, introduce CXStringBuf,
which provides an llvm::SmallVector<char> backing
for repeatedly generating CXStrings without a huge
amount of malloc() traffic.  This requires making
some changes to the representation of CXString
by renaming a few fields (but keeping the size
of the object the same).

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

1 files changed, 70 insertions, 8 deletions

diff --git a/tools/libclang/CXString.cpp b/tools/libclang/CXString.cpp
index 341b72032d..a2860a1095 100644
--- a/tools/libclang/CXString.cpp
+++ b/tools/libclang/CXString.cpp
@@ -16,20 +16,25 @@
 #include "CXString.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang-c/Index.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace clang;
 using namespace clang::cxstring;
 
-enum CXStringFlag { CXS_Unmanaged, CXS_Malloc };
+enum CXStringFlag { CXS_Unmanaged, CXS_Malloc, CXS_StringBuf };
+
+//===----------------------------------------------------------------------===//
+// Basic generation of CXStrings.
+//===----------------------------------------------------------------------===//
 
 CXString cxstring::createCXString(const char *String, bool DupString){
   CXString Str;
   if (DupString) {
-    Str.Spelling = strdup(String);
+    Str.data = strdup(String);
     Str.private_flags = (unsigned) CXS_Malloc;
   } else {
-    Str.Spelling = String;
+    Str.data = (void*)String;
     Str.private_flags = (unsigned) CXS_Unmanaged;
   }
   return Str;
@@ -41,27 +46,84 @@ CXString cxstring::createCXString(llvm::StringRef String, bool DupString) {
     char *Spelling = (char *)malloc(String.size() + 1);
     memmove(Spelling, String.data(), String.size());
     Spelling[String.size()] = 0;
-    Result.Spelling = Spelling;
+    Result.data = Spelling;
     Result.private_flags = (unsigned) CXS_Malloc;
   } else {
-    Result.Spelling = String.data();
+    Result.data = (void*) String.data();
     Result.private_flags = (unsigned) CXS_Unmanaged;
   }
   return Result;
 }
 
+CXString cxstring::createCXString(CXStringBuf *buf) {
+  CXString Str;
+  Str.data = buf;
+  Str.private_flags = (unsigned) CXS_StringBuf;
+  return Str;
+}
+
+
+//===----------------------------------------------------------------------===//
+// String pools.
+//===----------------------------------------------------------------------===//
+
+  
+typedef std::vector<CXStringBuf *> CXStringPool;
+
+void *cxstring::createCXStringPool() {
+  return new CXStringPool();
+}
+
+void cxstring::disposeCXStringPool(void *p) {
+  CXStringPool *pool = static_cast<CXStringPool*>(p);
+  if (pool) {
+    for (CXStringPool::iterator I = pool->begin(), E = pool->end();
+         I != E; ++I) {
+      delete *I;
+    }
+    delete pool;
+  }
+}
+
+CXStringBuf *cxstring::getCXStringBuf(CXTranslationUnit TU) {
+  CXStringPool *pool = static_cast<CXStringPool*>(TU->StringPool);
+  if (pool->empty())
+    return new CXStringBuf(TU);
+  CXStringBuf *buf = pool->back();
+  buf->Data.clear();
+  pool->pop_back();
+  return buf;
+}
+
+void cxstring::disposeCXStringBuf(CXStringBuf *buf) {
+  if (buf)
+    static_cast<CXStringPool*>(buf->TU->StringPool)->push_back(buf);
+}
+
 //===----------------------------------------------------------------------===//
 // libClang public APIs.
 //===----------------------------------------------------------------------===//
 
 extern "C" {
 const char *clang_getCString(CXString string) {
-  return string.Spelling;
+  if (string.private_flags == (unsigned) CXS_StringBuf) {
+    return ((CXStringBuf*)string.data)->Data.data();
+  }
+  return (const char*) string.data;
 }
 
 void clang_disposeString(CXString string) {
-  if (string.private_flags == CXS_Malloc && string.Spelling)
-    free((void*)string.Spelling);
+  switch ((CXStringFlag) string.private_flags) {
+    case CXS_Unmanaged:
+      break;
+    case CXS_Malloc:
+      if (string.data)
+        free((void*)string.data);
+      break;
+    case CXS_StringBuf:
+      disposeCXStringBuf((CXStringBuf *) string.data);
+      break;
+  }
 }
 } // end: extern "C"