Save ICData of unoptimized code in the function, thus preserving it across repated unoptimized comp…

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 223 matching lines @@
     Error& error = Error::Handle(isolate);
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
+static RawArray* ComputeICDataArray(const Function& function) {

[Cutch, 2014/06/16 21:39:42]

Maybe, make this a method on Function and call it RestoreICData to mirror
SaveICData.

[srdjan, 2014/06/16 21:58:08]

Yes: SaveICDataMap and RestoreICDataMap.

+  const Array& saved_icd = Array::Handle(function.ic_data_array());
+  if (saved_icd.Length() == 0) {
+    return Array::empty_array().raw();
+  }
+  ICData& icd = ICData::Handle();
+  icd ^= saved_icd.At(saved_icd.Length() - 1);
+  const Array& result = Array::Handle(Array::New(icd.deopt_id() + 1));
+  for (intptr_t i = 0; i < saved_icd.Length(); i++) {
+    icd ^= saved_icd.At(i);
+    result.SetAt(icd.deopt_id(), icd);
+  }
+  return result.raw();
+}
+
+
 // Return false if bailed out.
 static bool CompileParsedFunctionHelper(ParsedFunction* parsed_function,
                                         bool optimized,
                                         intptr_t osr_id) {
   const Function& function = parsed_function->function();
   if (optimized && !function.IsOptimizable()) {
     return false;
   }
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
@@ skipping 22 matching lines @@
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphbuilder_timer,
                          isolate);
         Array& ic_data_array = Array::Handle();
         if (optimized) {
           ASSERT(function.HasCode());
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
           ASSERT(function.deoptimization_counter() <
                  FLAG_deoptimization_counter_threshold);
-          const Code& unoptimized_code =
-              Code::Handle(function.unoptimized_code());
-          ic_data_array = unoptimized_code.ExtractTypeFeedbackArray();
+          ic_data_array = ComputeICDataArray(function);
         }
 
         // Build the flow graph.
         FlowGraphBuilder builder(parsed_function,
                                  ic_data_array,
                                  NULL,  // NULL = not inlining.
                                  osr_id,
                                  optimized);
         flow_graph = builder.BuildGraph();
       }
@@ skipping 270 matching lines @@
             }
           }
           function.AttachCode(code);
 
           for (intptr_t i = 0;
                i < flow_graph->guarded_fields()->length();
                i++) {
             const Field* field = (*flow_graph->guarded_fields())[i];
             field->RegisterDependentCode(code);
           }
-        } else {
+        } else {  // not optimized.
+          if (function.ic_data_array() == Array::null()) {
+            function.SetSavedICData(graph_compiler.deopt_id_to_ic_data());
+          }
           function.set_unoptimized_code(code);
           function.AttachCode(code);
           ASSERT(CodePatcher::CodeIsPatchable(code));
         }
         if (parsed_function->HasDeferredPrefixes()) {
           ZoneGrowableArray<const LibraryPrefix*>* prefixes =
               parsed_function->deferred_prefixes();
           for (intptr_t i = 0; i < prefixes->length(); i++) {
             (*prefixes)[i]->RegisterDependentCode(code);
           }
@@ skipping 170 matching lines @@
 static RawError* CompileFunctionHelper(const Function& function,
                                        bool optimized,
                                        intptr_t osr_id) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(isolate, time_compilation);
     Timer per_compile_timer(FLAG_trace_compiler, "Compilation time");
     per_compile_timer.Start();
-    ParsedFunction* parsed_function = new ParsedFunction(
+    ParsedFunction* parsed_function = new(isolate) ParsedFunction(
         isolate, Function::ZoneHandle(isolate, function.raw()));
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %s%sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
                 (osr_id == Isolate::kNoDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos(),
                 (function.end_token_pos() - function.token_pos()));
     }
     {
@@ skipping 196 matching lines @@
     const Object& result =
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart