Fix allocation of array tables (use store barrier if needed, store values directly instead of via s…

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 96 matching lines @@
 }
 
 
 LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
   return new LocalVariable(token_pos,
                            Symbols::ExprTemp(),
                            Type::ZoneHandle(Type::DynamicType()));
 }
 
 
+LocalVariable* ParsedFunction::CreateArrayLiteralVar(intptr_t token_pos) {
+  return new LocalVariable(token_pos,
+                           Symbols::ArrayLiteralVar(),
+                           Type::ZoneHandle(Type::ArrayType()));
+}
+
+
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
 LocalVariable* ParsedFunction::GetSavedArgumentsDescriptorVar() const {
   const int num_parameters = function().NumParameters();
   LocalScope* scope = node_sequence()->scope();
@@ skipping 624 matching lines @@
     case RawFunction::kConstImplicitGetter:
       node_sequence = parser.ParseStaticConstGetter(func);
       break;
     case RawFunction::kMethodExtractor:
       node_sequence = parser.ParseMethodExtractor(func);
       break;
     default:
       UNREACHABLE();
   }
 
+  parsed_function->set_array_literal_var(

[hausner, 2013/02/13 00:47:30]

I don't like that you have to allocate a variable for each function, whether
it's used by the backend or not. It is needed in very few cases.

Could you not keep the old behavior of the ArrayNode if there is no temporary
variable given to the ArrayNode? That way, you treat all cases where the array
node is allocated in the parser with your new code generation pattern, and the
one use where the array node is allocated in the backend, code generation
remains as it is now.

[srdjan, 2013/02/13 01:15:00]

I don't like it either, but could not come up with a solution that would avoid
it (discussed offline). Optimized code will get rid of it.

+      ParsedFunction::CreateArrayLiteralVar(func.token_pos()));
+  node_sequence->scope()->AddVariable(parsed_function->array_literal_var());
+
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(func.end_token_pos()));
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   if (parsed_function->has_saved_current_context_var()) {
     node_sequence->scope()->AddVariable(
         parsed_function->saved_current_context_var());
@@ skipping 597 matching lines @@
 }
 
 
 static const String& PrivateCoreLibName(const String& str) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
   return private_name;
 }
 
 
+LocalVariable* Parser::BuildArrayTempLocal(intptr_t token_pos) {
+  char name[64];
+  OS::SNPrint(name, 64, ":arrlit%"Pd, token_pos);
+  LocalVariable* temp =
+      new LocalVariable(token_pos,
+                        String::ZoneHandle(Symbols::New(name)),
+                        Type::ZoneHandle(Type::ArrayType()));
+  current_block_->scope->AddVariable(temp);
+  return temp;
+}
+
+
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
     intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args) {
   const intptr_t args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is the arguments descriptor of the original function.
   const Array& args_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(function_args.length(),
                                                  function_args.names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original function arguments,
   // including the receiver.
   ArrayNode* args_array = new ArrayNode(
-      args_pos, Type::ZoneHandle(Type::ArrayType()));
+      args_pos, Type::ZoneHandle(Type::ArrayType()),
+      *BuildArrayTempLocal(call_pos));
   for (intptr_t i = 0; i < function_args.length(); i++) {
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
   const Class& mirror_class =
       Class::Handle(LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       mirror_class.LookupStaticFunction(
@@ skipping 7269 matching lines @@
       ASSERT(factory_type_args.Length() == 1);
       Type& factory_type = Type::Handle(Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
-    ArrayNode* list = new ArrayNode(TokenPos(), type, element_list);
+    const LocalVariable& temp_local = *BuildArrayTempLocal(type_pos);
+    ArrayNode* list = new ArrayNode(TokenPos(), type, temp_local, element_list);
     factory_param->Add(list);
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
 }
 
 
 ConstructorCallNode* Parser::CreateConstructorCallNode(
@@ skipping 69 matching lines @@
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
-  // The kv_pair array is temporary and of element type dynamic. It is passed
-  // to the factory to initialize a properly typed map.
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
       ErrorMsg("map entry key must be string literal");
@@ skipping 107 matching lines @@
       ASSERT(factory_type_args.Length() == 2);
       Type& factory_type = Type::Handle(Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+    // The kv_pair array is temporary and of element type dynamic. It is passed
+    // to the factory to initialize a properly typed map.
     ArrayNode* kv_pairs = new ArrayNode(
-        TokenPos(), Type::ZoneHandle(Type::ArrayType()), kv_pairs_list);
+        TokenPos(),
+        Type::ZoneHandle(Type::ArrayType()),
+        *BuildArrayTempLocal(type_pos),
+        kv_pairs_list);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
@@ skipping 355 matching lines @@
         }
       }
       values_list.Add(expr);
     }
   }
   if (is_compiletime_const) {
     primary = new LiteralNode(literal_start, Interpolate(values_list));
   } else {
     ArgumentListNode* interpolate_arg = new ArgumentListNode(TokenPos());
     ArrayNode* values = new ArrayNode(
-        TokenPos(), Type::ZoneHandle(Type::ArrayType()), values_list);
+        TokenPos(),
+        Type::ZoneHandle(Type::ArrayType()),
+        *BuildArrayTempLocal(TokenPos()),
+        values_list);
     interpolate_arg->Add(values);
     primary = MakeStaticCall(Symbols::StringBase(),
                              PrivateCoreLibName(Symbols::Interpolate()),
                              interpolate_arg);
   }
   return primary;
 }
 
 
 AstNode* Parser::ParseArgumentDefinitionTest() {
@@ skipping 485 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart