Avoid some crashes when running without snapshots.

src/heap.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 895 matching lines @@
   // TODO(gc) we are ignoring this flag
   static const int kForceCompactionMask = 1;
   static const int kMakeHeapIterableMask = 2;
 
   // Performs a full garbage collection.  If (flags & kForceCompactionMask) is
   // non-zero then force compaction.  If (flags & kMakeHeapIterableMask) is non-
   // zero, then the slower precise sweeper is used, which leaves the heap in a
   // state where we can iterate over the heap visiting all objects.
   void CollectAllGarbage(int flags);
 
+  // Check whether the heap is currently iterable.
+  bool IsHeapIterable();
+
   // Ensure that we have swept all spaces in such a way that we can iterate
   // over all objects.  May cause a GC.
   void EnsureHeapIsIterable();
 
   // Last hope GC, should try to squeeze as much as possible.
   void CollectAllAvailableGarbage();
 
   // Notify the heap that a context has been disposed.
   int NotifyContextDisposed() { return ++contexts_disposed_; }
 
@@ skipping 996 matching lines @@
   ObjectIterator* CreateIterator();
 
   int current_space_;  // from enum AllocationSpace.
   ObjectIterator* iterator_;  // object iterator for the current space.
   HeapObjectCallback size_func_;
 };
 
 
 // A HeapIterator provides iteration over the whole heap. It
 // aggregates the specific iterators for the different spaces as
-// these can only iterate over one space only.  It can only be guaranteed
-// to iterate over live objects.
+// these can only iterate over one space only.
 //
 // HeapIterator can skip free list nodes (that is, de-allocated heap
 // objects that still remain in the heap). As implementation of free
 // nodes filtering uses GC marks, it can't be used during MS/MC GC
 // phases. Also, it is forbidden to interrupt iteration in this mode,
 // as this will leave heap objects marked (and thus, unusable).
 class HeapObjectsFilter;
 
 class HeapIterator BASE_EMBEDDED {
  public:
+  enum HeapObjectsFiltering {
+    kNoFiltering,
+    kFilterFreeListNodes,
+    kFilterUnreachable
+  };
+
   HeapIterator();
+  explicit HeapIterator(HeapObjectsFiltering filtering);
   ~HeapIterator();
 
-  HeapObject* Next();
-  void Reset();
+  HeapObject* next();
+  void reset();
 
  private:
   // Perform the initialization.
   void Init();
   // Perform all necessary shutdown (destruction) work.
   void Shutdown();
+  HeapObject* NextObject();
 
+  HeapObjectsFiltering filtering_;
+  HeapObjectsFilter* filter_;
   // Space iterator for iterating all the spaces.
   SpaceIterator* space_iterator_;
   // Object iterator for the space currently being iterated.
   ObjectIterator* object_iterator_;
 };
 
 
 // Cache for mapping (map, property name) into field offset.
 // Cleared at startup and prior to mark sweep collection.
 class KeyedLookupCache {
@@ skipping 382 matching lines @@
     object->set_map_word(MapWord::FromRawValue(map_word | kNotMarkedBit));
     ASSERT(!IsMarked(object));
   }
 
   static void SetMark(HeapObject* object) {
     uintptr_t map_word = object->map_word().ToRawValue();
     object->set_map_word(MapWord::FromRawValue(map_word & ~kNotMarkedBit));
     ASSERT(IsMarked(object));
   }
 
+  static Map* MapOfMarkedObject(HeapObject* object) {
+    uintptr_t map_word = object->map_word().ToRawValue();
+    return MapWord::FromRawValue(map_word | kNotMarkedBit).ToMap();
+  }
+
   static int SizeOfMarkedObject(HeapObject* object) {
-    uintptr_t map_word = object->map_word().ToRawValue();
-    Map* map = MapWord::FromRawValue(map_word | kNotMarkedBit).ToMap();
-    return object->SizeFromMap(map);
+    return object->SizeFromMap(MapOfMarkedObject(object));
   }
 
  private:
   static const uintptr_t kNotMarkedBit = 0x1;
   STATIC_ASSERT((kHeapObjectTag & kNotMarkedBit) != 0);
 };
 
 
 #if defined(DEBUG) || defined(LIVE_OBJECT_LIST)
 // Helper class for tracing paths to a search target Object from all roots.
@@ skipping 51 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #undef HEAP
 
 #endif  // V8_HEAP_H_