Add checks for stack-allocated types and their uses in fields.

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),
+      is_stack_allocated_(kMaybe),

[Mads Ager (chromium), 2014/03/20 10:32:29]

Wasn't it called kNone in the enum? This is really a cache and maybe we should
name it accordingly?

enum CachedBool {
  kFalse = 0,
  kTrue = 1,
  kNotComputed = 2
};

[zerny-chromium, 2014/03/20 15:14:20]

Done.

       determined_trace_methods_(false),
       trace_method_(0),
       trace_dispatch_method_(0),
       is_gc_derived_(false),
       base_paths_(0) {}
 
 RecordInfo::~RecordInfo() {
   delete fields_;
   delete bases_;
   delete base_paths_;
@@ skipping 114 matching lines @@
   if (!record || IsAnnotated(record, "blink_gc_plugin_ignore"))
     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() {
-  for (CXXRecordDecl::method_iterator it = record_->method_begin();
-       it != record_->method_end();
-       ++it) {
-    if (it->getNameAsString() == kNewOperatorName)
-      return it->isDeleted() && IsAnnotated(*it, "blink_stack_allocated");
+  if (is_stack_allocated_ == kNone) {
+    is_stack_allocated_ = kFalse;
+    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;
+        }
+      }
+    }
   }
-  return false;
+  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;
   GetFields();
   return fields_need_tracing_.IsNeeded();
 }
 
 // Get the actual tracing method (ie, can be traceAfterDispatch if there is a
 // dispatch method).
 CXXMethodDecl* RecordInfo::GetTraceMethod() {
   DetermineTracingMethods();
   return trace_method_;
 }
@@ skipping 243 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);
 }