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

tools/clang/blink_gc_plugin/BlinkGCPlugin.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.
 
 // This clang plugin checks various invariants of the Blink garbage
 // collection infrastructure.
 //
 // Errors are described at:
 // http://www.chromium.org/developers/blink-gc-plugin-errors
 
@@ skipping 38 matching lines @@
 
 const char kRawPtrToGCManagedClassNote[] =
     "[blink-gc] Raw pointer field %0 to a GC managed class declared here:";
 
 const char kRefPtrToGCManagedClassNote[] =
     "[blink-gc] RefPtr field %0 to a GC managed class declared here:";
 
 const char kOwnPtrToGCManagedClassNote[] =
     "[blink-gc] OwnPtr field %0 to a GC managed class declared here:";
 
+const char kStackAllocatedFieldNote[] =
+    "[blink-gc] Stack-allocated field %0 declared here:";
+
 const char kPartObjectContainsGCRoot[] =
     "[blink-gc] Field %0 with embedded GC root in %1 declared here:";
 
 const char kFieldContainsGCRoot[] =
     "[blink-gc] Field %0 defining a GC root declared here:";
 
 const char kOverriddenNonVirtualTrace[] =
     "[blink-gc] Class %0 overrides non-virtual trace of base class %1.";
 
 const char kOverriddenNonVirtualTraceNote[] =
@@ skipping 21 matching lines @@
 
 const char kUserDeclaredDestructorNote[] =
     "[blink-gc] User-declared destructor declared here:";
 
 const char kBaseRequiresFinalizationNote[] =
     "[blink-gc] Base class %0 requiring finalization declared here:";
 
 const char kFieldRequiresFinalizationNote[] =
     "[blink-gc] Field %0 requiring finalization declared here:";
 
+const char kDerivesNonStackAllocated[] =
+    "[blink-gc] Stack-allocated class %0 derives class %1"
+    " which is not stack allocated.";
+
+const char kDerivesStackAllocated[] =
+    "[blink-gc] Class %0 derives stack-allocated class %1"
+    " but is not itself stack allocated";
+
 struct BlinkGCPluginOptions {
   BlinkGCPluginOptions() : enable_oilpan(false) {}
   bool enable_oilpan;
   std::set<std::string> ignored_classes;
   std::set<std::string> checked_namespaces;
   std::vector<std::string> ignored_directories;
 };
 
 typedef std::vector<CXXRecordDecl*> RecordVector;
 typedef std::vector<CXXMethodDecl*> MethodVector;
@@ skipping 302 matching lines @@
 };
 
 // This visitor checks that the fields of a class are "well formed".
 // - OwnPtr, RefPtr and RawPtr must not point to a GC derived types.
 // - An on-heap class must never contain GC roots.
 class CheckFieldsVisitor : public RecursiveEdgeVisitor {
  public:
   typedef std::vector<std::pair<FieldPoint*, Edge*> > Errors;
 
   CheckFieldsVisitor(const BlinkGCPluginOptions& options)
-      : options_(options), current_(0) {}
+      : options_(options), current_(0), stack_allocated_host_(false) {}
 
   Errors& invalid_fields() { return invalid_fields_; }
 
   bool ContainsInvalidFields(RecordInfo* info) {
+    stack_allocated_host_ = info->IsStackAllocated();
     for (RecordInfo::Fields::iterator it = info->GetFields().begin();
          it != info->GetFields().end();
          ++it) {
       context().clear();
       current_ = &it->second;
       current_->edge()->Accept(this);
     }
     return !invalid_fields_.empty();
   }
 
   void VisitValue(Value* edge) {
     // TODO: what should we do to check unions?
     if (edge->value()->record()->isUnion())
       return;
 
+    if (!stack_allocated_host_ && edge->value()->IsStackAllocated())
+      invalid_fields_.push_back(std::make_pair(current_, edge));
+
     if (!Parent() || !edge->value()->IsGCAllocated())
       return;
 
     if (Parent()->IsOwnPtr())
       invalid_fields_.push_back(std::make_pair(current_, Parent()));
 
     // Don't check raw and ref pointers in transition mode.
     if (options_.enable_oilpan)
       return;
 
-    if (Parent()->IsRawPtr() || Parent()->IsRefPtr())
+    if ((!stack_allocated_host_ && Parent()->IsRawPtr()) ||
+        Parent()->IsRefPtr())
       invalid_fields_.push_back(std::make_pair(current_, Parent()));
   }
 
  private:
   const BlinkGCPluginOptions& options_;
   FieldPoint* current_;
+  bool stack_allocated_host_;
   Errors invalid_fields_;
 };
 
 // Main class containing checks for various invariants of the Blink
 // garbage collection infrastructure.
 class BlinkGCPluginConsumer : public ASTConsumer {
  public:
   BlinkGCPluginConsumer(CompilerInstance& instance,
                         const BlinkGCPluginOptions& options)
       : instance_(instance),
@@ skipping 27 matching lines @@
     diag_overridden_non_virtual_trace_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kOverriddenNonVirtualTrace);
     diag_virtual_and_manual_dispatch_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kVirtualAndManualDispatch);
     diag_missing_trace_dispatch_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingTraceDispatch);
     diag_missing_finalize_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingFinalize);
     diag_missing_finalize_dispatch_ = diagnostic_.getCustomDiagID(
         getErrorLevel(), kMissingFinalizeDispatch);
+    diag_derives_non_stack_allocated_ = diagnostic_.getCustomDiagID(
+        getErrorLevel(), kDerivesNonStackAllocated);
+    diag_derives_stack_allocated_ = diagnostic_.getCustomDiagID(
+        getErrorLevel(), kDerivesStackAllocated);
 
     // Register note messages.
     diag_field_requires_tracing_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFieldRequiresTracingNote);
     diag_raw_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kRawPtrToGCManagedClassNote);
     diag_ref_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kRefPtrToGCManagedClassNote);
     diag_own_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kOwnPtrToGCManagedClassNote);
+    diag_stack_allocated_field_note_ = diagnostic_.getCustomDiagID(
+        DiagnosticsEngine::Note, kStackAllocatedFieldNote);
     diag_part_object_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kPartObjectContainsGCRoot);
     diag_field_contains_gc_root_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFieldContainsGCRoot);
     diag_finalized_field_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kFinalizedFieldNote);
     diag_user_declared_destructor_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kUserDeclaredDestructorNote);
     diag_base_requires_finalization_note_ = diagnostic_.getCustomDiagID(
         DiagnosticsEngine::Note, kBaseRequiresFinalizationNote);
@@ skipping 41 matching lines @@
         CheckClass(cache_.Lookup(*it));
       }
       return;
     }
 
     CheckClass(info);
   }
 
   // Check a class-like object (eg, class, specialization, instantiation).
   void CheckClass(RecordInfo* info) {
-    // Don't enforce tracing of stack allocated objects.
-    if (!info || info->IsStackAllocated())
+    if (!info)
       return;
 
+    // Check consistency of stack-allocated hierarchies.
+    bool stack_allocated = info->IsStackAllocated();
+    for (RecordInfo::Bases::iterator it = info->GetBases().begin();
+         it != info->GetBases().end();
+         ++it) {
+      bool stack_allocated_base = it->second.info()->IsStackAllocated();
+      if (stack_allocated && !stack_allocated_base)
+        ReportDerivesNonStackAllocated(info, &it->second);
+
+      if (!stack_allocated && stack_allocated_base)
+        ReportDerivesStackAllocated(info, &it->second);
+    }
+
     if (info->RequiresTraceMethod() && !info->GetTraceMethod())
       ReportClassRequiresTraceMethod(info);
 
     if (CXXMethodDecl* dispatch = info->GetTraceDispatchMethod())
       CheckDispatch(info, dispatch);
 
     {
       CheckFieldsVisitor visitor(options_);
       if (visitor.ContainsInvalidFields(info))
         ReportClassContainsInvalidFields(info, &visitor.invalid_fields());
@@ skipping 282 matching lines @@
         << info->record();
     for (CheckFieldsVisitor::Errors::iterator it = errors->begin();
          it != errors->end();
          ++it) {
       if (it->second->IsRawPtr()) {
         NoteField(it->first, diag_raw_ptr_to_gc_managed_class_note_);
       } else if (it->second->IsRefPtr()) {
         NoteField(it->first, diag_ref_ptr_to_gc_managed_class_note_);
       } else if (it->second->IsOwnPtr()) {
         NoteField(it->first, diag_own_ptr_to_gc_managed_class_note_);
+      } else if (it->second->IsValue()) {
+        NoteField(it->first, diag_stack_allocated_field_note_);
       }
     }
   }
 
   void ReportClassContainsGCRoots(RecordInfo* info,
                                   CheckGCRootsVisitor::Errors* errors) {
     SourceLocation loc = info->record()->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     for (CheckGCRootsVisitor::Errors::iterator it = errors->begin();
@@ skipping 73 matching lines @@
 
   void ReportMissingDispatch(const FunctionDecl* dispatch,
                                RecordInfo* receiver,
                                unsigned error) {
     SourceLocation loc = dispatch->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, error) << receiver->record();
   }
 
+  void ReportDerivesNonStackAllocated(RecordInfo* info, BasePoint* base) {
+    SourceLocation loc = base->spec().getLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_derives_non_stack_allocated_)
+        << info->record() << base->info()->record();
+  }
+
+  void ReportDerivesStackAllocated(RecordInfo* info, BasePoint* base) {
+    SourceLocation loc = base->spec().getLocStart();
+    SourceManager& manager = instance_.getSourceManager();
+    FullSourceLoc full_loc(loc, manager);
+    diagnostic_.Report(full_loc, diag_derives_stack_allocated_)
+        << info->record() << base->info()->record();
+  }
+
   void NoteFieldRequiresTracing(RecordInfo* holder, FieldDecl* field) {
     NoteField(field, diag_field_requires_tracing_note_);
   }
 
   void NotePartObjectContainsGCRoot(FieldPoint* point) {
     FieldDecl* field = point->field();
     SourceLocation loc = field->getLocStart();
     SourceManager& manager = instance_.getSourceManager();
     FullSourceLoc full_loc(loc, manager);
     diagnostic_.Report(full_loc, diag_part_object_contains_gc_root_note_)
@@ skipping 43 matching lines @@
   unsigned diag_fields_require_tracing_;
   unsigned diag_class_contains_invalid_fields_;
   unsigned diag_class_contains_gc_root_;
   unsigned diag_class_requires_finalization_;
   unsigned diag_finalizer_accesses_finalized_field_;
   unsigned diag_overridden_non_virtual_trace_;
   unsigned diag_virtual_and_manual_dispatch_;
   unsigned diag_missing_trace_dispatch_;
   unsigned diag_missing_finalize_;
   unsigned diag_missing_finalize_dispatch_;
+  unsigned diag_derives_non_stack_allocated_;
+  unsigned diag_derives_stack_allocated_;
 
   unsigned diag_field_requires_tracing_note_;
   unsigned diag_raw_ptr_to_gc_managed_class_note_;
   unsigned diag_ref_ptr_to_gc_managed_class_note_;
   unsigned diag_own_ptr_to_gc_managed_class_note_;
+  unsigned diag_stack_allocated_field_note_;
   unsigned diag_part_object_contains_gc_root_note_;
   unsigned diag_field_contains_gc_root_note_;
   unsigned diag_finalized_field_note_;
   unsigned diag_user_declared_destructor_note_;
   unsigned diag_base_requires_finalization_note_;
   unsigned diag_field_requires_finalization_note_;
   unsigned diag_overridden_non_virtual_trace_note_;
 
   CompilerInstance& instance_;
   DiagnosticsEngine& diagnostic_;
@@ skipping 30 matching lines @@
 
  private:
   BlinkGCPluginOptions options_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<BlinkGCPluginAction> X(
     "blink-gc-plugin",
     "Check Blink GC invariants");