Renamed "symbols" to "internalized strings" throughout the code base,

src/profile-generator.cc

 // Copyright 2012 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 1894 matching lines @@
 
 
 void V8HeapExplorer::ExtractJSObjectReferences(
     int entry, JSObject* js_obj) {
   HeapObject* obj = js_obj;
   ExtractClosureReferences(js_obj, entry);
   ExtractPropertyReferences(js_obj, entry);
   ExtractElementReferences(js_obj, entry);
   ExtractInternalReferences(js_obj, entry);
   SetPropertyReference(
-      obj, entry, heap_->Proto_symbol(), js_obj->GetPrototype());
+      obj, entry, heap_->proto_string(), js_obj->GetPrototype());
   if (obj->IsJSFunction()) {
     JSFunction* js_fun = JSFunction::cast(js_obj);
     Object* proto_or_map = js_fun->prototype_or_initial_map();
     if (!proto_or_map->IsTheHole()) {
       if (!proto_or_map->IsMap()) {
         SetPropertyReference(
             obj, entry,
-            heap_->prototype_symbol(), proto_or_map,
+            heap_->prototype_string(), proto_or_map,
             NULL,
             JSFunction::kPrototypeOrInitialMapOffset);
       } else {
         SetPropertyReference(
             obj, entry,
-            heap_->prototype_symbol(), js_fun->prototype());
+            heap_->prototype_string(), js_fun->prototype());
       }
     }
     SharedFunctionInfo* shared_info = js_fun->shared();
     // JSFunction has either bindings or literals and never both.
     bool bound = shared_info->bound();
     TagObject(js_fun->literals_or_bindings(),
               bound ? "(function bindings)" : "(function literals)");
     SetInternalReference(js_fun, entry,
                          bound ? "bindings" : "literals",
                          js_fun->literals_or_bindings(),
@@ skipping 269 matching lines @@
     int real_size = js_obj->map()->NumberOfOwnDescriptors();
     for (int i = 0; i < descs->number_of_descriptors(); i++) {
       if (descs->GetDetails(i).descriptor_index() > real_size) continue;
       switch (descs->GetType(i)) {
         case FIELD: {
           int index = descs->GetFieldIndex(i);
 
           String* k = descs->GetKey(i);
           if (index < js_obj->map()->inobject_properties()) {
             Object* value = js_obj->InObjectPropertyAt(index);
-            if (k != heap_->hidden_symbol()) {
+            if (k != heap_->hidden_string()) {
               SetPropertyReference(
                   js_obj, entry,
                   k, value,
                   NULL,
                   js_obj->GetInObjectPropertyOffset(index));
             } else {
               TagObject(value, "(hidden properties)");
               SetInternalReference(
                   js_obj, entry,
                   "hidden_properties", value,
                   js_obj->GetInObjectPropertyOffset(index));
             }
           } else {
             Object* value = js_obj->FastPropertyAt(index);
-            if (k != heap_->hidden_symbol()) {
+            if (k != heap_->hidden_string()) {
               SetPropertyReference(js_obj, entry, k, value);
             } else {
               TagObject(value, "(hidden properties)");
               SetInternalReference(js_obj, entry, "hidden_properties", value);
             }
           }
           break;
         }
         case CONSTANT_FUNCTION:
           SetPropertyReference(
@@ skipping 29 matching lines @@
     StringDictionary* dictionary = js_obj->property_dictionary();
     int length = dictionary->Capacity();
     for (int i = 0; i < length; ++i) {
       Object* k = dictionary->KeyAt(i);
       if (dictionary->IsKey(k)) {
         Object* target = dictionary->ValueAt(i);
         // We assume that global objects can only have slow properties.
         Object* value = target->IsJSGlobalPropertyCell()
             ? JSGlobalPropertyCell::cast(target)->value()
             : target;
-        if (k != heap_->hidden_symbol()) {
+        if (k != heap_->hidden_string()) {
           SetPropertyReference(js_obj, entry, String::cast(k), value);
         } else {
           TagObject(value, "(hidden properties)");
           SetInternalReference(js_obj, entry, "hidden_properties", value);
         }
       }
     }
   }
 }
 
@@ skipping 29 matching lines @@
   for (int i = 0; i < length; ++i) {
     Object* o = js_obj->GetInternalField(i);
     SetInternalReference(
         js_obj, entry, i, o, js_obj->GetInternalFieldOffset(i));
   }
 }
 
 
 String* V8HeapExplorer::GetConstructorName(JSObject* object) {
   Heap* heap = object->GetHeap();
-  if (object->IsJSFunction()) return heap->closure_symbol();
+  if (object->IsJSFunction()) return heap->closure_string();
   String* constructor_name = object->constructor_name();
-  if (constructor_name == heap->Object_symbol()) {
+  if (constructor_name == heap->Object_string()) {
     // Look up an immediate "constructor" property, if it is a function,
     // return its name. This is for instances of binding objects, which
     // have prototype constructor type "Object".
     Object* constructor_prop = NULL;
     LookupResult result(heap->isolate());
-    object->LocalLookupRealNamedProperty(heap->constructor_symbol(), &result);
+    object->LocalLookupRealNamedProperty(heap->constructor_string(), &result);
     if (!result.IsFound()) return object->constructor_name();
 
     constructor_prop = result.GetLazyValue();
     if (constructor_prop->IsJSFunction()) {
       Object* maybe_name =
           JSFunction::cast(constructor_prop)->shared()->name();
       if (maybe_name->IsString()) {
         String* name = String::cast(maybe_name);
         if (name->length() > 0) return name;
       }
@@ skipping 301 matching lines @@
 
 const char* V8HeapExplorer::GetStrongGcSubrootName(Object* object) {
   if (strong_gc_subroot_names_.is_empty()) {
 #define NAME_ENTRY(name) strong_gc_subroot_names_.SetTag(heap_->name(), #name);
 #define ROOT_NAME(type, name, camel_name) NAME_ENTRY(name)
     STRONG_ROOT_LIST(ROOT_NAME)
 #undef ROOT_NAME
 #define STRUCT_MAP_NAME(NAME, Name, name) NAME_ENTRY(name##_map)
     STRUCT_LIST(STRUCT_MAP_NAME)
 #undef STRUCT_MAP_NAME
-#define SYMBOL_NAME(name, str) NAME_ENTRY(name)
-    SYMBOL_LIST(SYMBOL_NAME)
-#undef SYMBOL_NAME
+#define STRING_NAME(name, str) NAME_ENTRY(name)
+    INTERNALIZED_STRING_LIST(STRING_NAME)
+#undef STRING_NAME
 #undef NAME_ENTRY
     CHECK(!strong_gc_subroot_names_.is_empty());
   }
   return strong_gc_subroot_names_.GetTag(object);
 }
 
 
 void V8HeapExplorer::TagObject(Object* obj, const char* tag) {
   if (IsEssentialObject(obj)) {
     HeapEntry* entry = GetEntry(obj);
@@ skipping 908 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal