Global cycle detection analysis.

tools/clang/blink_gc_plugin/RecordInfo.cpp

 // 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.
 
 #include "Config.h"
 #include "RecordInfo.h"
 
-#include "clang/AST/Attr.h"
-
 using namespace clang;
 using std::string;
 
 RecordInfo::RecordInfo(CXXRecordDecl* record, RecordCache* cache)
     : cache_(cache),
       record_(record),
       name_(record->getName()),
       fields_need_tracing_(TracingStatus::Unknown()),
       bases_(0),
       fields_(0),
@@ skipping 109 matching lines @@
     return false;
   // This is a mixin if there are no other paths to GC bases.
   return ++it == base_paths_->end();
 }
 
 // Test if a record is allocated on the managed heap.
 bool RecordInfo::IsGCAllocated() {
   return IsGCDerived() || IsHeapAllocatedCollection();
 }
 
-static bool IsAnnotated(Decl* decl, const string& anno) {
-  AnnotateAttr* attr = decl->getAttr<AnnotateAttr>();
-  return attr && (attr->getAnnotation() == anno);
-}
-
 RecordInfo* RecordCache::Lookup(CXXRecordDecl* record) {
   // Ignore classes annotated with the GC_PLUGIN_IGNORE macro.
-  if (!record || IsAnnotated(record, "blink_gc_plugin_ignore"))
+  if (!record || Config::IsIgnoreAnnotated(record))
     return 0;
   Cache::iterator it = cache_.find(record);
   if (it != cache_.end())
     return &it->second;
   return &cache_.insert(std::make_pair(record, RecordInfo(record, this)))
       .first->second;
 }
 
 bool RecordInfo::IsStackAllocated() {
   if (is_stack_allocated_ == kNotComputed) {
     is_stack_allocated_ = kFalse;
     for (Bases::iterator it = GetBases().begin();
          it != GetBases().end();
          ++it) {
       if (it->second.info()->IsStackAllocated()) {
         is_stack_allocated_ = kTrue;
-        break;
+        return is_stack_allocated_;
       }
     }
     for (CXXRecordDecl::method_iterator it = record_->method_begin();
          it != record_->method_end();
          ++it) {
-      if (it->getNameAsString() == kNewOperatorName) {
-        if (it->isDeleted() && IsAnnotated(*it, "blink_stack_allocated")) {
-          is_stack_allocated_ = kTrue;
-          break;
-        }
+      if (it->getNameAsString() == kNewOperatorName &&
+          it->isDeleted() &&
+          Config::IsStackAnnotated(*it)) {
+        is_stack_allocated_ = kTrue;
+        return is_stack_allocated_;
       }
     }
   }
   return is_stack_allocated_;
 }
 
 // An object requires a tracing method if it has any fields that need tracing.
 bool RecordInfo::RequiresTraceMethod() {
   if (IsStackAllocated())
     return false;
@@ skipping 94 matching lines @@
   // Compute the collection locally to avoid inconsistent states.
   Fields* fields = new Fields;
   if (!record_->hasDefinition())
     return fields;
   TracingStatus fields_status = TracingStatus::Unneeded();
   for (RecordDecl::field_iterator it = record_->field_begin();
        it != record_->field_end();
        ++it) {
     FieldDecl* field = *it;
     // Ignore fields annotated with the GC_PLUGIN_IGNORE macro.
-    if (IsAnnotated(field, "blink_gc_plugin_ignore"))
+    if (Config::IsIgnoreAnnotated(field))
       continue;
     if (Edge* edge = CreateEdge(field->getType().getTypePtrOrNull())) {
       fields->insert(std::make_pair(field, FieldPoint(field, edge)));
       fields_status = fields_status.LUB(edge->NeedsTracing(Edge::kRecursive));
     }
   }
   fields_need_tracing_ = fields_status;
   return fields;
 }
 
@@ skipping 153 matching lines @@
         // We failed to create an edge so abort the entire edge construction.
         delete edge;  // Will delete the already allocated members.
         return 0;
       }
     }
     return edge;
   }
 
   return new Value(info);
 }