Fix UBSan test error from r248897 about left shift of unsigned value.

[oota-llvm.git] / include / llvm / Support / StringPool.h

diff --git a/include/llvm/Support/StringPool.h b/include/llvm/Support/StringPool.h
index 07b2a8ddde2afd262a117fed63c599eb2a4b3e69..2ec0c3b76c11f13557ee5f810baa46a3bf7d512d 100644 (file)
--- a/include/llvm/Support/StringPool.h
+++ b/include/llvm/Support/StringPool.h
@@ -1,36 +1,35 @@
-//===-- StringPool.h - Interned string pool -------------------------------===//
+//===-- StringPool.h - Interned string pool ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Gordon Henriksen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares an interned string pool, which helps reduce the cost of
 // strings by using the same storage for identical strings.
-// 
+//
 // To intern a string:
-// 
+//
 //   StringPool Pool;
 //   PooledStringPtr Str = Pool.intern("wakka wakka");
-// 
+//
 // To use the value of an interned string, use operator bool and operator*:
-// 
+//
 //   if (Str)
 //     cerr << "the string is" << *Str << "\n";
-// 
+//
 // Pooled strings are immutable, but you can change a PooledStringPtr to point
 // to another instance. So that interned strings can eventually be freed,
 // strings in the string pool are reference-counted (automatically).
-// 
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_STRINGPOOL_H
 #define LLVM_SUPPORT_STRINGPOOL_H
 
-#include <llvm/ADT/StringMap.h>
-#include <new>
+#include "llvm/ADT/StringMap.h"
 #include <cassert>
 
 namespace llvm {
@@ -41,28 +40,36 @@ namespace llvm {
   /// string. Strings are removed automatically as PooledStringPtrs are
   /// destroyed.
   class StringPool {
+    /// PooledString - This is the value of an entry in the pool's interning
+    /// table.
     struct PooledString {
       StringPool *Pool;  ///< So the string can remove itself.
       unsigned Refcount; ///< Number of referencing PooledStringPtrs.
-      
+
     public:
-      PooledString() : Pool(0), Refcount(0) { }
+      PooledString() : Pool(nullptr), Refcount(0) { }
     };
-    
+
     friend class PooledStringPtr;
-    
+
     typedef StringMap<PooledString> table_t;
     typedef StringMapEntry<PooledString> entry_t;
     table_t InternTable;
-    
+
   public:
     StringPool();
     ~StringPool();
-    
-    PooledStringPtr intern(const char *Begin, const char *End);
-    inline PooledStringPtr intern(const char *Str);
+
+    /// intern - Adds a string to the pool and returns a reference-counted
+    /// pointer to it. No additional memory is allocated if the string already
+    /// exists in the pool.
+    PooledStringPtr intern(StringRef Str);
+
+    /// empty - Checks whether the pool is empty. Returns true if so.
+    ///
+    inline bool empty() const { return InternTable.empty(); }
   };
-  
+
   /// PooledStringPtr - A pointer to an interned string. Use operator bool to
   /// test whether the pointer is valid, and operator * to get the string if so.
   /// This is a lightweight value class with storage requirements equivalent to
@@ -71,18 +78,18 @@ namespace llvm {
   class PooledStringPtr {
     typedef StringPool::entry_t entry_t;
     entry_t *S;
-    
+
   public:
-    PooledStringPtr() : S(0) {}
-    
+    PooledStringPtr() : S(nullptr) {}
+
     explicit PooledStringPtr(entry_t *E) : S(E) {
       if (S) ++S->getValue().Refcount;
     }
-    
+
     PooledStringPtr(const PooledStringPtr &That) : S(That.S) {
       if (S) ++S->getValue().Refcount;
     }
-    
+
     PooledStringPtr &operator=(const PooledStringPtr &That) {
       if (S != That.S) {
         clear();
@@ -91,44 +98,40 @@ namespace llvm {
       }
       return *this;
     }
-    
+
     void clear() {
       if (!S)
         return;
       if (--S->getValue().Refcount == 0) {
         S->getValue().Pool->InternTable.remove(S);
-        delete S;
+        S->Destroy();
       }
-      S = 0;
+      S = nullptr;
     }
-    
+
     ~PooledStringPtr() { clear(); }
-    
+
     inline const char *begin() const {
       assert(*this && "Attempt to dereference empty PooledStringPtr!");
       return S->getKeyData();
     }
-    
+
     inline const char *end() const {
       assert(*this && "Attempt to dereference empty PooledStringPtr!");
       return S->getKeyData() + S->getKeyLength();
     }
-    
+
     inline unsigned size() const {
       assert(*this && "Attempt to dereference empty PooledStringPtr!");
       return S->getKeyLength();
     }
-    
+
     inline const char *operator*() const { return begin(); }
-    inline operator bool() const { return S != 0; }
-    
-    inline bool operator==(const PooledStringPtr &That) { return S == That.S; }
-    inline bool operator!=(const PooledStringPtr &That) { return S != That.S; }
+    inline explicit operator bool() const { return S != nullptr; }
+
+    inline bool operator==(const PooledStringPtr &That) const { return S == That.S; }
+    inline bool operator!=(const PooledStringPtr &That) const { return S != That.S; }
   };
-  
-  PooledStringPtr StringPool::intern(const char *Str) {
-    return intern(Str, Str + strlen(Str));
-  }
 
 } // End llvm namespace