1 files changed, 50 insertions, 52 deletions

diff --git a/deps/v8/src/objects/maybe-object.h b/deps/v8/src/objects/maybe-object.h
index 0d55ff859c..c40ae0a5aa 100644
--- a/deps/v8/src/objects/maybe-object.h
+++ b/deps/v8/src/objects/maybe-object.h
@@ -9,12 +9,14 @@
 #include "include/v8.h"
 #include "src/globals.h"
 #include "src/objects.h"
+#include "src/objects/slots.h"
+#include "src/objects/smi.h"
 
 namespace v8 {
 namespace internal {
 
 class HeapObject;
-class Smi;
+class Isolate;
 class StringStream;
 
 // A MaybeObject is either a SMI, a strong reference to a HeapObject, a weak
@@ -22,11 +24,24 @@ class StringStream;
 // implementing in-place weak references (see design doc: goo.gl/j6SdcK )
 class MaybeObject {
  public:
-  bool IsSmi() const { return HAS_SMI_TAG(this); }
-  inline bool ToSmi(Smi** value);
+  MaybeObject() : ptr_(kNullAddress) {}
+  explicit MaybeObject(Address ptr) : ptr_(ptr) {}
+
+  bool operator==(const MaybeObject& other) const { return ptr_ == other.ptr_; }
+  bool operator!=(const MaybeObject& other) const { return ptr_ != other.ptr_; }
+
+  Address ptr() const { return ptr_; }
+
+  // Enable incremental transition of client code.
+  MaybeObject* operator->() { return this; }
+  const MaybeObject* operator->() const { return this; }
+
+  bool IsSmi() const { return HAS_SMI_TAG(ptr_); }
+  inline bool ToSmi(Smi* value);
+  inline Smi ToSmi() const;
 
   bool IsCleared() const {
-    return ::v8::internal::IsClearedWeakHeapObject(this);
+    return static_cast<uint32_t>(ptr_) == kClearedWeakHeapObjectLower32;
   }
 
   inline bool IsStrongOrWeak() const;
@@ -34,58 +49,58 @@ class MaybeObject {
 
   // If this MaybeObject is a strong pointer to a HeapObject, returns true and
   // sets *result. Otherwise returns false.
-  inline bool GetHeapObjectIfStrong(HeapObject** result);
+  inline bool GetHeapObjectIfStrong(HeapObject* result) const;
 
   // DCHECKs that this MaybeObject is a strong pointer to a HeapObject and
   // returns the HeapObject.
-  inline HeapObject* GetHeapObjectAssumeStrong();
+  inline HeapObject GetHeapObjectAssumeStrong() const;
 
   inline bool IsWeak() const;
   inline bool IsWeakOrCleared() const;
 
   // If this MaybeObject is a weak pointer to a HeapObject, returns true and
   // sets *result. Otherwise returns false.
-  inline bool GetHeapObjectIfWeak(HeapObject** result);
+  inline bool GetHeapObjectIfWeak(HeapObject* result) const;
 
   // DCHECKs that this MaybeObject is a weak pointer to a HeapObject and
   // returns the HeapObject.
-  inline HeapObject* GetHeapObjectAssumeWeak();
+  inline HeapObject GetHeapObjectAssumeWeak() const;
 
   // If this MaybeObject is a strong or weak pointer to a HeapObject, returns
   // true and sets *result. Otherwise returns false.
-  inline bool GetHeapObject(HeapObject** result);
-  inline bool GetHeapObject(HeapObject** result,
-                            HeapObjectReferenceType* reference_type);
+  inline bool GetHeapObject(HeapObject* result) const;
+  inline bool GetHeapObject(HeapObject* result,
+                            HeapObjectReferenceType* reference_type) const;
 
   // DCHECKs that this MaybeObject is a strong or a weak pointer to a HeapObject
   // and returns the HeapObject.
-  inline HeapObject* GetHeapObject();
+  inline HeapObject GetHeapObject() const;
 
   // DCHECKs that this MaybeObject is a strong or a weak pointer to a HeapObject
   // or a SMI and returns the HeapObject or SMI.
-  inline Object* GetHeapObjectOrSmi();
+  inline Object GetHeapObjectOrSmi() const;
 
   inline bool IsObject() const;
   template <typename T>
-  T* cast() {
-    DCHECK(!HasWeakHeapObjectTag(this));
-    return T::cast(reinterpret_cast<Object*>(this));
+  T cast() const {
+    DCHECK(!HasWeakHeapObjectTag(ptr_));
+    return T::cast(Object(ptr_));
   }
 
-  static MaybeObject* FromSmi(Smi* smi) {
-    DCHECK(HAS_SMI_TAG(smi));
-    return reinterpret_cast<MaybeObject*>(smi);
+  static MaybeObject FromSmi(Smi smi) {
+    DCHECK(HAS_SMI_TAG(smi->ptr()));
+    return MaybeObject(smi->ptr());
   }
 
-  static MaybeObject* FromObject(Object* object) {
-    DCHECK(!HasWeakHeapObjectTag(object));
-    return reinterpret_cast<MaybeObject*>(object);
+  static MaybeObject FromObject(Object object) {
+    DCHECK(!HasWeakHeapObjectTag(object.ptr()));
+    return MaybeObject(object.ptr());
   }
 
-  static inline MaybeObject* MakeWeak(MaybeObject* object);
+  static inline MaybeObject MakeWeak(MaybeObject object);
 
 #ifdef VERIFY_HEAP
-  static void VerifyMaybeObjectPointer(Isolate* isolate, MaybeObject* p);
+  static void VerifyMaybeObjectPointer(Isolate* isolate, MaybeObject p);
 #endif
 
   // Prints this object without details.
@@ -105,49 +120,32 @@ class MaybeObject {
 #endif
 
  private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(MaybeObject);
+  Address ptr_;
 };
 
 // A HeapObjectReference is either a strong reference to a HeapObject, a weak
 // reference to a HeapObject, or a cleared weak reference.
 class HeapObjectReference : public MaybeObject {
  public:
-  static HeapObjectReference* Strong(Object* object) {
+  explicit HeapObjectReference(Address address) : MaybeObject(address) {}
+  explicit HeapObjectReference(Object object) : MaybeObject(object->ptr()) {}
+
+  static HeapObjectReference Strong(Object object) {
     DCHECK(!object->IsSmi());
     DCHECK(!HasWeakHeapObjectTag(object));
-    return reinterpret_cast<HeapObjectReference*>(object);
+    return HeapObjectReference(object);
   }
 
-  static HeapObjectReference* Weak(Object* object) {
+  static HeapObjectReference Weak(Object object) {
     DCHECK(!object->IsSmi());
     DCHECK(!HasWeakHeapObjectTag(object));
-    return AddWeakHeapObjectMask(object);
-  }
-
-  static HeapObjectReference* ClearedValue() {
-    return reinterpret_cast<HeapObjectReference*>(kClearedWeakHeapObject);
+    return HeapObjectReference(object->ptr() | kWeakHeapObjectMask);
   }
 
-  static void Update(HeapObjectReference** slot, HeapObject* value) {
-    DCHECK(!HAS_SMI_TAG(*slot));
-    DCHECK(Internals::HasHeapObjectTag(value));
+  V8_INLINE static HeapObjectReference ClearedValue(Isolate* isolate);
 
-#ifdef DEBUG
-    bool weak_before = HasWeakHeapObjectTag(*slot);
-#endif
-
-    *slot = reinterpret_cast<HeapObjectReference*>(
-        reinterpret_cast<intptr_t>(value) |
-        (reinterpret_cast<intptr_t>(*slot) & kWeakHeapObjectMask));
-
-#ifdef DEBUG
-    bool weak_after = HasWeakHeapObjectTag(*slot);
-    DCHECK_EQ(weak_before, weak_after);
-#endif
-  }
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObjectReference);
+  template <typename THeapObjectSlot>
+  V8_INLINE static void Update(THeapObjectSlot slot, HeapObject value);
 };
 
 }  // namespace internal