Convert all symbols accessor to return read only handles so that it is not necessary to create a ne…

vm/symbols.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/symbols.h"
 
 #include "vm/handles.h"
 #include "vm/handles_impl.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/raw_object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/unicode.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
-RawString* Symbols::predefined_[Symbols::kMaxId];
-
-#define DEFINE_SYMBOL_HANDLE(symbol)                                           \
-  String* Symbols::symbol##_handle_ = NULL;
-PREDEFINED_SYMBOL_HANDLES_LIST(DEFINE_SYMBOL_HANDLE)
-#undef DEFINE_SYMBOL_HANDLE
+RawString* Symbols::predefined_[Symbols::kNumberOfOneCharCodeSymbols];
+String* Symbols::symbol_handles_[Symbols::kMaxPredefinedId];
 
 static const char* names[] = {
   NULL,
 
 #define DEFINE_SYMBOL_LITERAL(symbol, literal)                                 \
   literal,
 PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_LITERAL)
 #undef DEFINE_SYMBOL_LITERAL
 };
 
 intptr_t Symbols::num_of_grows_;
 intptr_t Symbols::collision_count_[kMaxCollisionBuckets];
 
 DEFINE_FLAG(bool, dump_symbol_stats, false, "Dump symbol table statistics");
 
 
 const char* Symbols::Name(SymbolId symbol) {
-  ASSERT((symbol > kIllegal) && (symbol < kMaxPredefinedId));
+  ASSERT((symbol > kIllegal) && (symbol < kNullCharId));
   return names[symbol];
 }
 
 
 void Symbols::InitOnce(Isolate* isolate) {
   // Should only be run by the vm isolate.
   ASSERT(isolate == Dart::vm_isolate());
 
   if (FLAG_dump_symbol_stats) {
     num_of_grows_ = 0;
     for (intptr_t i = 0; i < kMaxCollisionBuckets; i++) {
       collision_count_[i] = 0;
     }
   }
 
   // Create and setup a symbol table in the vm isolate.
   SetupSymbolTable(isolate);
 
   // Create all predefined symbols.
-  ASSERT((sizeof(names) / sizeof(const char*)) == Symbols::kMaxPredefinedId);
+  ASSERT((sizeof(names) / sizeof(const char*)) == Symbols::kNullCharId);
   ObjectStore* object_store = isolate->object_store();
   Array& symbol_table = Array::Handle();
-  dart::String& str = String::Handle();
 
-  for (intptr_t i = 1; i < Symbols::kMaxPredefinedId; i++) {
+
+  // First set up all the predefined string symbols.
+  for (intptr_t i = 1; i < Symbols::kNullCharId; i++) {
     // The symbol_table needs to be reloaded as it might have grown in the
     // previous iteration.
     symbol_table = object_store->symbol_table();
-    str = OneByteString::New(names[i], Heap::kOld);
-    Add(symbol_table, str);
-    predefined_[i] = str.raw();
+    String* str = reinterpret_cast<String*>(Dart::AllocateReadOnlyHandle());
+    *str = OneByteString::New(names[i], Heap::kOld);
+    Add(symbol_table, *str);
+    symbol_handles_[i] = str;
   }
   Object::RegisterSingletonClassNames();
 
   // Add Latin1 characters as Symbols, so that Symbols::FromCharCode is fast.
-  for (intptr_t c = 0; c <= kMaxOneCharCodeSymbol; c++) {
+  for (intptr_t c = 0; c < kNumberOfOneCharCodeSymbols; c++) {
     // The symbol_table needs to be reloaded as it might have grown in the
     // previous iteration.
     symbol_table = object_store->symbol_table();
-    ASSERT(kMaxPredefinedId + c < kMaxId);
+    intptr_t idx = (kNullCharId + c);
+    ASSERT(idx < kMaxPredefinedId);
     ASSERT(Utf::IsLatin1(c));
     uint8_t ch = static_cast<uint8_t>(c);
-    str = OneByteString::New(&ch, 1, Heap::kOld);
-    Add(symbol_table, str);
-    predefined_[kMaxPredefinedId + c] = str.raw();
+    String* str = reinterpret_cast<String*>(Dart::AllocateReadOnlyHandle());
+    *str = OneByteString::New(&ch, 1, Heap::kOld);
+    Add(symbol_table, *str);
+    predefined_[c] = str->raw();
+    symbol_handles_[idx] = str;
   }
-
-#define INITIALIZE_SYMBOL_HANDLE(symbol)                                       \
-  symbol##_handle_ = reinterpret_cast<String*>(                                \
-      Dart::AllocateReadOnlyHandle());                                         \
-  *symbol##_handle_ = symbol();
-PREDEFINED_SYMBOL_HANDLES_LIST(INITIALIZE_SYMBOL_HANDLE)
-#undef INITIALIZE_SYMBOL_HANDLE
 }
 
 
 void Symbols::SetupSymbolTable(Isolate* isolate) {
   ASSERT(isolate != NULL);
 
   // Setup the symbol table used within the String class.
   const int initial_size = (isolate == Dart::vm_isolate()) ?
       kInitialVMIsolateSymtabSize : kInitialSymtabSize;
   const Array& array = Array::Handle(Array::New(initial_size + 1));
@@ skipping 165 matching lines @@
   }
   ASSERT(symbol.IsSymbol());
   return symbol.raw();
 }
 
 
 RawString* Symbols::FromCharCode(int32_t char_code) {
   if (char_code > kMaxOneCharCodeSymbol) {
     return FromUTF32(&char_code, 1);
   }
-  return predefined_[kNullCharId + char_code];
+  return predefined_[char_code];
 }
 
 
 void Symbols::DumpStats() {
   if (FLAG_dump_symbol_stats) {
     intptr_t table_size = 0;
     dart::Smi& used = Smi::Handle();
     Array& symbol_table = Array::Handle(Array::null());
 
     // First dump VM symbol table stats.
@@ skipping 142 matching lines @@
     if (num_collisions >= kMaxCollisionBuckets) {
       num_collisions = (kMaxCollisionBuckets - 1);
     }
     collision_count_[num_collisions] += 1;
   }
   return index;  // Index of symbol if found or slot into which to add symbol.
 }
 
 
 intptr_t Symbols::LookupVMSymbol(RawObject* obj) {
-  for (intptr_t i = 1;  i < Symbols::kMaxId; i++) {
-    if (predefined_[i] == obj) {
+  for (intptr_t i = 1; i < Symbols::kMaxPredefinedId; i++) {
+    if (symbol_handles_[i]->raw() == obj) {
       return (i + kMaxPredefinedObjectIds);
     }
   }
   return kInvalidIndex;
 }
 
 
 RawObject* Symbols::GetVMSymbol(intptr_t object_id) {
   ASSERT(IsVMSymbolId(object_id));
   intptr_t i = (object_id - kMaxPredefinedObjectIds);
-  return (i > 0 && i < Symbols::kMaxId) ? predefined_[i] : Object::null();
+  if ((i > kIllegal) && (i < Symbols::kMaxPredefinedId)) {
+    return symbol_handles_[i]->raw();
+  }
+  return Object::null();
 }
 
 }  // namespace dart