Kiss goodbye to MaybeObject.

src/heap-snapshot-generator.cc

 // Copyright 2013 the V8 project 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 "v8.h"
 
 #include "heap-snapshot-generator-inl.h"
 
 #include "allocation-tracker.h"
 #include "code-stubs.h"
@@ skipping 1038 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) {
       ++next_index_;
       if (CheckVisitedAndUnmark(p)) continue;
       generator_->SetHiddenReference(parent_obj_, parent_, next_index_, *p);
     }
   }
   static void MarkVisitedField(HeapObject* obj, int offset) {
     if (offset < 0) return;
     Address field = obj->address() + offset;
-    ASSERT(!Memory::Object_at(field)->IsFailure());
     ASSERT(Memory::Object_at(field)->IsHeapObject());
-    Object* untagged = *reinterpret_cast<Object**>(field);
-    intptr_t tagged  = reinterpret_cast<intptr_t>(untagged) | kFailureTag;
-    *reinterpret_cast<Object**>(field) = reinterpret_cast<Object*>(tagged);
+    intptr_t p = reinterpret_cast<intptr_t>(Memory::Object_at(field));
+    ASSERT(!IsMarked(p));
+    intptr_t p_tagged = p | kTag;
+    Memory::Object_at(field) = reinterpret_cast<Object*>(p_tagged);
   }
 
  private:
   bool CheckVisitedAndUnmark(Object** field) {
-    if ((*field)->IsFailure()) {
-      intptr_t untagged = reinterpret_cast<intptr_t>(*field) & ~kFailureTagMask;
-      *field = reinterpret_cast<Object*>(untagged | kHeapObjectTag);
+    intptr_t p = reinterpret_cast<intptr_t>(*field);
+    if (IsMarked(p)) {
+      intptr_t p_untagged = (p & ~kTaggingMask) | kHeapObjectTag;
+      *field = reinterpret_cast<Object*>(p_untagged);
       ASSERT((*field)->IsHeapObject());
       return true;
     }
     return false;
   }
+
+  static const intptr_t kTaggingMask = 3;
+  static const intptr_t kTag = 3;
+
+  static bool IsMarked(intptr_t p) { return (p & kTaggingMask) == kTag; }
+
   V8HeapExplorer* generator_;
   HeapObject* parent_obj_;
   int parent_;
   int next_index_;
 };
 
 
 bool V8HeapExplorer::ExtractReferencesPass1(int entry, HeapObject* obj) {
   if (obj->IsFixedArray()) return false;  // FixedArrays are processed on pass 2
 
@@ skipping 2056 matching lines @@
   writer_->AddString("\"<dummy>\"");
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 } }  // namespace v8::internal