Do not inline List factory if a non-constant argument is passed in order to prevent non-optimal cod…

runtime/vm/flow_graph_inliner.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/flow_graph_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 626 matching lines @@
         return parsed_function;
       }
     }
     *in_cache = false;
     ParsedFunction* parsed_function = new ParsedFunction(function);
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
     return parsed_function;
   }
 
+  // Include special handling for List. factory: inlining it is not helpful
+  // if the incoming argument is a non-constant value.
+  // TODO(srdjan): Fix inlining of  List. factory.

[Ivan Posva, 2013/02/28 23:22:31]

Two spaces between of and List.

[srdjan, 2013/02/28 23:31:01]

Done.

   void InlineStaticCalls() {
     const GrowableArray<StaticCallInstr*>& calls =
         inlining_call_sites_->static_calls();
     TRACE_INLINING(OS::Print("  Static Calls (%d)\n", calls.length()));
     for (intptr_t i = 0; i < calls.length(); ++i) {
       StaticCallInstr* call = calls[i];
+      if (call->function().name() == Symbols::ListFactory().raw()) {
+        // Inline only if no arguments or a constant was passed.
+        ASSERT(call->function().NumImplicitParameters() == 1);
+        ASSERT(call->ArgumentCount() <= 2);
+        // Arg 0: Instantiator type arguments.
+        // Arg 1: Length (optional).
+        if ((call->ArgumentCount() == 2) &&
+            (!call->PushArgumentAt(1)->value()->BindsToConstant())) {
+          // Do not inline since a non-constant argument was passed.
+          continue;
+        }
+      }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
       TryInlining(call->function(), call->argument_names(), &arguments, call);
     }
   }
 
   void InlineClosureCalls() {
     const GrowableArray<ClosureCallInstr*>& calls =
@@ skipping 205 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart