- Refactor Symbol allocation to expect a thread parameter.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 27 matching lines @@
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 // Quick access to the locally defined zone() method.
 #define Z (zone())
 
+// Quick access to the locally defined thread() method.
+#define T (thread())
+
 // Quick synthetic token position.
 #define ST(token_pos) ((token_pos).ToSynthetic())
 
 // TODO(srdjan): Allow compiler to add constants as they are encountered in
 // the compilation.
 const double kCommonDoubleConstants[] =
     {-1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0,
      10.0, 20.0, 30.0, 64.0, 255.0, NAN,
      // From dart:math
      2.718281828459045, 2.302585092994046, 0.6931471805599453,
@@ skipping 1327 matching lines @@
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
-  const String& name = String::ZoneHandle(Z, Symbols::New(node->TokenName()));
+  const String& name = Symbols::Token(node->kind());
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new(Z) InstanceCallInstr(node->token_pos(),
                                                      name,
                                                      node->kind(),
                                                      arguments,
                                                      Object::null_array(),
                                                      kNumArgsChecked,
                                                      owner()->ic_data_array());
   ReturnDefinition(call);
 }
@@ skipping 415 matching lines @@
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
   InstanceCallInstr* comp = new(Z) InstanceCallInstr(
       node->token_pos(),
-      String::ZoneHandle(Z, Symbols::New(node->TokenName())),
+      Symbols::Token(node->kind()),
       node->kind(),
       arguments,
       Object::null_array(),
       2,
       owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
@@ skipping 15 matching lines @@
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   InstanceCallInstr* call = new(Z) InstanceCallInstr(
       node->token_pos(),
-      String::ZoneHandle(Z, Symbols::New(node->TokenName())),
+      Symbols::Token(node->kind()),
       node->kind(),
       arguments,
       Object::null_array(),
       1,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
@@ skipping 416 matching lines @@
     Value* value, TokenPosition token_pos) {
   Do(new(Z) PushTempInstr(value));
   owner()->AllocateTemp();
 
   ASSERT(value->definition()->temp_index() == (owner()->temp_count() - 1));
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable*  var =
       new(Z) LocalVariable(TokenPosition::kNoSource,
-                           String::ZoneHandle(Z, Symbols::New(name)),
+                           String::ZoneHandle(Z, Symbols::New(T, name)),
                            *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
 Definition* EffectGraphVisitor::ExitTempLocalScope(
     LocalVariable* var, TokenPosition token_pos) {
   Value* tmp = Bind(new(Z) LoadLocalInstr(*var, token_pos));
   owner()->DeallocateTemps(1);
@@ skipping 904 matching lines @@
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle(Z, Function::null());
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     ASSERT(node->receiver() != NULL);
-    getter_function = Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
+    getter_function = Resolver::ResolveDynamicAnyArgs(Z,
+        node->cls(), getter_name);
     if (getter_function.IsNull()) {
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new(Z) ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->cls(),
                                       node->receiver(),
                                       getter_name,
                                       arguments,
                                       false,  // Don't save last argument.
@@ skipping 547 matching lines @@
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(
       BuildStoreStaticField(node, kResultNeeded, node->token_pos()));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Function* super_function = NULL;
   if (node->IsSuperLoad()) {
     // Resolve the load indexed operator in the super class.
-    super_function = &Function::ZoneHandle(
-          Z, Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                             Symbols::IndexToken()));
+    super_function = &Function::ZoneHandle(Z, Resolver::ResolveDynamicAnyArgs(Z,
+        node->super_class(), Symbols::IndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new(Z) ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
                                       Symbols::IndexToken(),
@@ skipping 40 matching lines @@
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
   const TokenPosition token_pos = node->token_pos();
   if (node->IsSuperStore()) {
     // Resolve the store indexed operator in the super class.
-    super_function = &Function::ZoneHandle(
-        Z, Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                           Symbols::AssignIndexToken()));
+    super_function = &Function::ZoneHandle(Z, Resolver::ResolveDynamicAnyArgs(Z,
+        node->super_class(), Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new(Z) ArgumentListNode(token_pos);
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       arguments->Add(node->value());
       StaticCallInstr* call = BuildStaticNoSuchMethodCall(
           node->super_class(),
           node->array(),
@@ skipping 45 matching lines @@
                                owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 2;  // Do not check for value type.
-    const String& name =
-        String::ZoneHandle(Z, Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
     InstanceCallInstr* store =
         new(Z) InstanceCallInstr(token_pos,
-                                 name,
+                                 Symbols::AssignIndexToken(),
                                  Token::kASSIGN_INDEX,
                                  arguments,
                                  Object::null_array(),
                                  checked_argument_count,
                                  owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
@@ skipping 524 matching lines @@
       Type::New(function_class,
                 TypeArguments::Handle(Z, TypeArguments::null()),
                 token_pos,
                 Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       function_class, type, ClassFinalizer::kCanonicalize);
   Value* receiver_value = Bind(new(Z) ConstantInstr(type));
   arguments->Add(PushArgument(receiver_value));
   // String memberName.
   const String& member_name =
-      String::ZoneHandle(Z, Symbols::New(function_name));
+      String::ZoneHandle(Z, Symbols::New(T, function_name));
   Value* member_name_value = Bind(new(Z) ConstantInstr(member_name));
   arguments->Add(PushArgument(member_name_value));
   // Smi invocation_type.
   Value* invocation_type_value = Bind(new(Z) ConstantInstr(
       Smi::ZoneHandle(Z, Smi::New(invocation_type))));
   arguments->Add(PushArgument(invocation_type_value));
   // List arguments.
   if (function_arguments == NULL) {
     Value* arguments_value = Bind(
         new(Z) ConstantInstr(Array::ZoneHandle(Z, Array::null())));
@@ skipping 176 matching lines @@
                    Script::Handle(function.script()),
                    function.token_pos(),
                    Report::AtLocation,
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart