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(
+      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