Change indexed load and store IL instructions to fit with SSA backend.

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/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2015 matching lines @@
                                        type,
                                        dst_name);
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
-  ValueGraphVisitor for_index(owner(), for_array.temp_index());
+  arguments->Add(PushArgument(for_array.value()));
+
+  ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
+  arguments->Add(PushArgument(for_index.value()));
 
-  LoadIndexedComp* load = new LoadIndexedComp(
-      node->token_pos(),
-      owner()->try_index(),
-      for_array.value(),
-      for_index.value());
+  const intptr_t checked_argument_count = 1;
+  const String& name =
+      String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
+  InstanceCallComp* load = new InstanceCallComp(node->token_pos(),
+                                                owner()->try_index(),
+                                                name,
+                                                Token::kINDEX,
+                                                arguments,
+                                                Array::ZoneHandle(),
+                                                checked_argument_count);
   ReturnComputation(load);
 }
 
 
-void EffectGraphVisitor::BuildStoreIndexedValues(
-    StoreIndexedNode* node, Value** array, Value** index, Value** value) {
+Computation* EffectGraphVisitor::BuildStoreIndexedValues(
+    StoreIndexedNode* node,
+    bool result_is_needed) {
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(3);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
-  ValueGraphVisitor for_index(owner(), for_array.temp_index());
+  arguments->Add(PushArgument(for_array.value()));
+
+  ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
-  ValueGraphVisitor for_value(owner(), for_index.temp_index());
+  arguments->Add(PushArgument(for_index.value()));
+
+  ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  *array = for_array.value();
-  *index = for_index.value();
-  *value = for_value.value();
+  Value* value = NULL;
+  if (result_is_needed) {
+    value = Bind(
+        BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
+                        for_value.value()));
+  } else {
+    value = for_value.value();
+  }
+  arguments->Add(PushArgument(value));
+
+  const intptr_t checked_argument_count = 1;
+  const String& name =
+      String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
+  InstanceCallComp* store = new InstanceCallComp(node->token_pos(),
+                                                 owner()->try_index(),
+                                                 name,
+                                                 Token::kASSIGN_INDEX,
+                                                 arguments,
+                                                 Array::ZoneHandle(),
+                                                 checked_argument_count);
+  if (result_is_needed) {
+    Do(store);
+    return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
+  } else {
+    return store;
+  }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Value *array, *index, *value;
-  BuildStoreIndexedValues(node, &array, &index, &value);
-  StoreIndexedComp* store = new StoreIndexedComp(node->token_pos(),
-                                                 owner()->try_index(),
-                                                 array,
-                                                 index,
-                                                 value);
-  ReturnComputation(store);
+  ReturnComputation(BuildStoreIndexedValues(node,
+                                            false));  // Result not needed.

[Vyacheslav Egorov (Google), 2012/08/15 13:16:09]

It's not the first place where we pass boolean as a resultnot needed indicator.
Consider instroducing enum and fixing all call sites to make them more readable.

[Florian Schneider, 2012/08/15 13:53:51]

Since there is only two very localized call-sites per helper in this case, I
don't see how an enum is much more readable.

 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Value *array, *index, *value;
-  BuildStoreIndexedValues(node, &array, &index, &value);
-  Value* saved_value = Bind(
-      BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
-                      value));
-  Do(new StoreIndexedComp(node->token_pos(),
-                          owner()->try_index(),
-                          array,
-                          index,
-                          saved_value));
-  ReturnComputation(
-       BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
+  ReturnComputation(BuildStoreIndexedValues(node,
+                                            true));  // Result is needed.
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
@@ skipping 719 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