Don't inline recursive calls.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 10 matching lines @@
 DEFINE_FLAG(charp, inlining_filter, NULL, "Inline only in named function");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (FLAG_trace_inlining) statement;                                        \
   } while (false)
 
 
+// Test if a call is recursive by looking in the deoptimization environment.
+static bool IsCallRecursive(const Function& function, Definition* call) {
+  Environment* env = call->env();
+  while (env != NULL) {
+    if (function.raw() == env->function().raw()) return true;
+    env = env->outer();
+  }
+  return false;
+}
+
+
 class CallSiteInliner : public FlowGraphVisitor {
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : FlowGraphVisitor(flow_graph->postorder()),
         caller_graph_(flow_graph),
         next_ssa_temp_index_(flow_graph->max_virtual_register_number()),
         inlined_(false) { }
 
   bool TryInlining(const Function& function,
                    GrowableArray<Value*>* arguments,
                    Definition* call) {
     TRACE_INLINING(OS::Print("  => %s\n", function.ToCString()));
 
     // Abort if the inlinable bit on the function is low.
     if (!function.is_inlinable()) {
       TRACE_INLINING(OS::Print("     Bailout: not inlinable\n"));
       return false;
     }
 
     // Abort if the callee has optional parameters.
     if (function.HasOptionalParameters()) {
       TRACE_INLINING(OS::Print("     Bailout: optional parameters\n"));
       return false;
     }
 
     // Assuming no optional parameters the actual/formal count should match.
     ASSERT(arguments->length() == function.num_fixed_parameters());
 
+    // Abort if this is a recursive occurrence.
+    if (IsCallRecursive(function, call)) {
+      function.set_is_inlinable(false);
+      TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
+      return false;
+    }
+
     // Abort if the callee has an intrinsic translation.
     if (Intrinsifier::CanIntrinsify(function)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: can intrinsify\n"));
       return false;
     }
 
     Isolate* isolate = Isolate::Current();
     // Save and clear IC data.
     const Array& prev_ic_data = Array::Handle(isolate->ic_data_array());
@@ skipping 184 matching lines @@
     if (FLAG_trace_inlining && FLAG_print_flow_graph) {
       OS::Print("After Inlining of %s\n", flow_graph_->
                 parsed_function().function().ToFullyQualifiedCString());
       FlowGraphPrinter printer(*flow_graph_);
       printer.PrintBlocks();
     }
   }
 }
 
 }  // namespace dart