Share ic data between unoptimized and optimized static calls.

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 2318 matching lines @@
 }
 
 
 LocationSummary* StaticCallInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool optimizing) const {
   return MakeCallSummary();
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ICData& call_ic_data = ICData::ZoneHandle(ic_data()->raw());
+  if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
+    const Array& arguments_descriptor =
+        Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
+                                               argument_names()));
+    // TODO(srdjan): Improve performance of function recognition.
+    MethodRecognizer::Kind recognized_kind =
+        MethodRecognizer::RecognizeKind(function());
+    int num_args_checked = 0;
+    if ((recognized_kind == MethodRecognizer::kMathMin) ||
+        (recognized_kind == MethodRecognizer::kMathMax)) {
+      num_args_checked = 2;
+    }
+    call_ic_data = ICData::New(compiler->parsed_function().function(),
+                               String::Handle(function().name()),
+                               arguments_descriptor,
+                               deopt_id(),
+                               num_args_checked);  // No arguments checked.
+    call_ic_data.AddTarget(function());
+  }
   if (!compiler->is_optimizing()) {
     // Some static calls can be optimized by the optimizing compiler (e.g. sqrt)
     // and therefore need a deoptimization descriptor.
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id(),
                                    token_pos());
   }
   compiler->GenerateStaticCall(deopt_id(),
                                token_pos(),
                                function(),
                                ArgumentCount(),
                                argument_names(),
-                               locs());
+                               locs(),
+                               call_ic_data);
 }
 
 
 void AssertAssignableInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateAssertAssignable(token_pos(),
                                      deopt_id(),
                                      dst_type(),
                                      dst_name(),
                                      locs());
   ASSERT(locs()->in(0).reg() == locs()->out(0).reg());
@@ skipping 1107 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart