Bisect clang

tools/clang/blink_gc_plugin/CheckFieldsVisitor.cpp

+// Copyright 2015 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 "CheckFieldsVisitor.h"
+
+#include <cassert>
+
+#include "BlinkGCPluginOptions.h"
+#include "RecordInfo.h"
+
+CheckFieldsVisitor::CheckFieldsVisitor(const BlinkGCPluginOptions& options)
+    : options_(options),
+      current_(0),
+      stack_allocated_host_(false) {
+}
+
+CheckFieldsVisitor::Errors& CheckFieldsVisitor::invalid_fields() {
+  return invalid_fields_;
+}
+
+bool CheckFieldsVisitor::ContainsInvalidFields(RecordInfo* info) {
+  stack_allocated_host_ = info->IsStackAllocated();
+  managed_host_ = stack_allocated_host_ ||
+                  info->IsGCAllocated() ||
+                  info->IsNonNewable() ||
+                  info->IsOnlyPlacementNewable();
+  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 CheckFieldsVisitor::AtMember(Member* edge) {
+  if (managed_host_)
+    return;
+  // A member is allowed to appear in the context of a root.
+  for (Context::iterator it = context().begin();
+       it != context().end();
+       ++it) {
+    if ((*it)->Kind() == Edge::kRoot)
+      return;
+  }
+  invalid_fields_.push_back(std::make_pair(current_, kMemberInUnmanaged));
+}
+
+void CheckFieldsVisitor::AtValue(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_, kPtrFromHeapToStack));
+    return;
+  }
+
+  if (!Parent() &&
+      edge->value()->IsGCDerived() &&
+      !edge->value()->IsGCMixin()) {
+    invalid_fields_.push_back(std::make_pair(current_, kGCDerivedPartObject));
+    return;
+  }
+
+  // If in a stack allocated context, be fairly insistent that T in Member<T>
+  // is GC allocated, as stack allocated objects do not have a trace()
+  // that separately verifies the validity of Member<T>.
+  //
+  // Notice that an error is only reported if T's definition is in scope;
+  // we do not require that it must be brought into scope as that would
+  // prevent declarations of mutually dependent class types.
+  //
+  // (Note: Member<>'s constructor will at run-time verify that the
+  // pointer it wraps is indeed heap allocated.)
+  if (stack_allocated_host_ && Parent() && Parent()->IsMember() &&
+      edge->value()->HasDefinition() && !edge->value()->IsGCAllocated()) {
+    invalid_fields_.push_back(std::make_pair(current_,
+                                             kMemberToGCUnmanaged));
+    return;
+  }
+
+  if (!Parent() || !edge->value()->IsGCAllocated())
+    return;
+
+  // In transition mode, disallow  OwnPtr<T>, RawPtr<T> to GC allocated T's,
+  // also disallow T* in stack-allocated types.
+  if (options_.enable_oilpan) {
+    if (Parent()->IsOwnPtr() ||
+        Parent()->IsRawPtrClass() ||
+        (stack_allocated_host_ && Parent()->IsRawPtr())) {
+      invalid_fields_.push_back(std::make_pair(
+          current_, InvalidSmartPtr(Parent())));
+      return;
+    }
+    if (options_.warn_raw_ptr && Parent()->IsRawPtr()) {
+      if (static_cast<RawPtr*>(Parent())->HasReferenceType()) {
+        invalid_fields_.push_back(std::make_pair(
+            current_, kReferencePtrToGCManagedWarning));
+      } else {
+        invalid_fields_.push_back(std::make_pair(
+            current_, kRawPtrToGCManagedWarning));
+      }
+    }
+    return;
+  }
+
+  if (Parent()->IsRawPtr() || Parent()->IsRefPtr() || Parent()->IsOwnPtr()) {
+    invalid_fields_.push_back(std::make_pair(
+        current_, InvalidSmartPtr(Parent())));
+    return;
+  }
+}
+
+void CheckFieldsVisitor::AtCollection(Collection* edge) {
+  if (edge->on_heap() && Parent() && Parent()->IsOwnPtr())
+    invalid_fields_.push_back(std::make_pair(current_, kOwnPtrToGCManaged));
+}
+
+bool CheckFieldsVisitor::IsWarning(Error error) {
+  if (error == kRawPtrToGCManagedWarning)
+    return true;
+  if (error == kReferencePtrToGCManagedWarning)
+    return true;
+  return false;
+}
+
+bool CheckFieldsVisitor::IsRawPtrError(Error error) {
+  return (error == kRawPtrToGCManaged ||
+          error == kRawPtrToGCManagedWarning);
+}
+
+bool CheckFieldsVisitor::IsReferencePtrError(Error error) {
+  return (error == kReferencePtrToGCManaged ||
+          error == kReferencePtrToGCManagedWarning);
+}
+
+CheckFieldsVisitor::Error CheckFieldsVisitor::InvalidSmartPtr(Edge* ptr) {
+  if (ptr->IsRawPtr()) {
+    if (static_cast<RawPtr*>(ptr)->HasReferenceType())
+      return kReferencePtrToGCManaged;
+    else
+      return kRawPtrToGCManaged;
+  }
+  if (ptr->IsRefPtr())
+    return kRefPtrToGCManaged;
+  if (ptr->IsOwnPtr())
+    return kOwnPtrToGCManaged;
+  assert(false && "Unknown smart pointer kind");
+}