Disallow heap objects containing unsafe on-heap iterators.

tools/clang/blink_gc_plugin/Config.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file defines the names used by GC infrastructure.
 
 // TODO: Restructure the name determination to use fully qualified names (ala,
 // blink::Foo) so that the plugin can be enabled for all of chromium. Doing so
 // would allow us to catch errors with structures outside of blink that might
 // have unsafe pointers to GC allocated blink structures.
@@ skipping 14 matching lines @@
 const char kTraceAfterDispatchName[] = "traceAfterDispatch";
 const char kTraceAfterDispatchImplName[] = "traceAfterDispatchImpl";
 const char kRegisterWeakMembersName[] = "registerWeakMembers";
 const char kHeapAllocatorName[] = "HeapAllocator";
 const char kTraceIfNeededName[] = "TraceIfNeeded";
 const char kVisitorDispatcherName[] = "VisitorDispatcher";
 const char kVisitorVarName[] = "visitor";
 const char kAdjustAndMarkName[] = "adjustAndMark";
 const char kIsHeapObjectAliveName[] = "isHeapObjectAlive";
 const char kIsEagerlyFinalizedName[] = "IsEagerlyFinalizedMarker";
+const char kConstIteratorName[] = "const_iterator";
+const char kIteratorName[] = "iterator";
+const char kConstReverseIteratorName[] = "const_reverse_iterator";
+const char kReverseIteratorName[] = "reverse_iterator";
 
 class Config {
  public:
   static bool IsMember(const std::string& name) {
     return name == "Member";
   }
 
   static bool IsWeakMember(const std::string& name) {
     return name == "WeakMember";
   }
@@ skipping 49 matching lines @@
   static bool IsPersistentGCCollection(const std::string& name) {
     return name == "PersistentHeapVector" ||
            name == "PersistentHeapDeque" ||
            name == "PersistentHeapHashSet" ||
            name == "PersistentHeapListHashSet" ||
            name == "PersistentHeapLinkedHashSet" ||
            name == "PersistentHeapHashCountedSet" ||
            name == "PersistentHeapHashMap";
   }
 
+  static bool IsGCCollectionWithUnsafeIterator(const std::string& name) {
+    if (!IsGCCollection(name))
+      return false;
+    // The list hash set iterators refer to the set, not the
+    // backing store and are consequently safe.
+    if (name == "HeapListHashSet" || name == "PersistentHeapListHashSet")
+      return false;
+    return true;
+  }
+
   static bool IsHashMap(const std::string& name) {
     return name == "HashMap" ||
            name == "HeapHashMap" ||
            name == "PersistentHeapHashMap";
   }
 
   // Assumes name is a valid collection name.
   static size_t CollectionDimension(const std::string& name) {
     return (IsHashMap(name) || name == "pair") ? 2 : 1;
   }
@@ skipping 10 matching lines @@
   static bool IsGCFinalizedBase(const std::string& name) {
     return name == "GarbageCollectedFinalized";
   }
 
   static bool IsGCBase(const std::string& name) {
     return name == "GarbageCollected" ||
            IsGCFinalizedBase(name) ||
            IsGCMixinBase(name);
   }
 
+  static bool IsIterator(const std::string& name) {
+    return name == kIteratorName || name == kConstIteratorName ||
+           name == kReverseIteratorName || name == kConstReverseIteratorName;
+  }
+
   // Returns true of the base classes that do not need a vtable entry for trace
   // because they cannot possibly initiate a GC during construction.
   static bool IsSafePolymorphicBase(const std::string& name) {
     return IsGCBase(name) || IsRefCountedBase(name);
   }
 
   static bool IsAnnotated(clang::Decl* decl, const std::string& anno) {
     clang::AnnotateAttr* attr = decl->getAttr<clang::AnnotateAttr>();
     return attr && (attr->getAnnotation() == anno);
   }
@@ skipping 106 matching lines @@
     if (suffix.size() > str.size())
       return false;
     return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
   }
 
   // Test if a template specialization is an instantiation.
   static bool IsTemplateInstantiation(clang::CXXRecordDecl* record);
 };
 
 #endif  // TOOLS_BLINK_GC_PLUGIN_CONFIG_H_