Line data    Source code

       1             : // Copyright 2018 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_MAYBE_HANDLES_INL_H_
       6             : #define V8_MAYBE_HANDLES_INL_H_
       7             : 
       8             : #include "src/maybe-handles.h"
       9             : 
      10             : #include "src/handles-inl.h"
      11             : #include "src/objects/maybe-object-inl.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : template <typename T>
      16             : MaybeHandle<T>::MaybeHandle(T object, Isolate* isolate)
      17             :     : MaybeHandle(handle(object, isolate)) {}
      18             : 
      19             : MaybeObjectHandle::MaybeObjectHandle()
      20             :     : reference_type_(HeapObjectReferenceType::STRONG),
      21    13686323 :       handle_(Handle<Object>::null()) {}
      22             : 
      23      505012 : MaybeObjectHandle::MaybeObjectHandle(MaybeObject object, Isolate* isolate) {
      24             :   HeapObject heap_object;
      25             :   DCHECK(!object->IsCleared());
      26      505012 :   if (object->GetHeapObjectIfWeak(&heap_object)) {
      27      127493 :     handle_ = handle(heap_object, isolate);
      28      127493 :     reference_type_ = HeapObjectReferenceType::WEAK;
      29             :   } else {
      30      377521 :     handle_ = handle(object->cast<Object>(), isolate);
      31      377521 :     reference_type_ = HeapObjectReferenceType::STRONG;
      32             :   }
      33      505014 : }
      34             : 
      35             : MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object)
      36     3173839 :     : reference_type_(HeapObjectReferenceType::STRONG), handle_(object) {}
      37             : 
      38       46598 : MaybeObjectHandle::MaybeObjectHandle(Object object, Isolate* isolate)
      39             :     : reference_type_(HeapObjectReferenceType::STRONG),
      40       93196 :       handle_(object, isolate) {}
      41             : 
      42     5817512 : MaybeObjectHandle::MaybeObjectHandle(Object object,
      43             :                                      HeapObjectReferenceType reference_type,
      44             :                                      Isolate* isolate)
      45    11635022 :     : reference_type_(reference_type), handle_(handle(object, isolate)) {}
      46             : 
      47             : MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object,
      48             :                                      HeapObjectReferenceType reference_type)
      49             :     : reference_type_(reference_type), handle_(object) {}
      50             : 
      51             : MaybeObjectHandle MaybeObjectHandle::Weak(Handle<Object> object) {
      52             :   return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK);
      53             : }
      54             : 
      55             : MaybeObjectHandle MaybeObjectHandle::Weak(Object object, Isolate* isolate) {
      56     5817513 :   return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK, isolate);
      57             : }
      58             : 
      59   102174396 : MaybeObject MaybeObjectHandle::operator*() const {
      60   102174396 :   if (reference_type_ == HeapObjectReferenceType::WEAK) {
      61    84243242 :     return HeapObjectReference::Weak(*handle_.ToHandleChecked());
      62             :   } else {
      63             :     return MaybeObject::FromObject(*handle_.ToHandleChecked());
      64             :   }
      65             : }
      66             : 
      67             : MaybeObject MaybeObjectHandle::operator->() const {
      68             :   if (reference_type_ == HeapObjectReferenceType::WEAK) {
      69             :     return HeapObjectReference::Weak(*handle_.ToHandleChecked());
      70             :   } else {
      71             :     return MaybeObject::FromObject(*handle_.ToHandleChecked());
      72             :   }
      73             : }
      74             : 
      75             : Handle<Object> MaybeObjectHandle::object() const {
      76             :   return handle_.ToHandleChecked();
      77             : }
      78             : 
      79             : inline MaybeObjectHandle handle(MaybeObject object, Isolate* isolate) {
      80      503977 :   return MaybeObjectHandle(object, isolate);
      81             : }
      82             : 
      83             : }  // namespace internal
      84             : }  // namespace v8
      85             : 
      86             : #endif  // V8_MAYBE_HANDLES_INL_H_