Verify the symbol table contents before and after all...

src/heap.cc

 // Copyright 2009 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 356 matching lines @@
   return false;
 }
 
 
 void Heap::PerformScavenge() {
   GCTracer tracer;
   PerformGarbageCollection(NEW_SPACE, SCAVENGER, &tracer);
 }
 
 
+static void VerifySymbolTable() {
+#ifdef DEBUG
+  // Helper class for verifying the symbol table.
+  class SymbolTableVerifier : public ObjectVisitor {
+   public:
+    SymbolTableVerifier() { }
+    void VisitPointers(Object** start, Object** end) {
+      // Visit all HeapObject pointers in [start, end).
+      for (Object** p = start; p < end; p++) {
+        if ((*p)->IsHeapObject()) {
+          // Check that the symbol is actually a symbol.
+          ASSERT((*p)->IsNull() || (*p)->IsUndefined() || (*p)->IsSymbol());
+        }
+      }
+    }
+  };
+
+  SymbolTableVerifier verifier;
+  SymbolTable* symbol_table = SymbolTable::cast(Heap::symbol_table());
+  symbol_table->IterateElements(&verifier);
+#endif  // DEBUG
+}
+
+
 void Heap::PerformGarbageCollection(AllocationSpace space,
                                     GarbageCollector collector,
                                     GCTracer* tracer) {
+  VerifySymbolTable();
   if (collector == MARK_COMPACTOR && global_gc_prologue_callback_) {
     ASSERT(!allocation_allowed_);
     global_gc_prologue_callback_();
   }
 
   if (collector == MARK_COMPACTOR) {
     MarkCompact(tracer);
 
     int old_gen_size = PromotedSpaceSize();
     old_gen_promotion_limit_ =
@@ skipping 24 matching lines @@
   if (collector == MARK_COMPACTOR) {
     // Register the amount of external allocated memory.
     amount_of_external_allocated_memory_at_last_global_gc_ =
         amount_of_external_allocated_memory_;
   }
 
   if (collector == MARK_COMPACTOR && global_gc_epilogue_callback_) {
     ASSERT(!allocation_allowed_);
     global_gc_epilogue_callback_();
   }
+  VerifySymbolTable();
 }
 
 
 void Heap::PostGarbageCollectionProcessing() {
   // Process weak handles post gc.
   GlobalHandles::PostGarbageCollectionProcessing();
   // Update flat string readers.
   FlatStringReader::PostGarbageCollectionProcessing();
 }
 
@@ skipping 372 matching lines @@
     *p = first_word.ToForwardingAddress();
     return;
   }
 
   // Call the slow part of scavenge object.
   return ScavengeObjectSlow(p, object);
 }
 
 
 static inline bool IsShortcutCandidate(HeapObject* object, Map* map) {
-  // A ConsString with an empty string as the right side is a
-  // candidate for being shortcut by the scavenger unless it is a
-  // symbol. It's not common to have non-flat symbols, so we do not
-  // shortcut them thereby avoiding turning symbols into strings.
-  ASSERT(kNotStringTag != 0 && kSymbolTag != 0);
-  static const uint32_t kShortcutTypeMask =
-      kIsNotStringMask |
-      kIsSymbolMask |
-      kStringRepresentationMask;
   ASSERT(object->map() == map);
   InstanceType type = map->instance_type();
-  if ((type & kShortcutTypeMask) != kConsStringTag) return false;
+  if ((type & kShortcutTypeMask) != kShortcutTypeTag) return false;
   ASSERT(object->IsString() && !object->IsSymbol());
   return ConsString::cast(object)->unchecked_second() == Heap::empty_string();
 }
 
 
 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
   ASSERT(InFromSpace(object));
   MapWord first_word = object->map_word();
   ASSERT(!first_word.IsForwardingAddress());
 
@@ skipping 2525 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal