Move String interpolation constant folding from constant propagator to canonicalizer

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
+#include "vm/il_printer.h"
+
 namespace dart {
 
 DEFINE_FLAG(int, max_equality_polymorphic_checks, 32,
     "Maximum number of polymorphic checks in equality operator,"
     " otherwise use megamorphic dispatch.");
 DEFINE_FLAG(bool, new_identity_spec, true,
     "Use new identity check rules for numbers.");
 DEFINE_FLAG(bool, propagate_ic_data, true,
     "Propagate IC data from unoptimized to optimized IC calls.");
 DECLARE_FLAG(bool, enable_type_checks);
@@ skipping 2657 matching lines @@
             Library::PrivateCoreLibName(Symbols::Interpolate()),
             kNumberOfArguments,
             kNoArgumentNames,
             Resolver::kIsQualified);
   }
   ASSERT(!function_.IsNull());
   return function_;
 }
 
 
+// Replace StringInterpolateInstr with a constant string if all inputs are
+// constant. Leave the CreateArrayInstr and StoreIndexedInstr in the
+// stream in case deoptimization occurs.
+Definition* StringInterpolateInstr::Canonicalize(FlowGraph* flow_graph) {
+  // The following graph structure is generated by the graph builder:
+  //   v2 <- CreateArray(v0)
+  //   StoreIndexed(v2, v3, v4)   -- v3:constant index, v4: value.
+  //   ..
+  //   v8 <- StringInterpolate(v2)
+  CreateArrayInstr* create_array = value()->definition()->AsCreateArray();
+  ASSERT(create_array != NULL);
+  // Check if the string interpolation has only constant inputs.
+  GrowableArray<ConstantInstr*> constants(create_array->num_elements());
+  for (intptr_t i = 0; i < create_array->num_elements(); i++) {
+    constants.Add(NULL);
+  }
+  for (Value::Iterator it(create_array->input_use_list());
+       !it.Done();
+       it.Advance()) {
+    Instruction* curr = it.Current()->instruction();
+    if (curr != this) {
+      StoreIndexedInstr* store = curr->AsStoreIndexed();
+      ASSERT(store != NULL);
+      if (store->value()->definition()->IsConstant()) {
+        ASSERT(store->index()->BindsToConstant());
+        constants[Smi::Cast(store->index()->BoundConstant()).Value()] =
+            store->value()->definition()->AsConstant();
+      } else {
+        return this;
+      }
+    }
+  }
+  // Interpolate string at compile time.
+  const Array& array_argument =
+      Array::Handle(Array::New(create_array->num_elements()));
+  for (intptr_t i = 0; i < constants.length(); i++) {
+    array_argument.SetAt(i, constants[i]->value());
+  }
+  // Build argument array to pass to the interpolation function.
+  const Array& interpolate_arg = Array::Handle(Array::New(1));
+  interpolate_arg.SetAt(0, array_argument);
+  // Call interpolation function.
+  String& concatenated = String::ZoneHandle();
+  concatenated ^=
+      DartEntry::InvokeFunction(CallFunction(), interpolate_arg);
+  if (concatenated.IsUnhandledException()) {
+    return this;

[Florian Schneider, 2013/10/23 17:32:39]

Please make sure that the case of an exception is also covered in the test.

[srdjan, 2013/10/23 20:39:02]

Changed the code to allow only numbers, strings, boolean and null constants.
This is the same as done in the parser and guarantees that no exception is
thrown and that toString has no side effect.

+  }
+  concatenated = Symbols::New(concatenated);
+  return flow_graph->GetConstant(concatenated);
+}
+
+
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
     ZoneGrowableArray<Value*>* inputs,
     intptr_t original_deopt_id,
     MethodRecognizer::Kind recognized_kind)
     : inputs_(inputs),
       locs_(NULL),
       recognized_kind_(recognized_kind) {
   ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
@@ skipping 91 matching lines @@
       return kCosRuntimeEntry;
     default:
       UNREACHABLE();
   }
   return kSinRuntimeEntry;
 }
 
 #undef __
 
 }  // namespace dart