Create frequently used symbols in the vm isolate

vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/resolver.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
+#include "vm/symbols.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, inline_cache, true, "Enable inline caches");
 DEFINE_FLAG(bool, trace_deopt, false, "Trace deoptimization");
 DEFINE_FLAG(bool, trace_ic, false, "Trace IC handling");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(int, optimization_counter_threshold, 2000,
@@ skipping 176 matching lines @@
     ASSERT(type_arguments.IsInstantiated());
     Error& malformed_error = Error::Handle();
     if (!type_arguments.IsWithinBoundsOf(cls,
                                          bounds_instantiator,
                                          &malformed_error)) {
       ASSERT(!malformed_error.IsNull());
       // Throw a dynamic type error.
       const intptr_t location = GetCallerLocation();
       String& malformed_error_message =  String::Handle(
           String::New(malformed_error.ToErrorCString()));
-      const String& no_name = String::Handle(String::NewSymbol(""));
+      const String& no_name = String::Handle(Symbols::New(""));
       Exceptions::CreateAndThrowTypeError(
           location, no_name, no_name, no_name, malformed_error_message);
       UNREACHABLE();
     }
   }
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type arguments.
@@ skipping 342 matching lines @@
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
   }
   if (!result.value() && !malformed_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const intptr_t location = GetCallerLocation();
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
-    const String& no_name = String::Handle(String::NewSymbol(""));
+    const String& no_name = String::Handle(Symbols::New(""));
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(node_id, instance, type, instantiator,
                       instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // For error reporting, simplify type name, e.g, all integer types (Smi, Mint,
 // Bigint) are reported as 'int' and all String types are mapped to 'String'.
 static RawString* GetSimpleTypeName(const Instance& value) {
   if (value.IsInteger()) {
-    return String::NewSymbol("int");
+    return Symbols::New("int");
   } else if (value.IsString()) {
-    return String::NewSymbol("String");
+    return Symbols::New("String");
   } else {
     return Type::Handle(value.GetType()).Name();
   }
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
 // Arg0: node-id of the assignment.
 // Arg1: instance being assigned.
@@ skipping 61 matching lines @@
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 1) {
   ASSERT(arguments.Count() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_instance = Instance::CheckedHandle(arguments.At(0));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolInterface());
   const String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
   const String& bool_type_name = String::Handle(bool_interface.Name());
-  const String& expr = String::Handle(String::NewSymbol("boolean expression"));
+  const String& expr = String::Handle(Symbols::New("boolean expression"));
   const String& no_malformed_type_error =  String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
                                       expr, no_malformed_type_error);
   UNREACHABLE();
 }
 
 
 // Report that the type of the type check is malformed.
 // Arg0: src value.
 // Arg1: name of instance being assigned to.
 // Arg2: malformed type error message.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(MalformedTypeError, 3) {
   ASSERT(arguments.Count() ==
       kMalformedTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(arguments.At(0));
   const String& dst_name = String::CheckedHandle(arguments.At(1));
   const String& malformed_error = String::CheckedHandle(arguments.At(2));
-  const String& dst_type_name = String::Handle(String::NewSymbol("malformed"));
+  const String& dst_type_name = String::Handle(Symbols::New("malformed"));
   const String& src_type_name = String::Handle(GetSimpleTypeName(src_value));
   Exceptions::CreateAndThrowTypeError(location, src_type_name,
                                       dst_type_name, dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   ASSERT(arguments.Count() == kThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.At(0));
@@ skipping 307 matching lines @@
   if (!original_function_name.StartsWith(getter_prefix)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   const Class& receiver_class = Class::Handle(receiver.clazz());
   ASSERT(!receiver_class.IsNull());
   String& func_name = String::Handle();
   func_name = String::SubString(original_function_name, getter_prefix.Length());
-  func_name = String::NewSymbol(func_name);
+  func_name = Symbols::New(func_name);
   const Function& function = Function::Handle(
       LookupDynamicFunction(isolate, receiver_class, func_name));
   if (function.IsNull()) {
     // There is no function of the same name so can't be the case where
     // we are trying to create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   Function& implicit_closure_function =
       Function::Handle(function.ImplicitClosureFunction());
@@ skipping 154 matching lines @@
   const String& original_function_name = String::Handle(ic_data.target_name());
   ASSERT(!Array::CheckedHandle(arguments.At(2)).IsNull());
   const Array& orig_arguments = Array::CheckedHandle(arguments.At(3));
   // TODO(regis): The signature of the "noSuchMethod" method has to change from
   // noSuchMethod(String name, Array arguments) to something like
   // noSuchMethod(InvocationMirror call).
   const int kNumArguments = 3;
   const int kNumNamedArguments = 0;
   const Array& kNoArgumentNames = Array::Handle();
   const String& function_name =
-      String::Handle(String::NewSymbol("noSuchMethod"));
+      String::Handle(Symbols::New("noSuchMethod"));
   const Function& function = Function::ZoneHandle(
       Resolver::ResolveDynamic(receiver,
                                function_name,
                                kNumArguments,
                                kNumNamedArguments));
   ASSERT(!function.IsNull());
   GrowableArray<const Object*> invoke_arguments(2);
   invoke_arguments.Add(&original_function_name);
   invoke_arguments.Add(&orig_arguments);
   const Object& result = Object::Handle(
@@ skipping 358 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart