Create frequently used symbols in the vm isolate

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 11 matching lines @@
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
 class Code;
 class LocalScope;
+class Symbols;
 
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   void operator=(Raw##object* value) {                                         \
     initializeHandle(this, value);                                             \
   }                                                                            \
   bool Is##object() const { return true; }                                     \
   void operator^=(RawObject* value) {                                          \
     initializeHandle(this, value);                                             \
@@ skipping 322 matching lines @@
 
   uword raw_value() const {
     return reinterpret_cast<uword>(raw());
   }
 
   inline void SetRaw(RawObject* value);
 
   cpp_vtable vtable() const { return bit_copy<cpp_vtable>(*this); }
   void set_vtable(cpp_vtable value) { *vtable_address() = value; }
 
-  static RawObject* Allocate(const Class& cls,
+  static RawObject* Allocate(intptr_t cls_id,
                              intptr_t size,
                              Heap::Space space);
 
   static intptr_t RoundedAllocationSize(intptr_t size) {
     return Utils::RoundUp(size, kObjectAlignment);
   }
 
   bool Contains(uword addr) const {
     intptr_t this_size = raw()->Size();
     uword this_addr = RawObject::ToAddr(raw());
@@ skipping 2936 matching lines @@
 
   static RawString* Transform(int32_t (*mapping)(int32_t ch),
                               const String& str,
                               Heap::Space space = Heap::kNew);
 
   static RawString* ToUpperCase(const String& str,
                                 Heap::Space space = Heap::kNew);
   static RawString* ToLowerCase(const String& str,
                                 Heap::Space space = Heap::kNew);
 
-  static RawString* NewSymbol(const char* str);
-  template<typename T>
-  static RawString* NewSymbol(const T* characters, intptr_t len);
-  static RawString* NewSymbol(const String& str);
-  static RawString* NewSymbol(const String& str,
-                              intptr_t begin_index,
-                              intptr_t length);
-
   static RawString* NewFormatted(const char* format, ...);
 
  protected:
   bool HasHash() const {
     ASSERT(Smi::New(0) == NULL);
     return (raw_ptr()->hash_ != NULL);
   }
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->length_ = Smi::New(value);
   }
 
   void SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->hash_ = Smi::New(value);
   }
 
   template<typename HandleType, typename ElementType>
   static void ReadFromImpl(SnapshotReader* reader,
                            HandleType* str_obj,
                            intptr_t len,
                            intptr_t tags);
 
   HEAP_OBJECT_IMPLEMENTATION(String, Instance);
+
+  friend class Symbols;
 };
 
 
 class OneByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
@@ skipping 1834 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_