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

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 1638 matching lines @@
   InlineBailout("EffectGraphVisitor::VisitArgumentDefinitionTestNode");
   Definition* load = BuildLoadLocal(node->saved_arguments_descriptor());
   Value* arguments_descriptor = Bind(load);
   ArgumentDefinitionTestInstr* arg_def_test =
       new ArgumentDefinitionTestInstr(node, arguments_descriptor);
   ReturnDefinition(arg_def_test);
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  // Translate the array elements and collect their values.
-  ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new ZoneGrowableArray<PushArgumentInstr*>(node->length());
-  for (int i = 0; i < node->length(); ++i) {
-    ValueGraphVisitor for_value(owner(), temp_index());
-    node->ElementAt(i)->Visit(&for_value);
-    Append(for_value);
-    arguments->Add(PushArgument(for_value.value()));
-  }
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
-                                                  arguments,
+                                                  node->length(),
                                                   node->type(),
                                                   element_type);
-  ReturnDefinition(create);
+  Value* array_val = Bind(create);
+  Definition* store = BuildStoreTemp(node->temp_local(), array_val);
+  Do(store);
+
+  const intptr_t class_id = create->Type()->ToCid();
+  const intptr_t deopt_id = Isolate::kNoDeoptId;
+  for (int i = 0; i < node->length(); ++i) {
+    Value* array = Bind(
+        new LoadLocalInstr(node->temp_local(), owner()->context_level()));
+    Value* index = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(i))));
+    ValueGraphVisitor for_value(owner(), temp_index());
+    node->ElementAt(i)->Visit(&for_value);
+    Append(for_value);
+    // No store barrier needed for constants.
+    const bool emit_store_barrier = !for_value.value()->BindsToConstant();
+    StoreIndexedInstr* store = new StoreIndexedInstr(
+        array, index, for_value.value(),
+        emit_store_barrier, class_id, deopt_id);
+    Do(store);
+  }
+
+  ReturnDefinition(
+      new LoadLocalInstr(node->temp_local(), owner()->context_level()));
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   if (function.IsImplicitStaticClosureFunction()) {
     Instance& closure = Instance::ZoneHandle();
     closure ^= function.implicit_static_closure();
     if (closure.IsNull()) {
@@ skipping 1347 matching lines @@
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original method name.
   arguments->Add(new LiteralNode(args_pos, method_name));
   // The second argument is the arguments descriptor of the original method.
   const Array& args_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(method_arguments->length(),
                                                  method_arguments->names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original method arguments,
   // including the receiver.
-  ArrayNode* args_array =
-      new ArrayNode(args_pos, Type::ZoneHandle(Type::ArrayType()));
+  ArrayNode* args_array = new ArrayNode(
+      args_pos,
+      Type::ZoneHandle(Type::ArrayType()),
+      *owner()->parsed_function().array_literal_var());
   for (intptr_t i = 0; i < method_arguments->length(); i++) {
     args_array->AddElement(method_arguments->NodeAt(i));
   }
   arguments->Add(args_array);
   ZoneGrowableArray<PushArgumentInstr*>* allocation_args =
       new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
   BuildPushArguments(*arguments, allocation_args);
   StaticCallInstr* allocation = new StaticCallInstr(args_pos,
                                                     allocation_function,
                                                     Array::ZoneHandle(),
@@ skipping 171 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart