Add deopt info to code object and print it

runtime/vm/flow_graph_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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
+#include "vm/deopt_instructions.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(bool, trace_functions);
 DECLARE_FLAG(int, optimization_counter_threshold);
 
+RawDeoptInfo* DeoptimizationStub::CreateDeoptInfo(FlowGraphCompiler* compiler) {
+  if (deoptimization_env_ == NULL) return DeoptInfo::null();
+  const intptr_t fixed_parameter_count =
+      deoptimization_env_->fixed_parameter_count();
+  DeoptInfoBuilder builder(compiler->object_table(), fixed_parameter_count);
+
+  const Function& function = compiler->parsed_function().function();
+  intptr_t slot_ix = 0;
+  builder.AddReturnAddress(function, deopt_id_, slot_ix++);
+
+  // All locals between TOS and PC-marker.
+  const GrowableArray<Value*>& values = deoptimization_env_->values();
+  // const intptr_t local_slot_count = values.length() - fixed_parameter_count;
+  for (intptr_t i = values.length() - 1; i >= fixed_parameter_count; i--) {
+    builder.AddCopy(deoptimization_env_->LocationAt(i), *values[i], slot_ix++);
+  }
+
+  // PC marker, caller-fp, caller-pc.
+  builder.AddPcMarker(function, slot_ix++);
+  builder.AddCallerFp(slot_ix++);
+  builder.AddCallerPc(slot_ix++);
+  // Incoming arguments.
+  for (intptr_t i = fixed_parameter_count - 1; i >= 0; i--) {
+    builder.AddCopy(deoptimization_env_->LocationAt(i), *values[i], slot_ix++);
+  }
+
+  const DeoptInfo& deopt_info = DeoptInfo::Handle(builder.CreateDeoptInfo());
+  return deopt_info.raw();
+}
+
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     const ParsedFunction& parsed_function,
     const GrowableArray<BlockEntryInstr*>& block_order,
     bool is_optimizing,
     bool is_ssa,
     bool is_leaf)
     : assembler_(assembler),
       parsed_function_(parsed_function),
       block_order_(block_order),
       current_block_(NULL),
       exception_handlers_list_(NULL),
       pc_descriptors_list_(NULL),
       stackmap_table_builder_(NULL),
       block_info_(block_order.length()),
       deopt_stubs_(),
+      object_table_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
       is_optimizing_(is_optimizing),
       is_ssa_(is_ssa),
       is_dart_leaf_(is_leaf),
       bool_true_(Bool::ZoneHandle(Bool::True())),
       bool_false_(Bool::ZoneHandle(Bool::False())),
       double_class_(Class::ZoneHandle(
           Isolate::Current()->object_store()->double_class())),
       frame_register_allocator_(this, is_optimizing, is_ssa),
       parallel_move_resolver_(this) {
   ASSERT(assembler != NULL);
@@ skipping 100 matching lines @@
 
 bool FlowGraphCompiler::IsNextBlock(BlockEntryInstr* block_entry) const {
   intptr_t current_index = reverse_index(current_block()->postorder_number());
   return (current_index < (block_order().length() - 1)) &&
       (block_order()[current_index + 1] == block_entry);
 }
 
 
 void FlowGraphCompiler::GenerateDeferredCode() {
   for (intptr_t i = 0; i < deopt_stubs_.length(); i++) {
-    deopt_stubs_[i]->GenerateCode(this);
+    deopt_stubs_[i]->GenerateCode(this, i);
   }
 }
 
 
 void FlowGraphCompiler::AddExceptionHandler(intptr_t try_index,
                                             intptr_t pc_offset) {
   exception_handlers_list_->AddHandler(try_index, pc_offset);
 }
 
 
@@ skipping 46 matching lines @@
 
 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
   ASSERT(pc_descriptors_list_ != NULL);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
   descriptors.Verify(parsed_function_.function().is_optimizable());
   code.set_pc_descriptors(descriptors);
 }
 
 
+void FlowGraphCompiler::FinalizeDeoptInfo(const Code& code) {
+  const Array& array =
+      Array::Handle(Array::New(deopt_stubs_.length(), Heap::kOld));
+  DeoptInfo& info = DeoptInfo::Handle();
+  for (intptr_t i = 0; i < deopt_stubs_.length(); i++) {
+    info = deopt_stubs_[i]->CreateDeoptInfo(this);
+    array.SetAt(i, info);
+  }
+  code.set_deopt_info_array(array);
+  const Array& object_array = Array::Handle(Array::MakeArray(object_table_));
+  code.set_object_table(object_array);
+}
+
+
 void FlowGraphCompiler::FinalizeStackmaps(const Code& code) {
   if (stackmap_table_builder_ == NULL) {
     // The unoptimizing compiler has no stack maps.
     code.set_stackmaps(Array::Handle());
   } else {
     // Finalize the stack map array and add it to the code object.
     code.set_stackmaps(
         Array::Handle(stackmap_table_builder_->FinalizeStackmaps(code)));
   }
 }
@@ skipping 556 matching lines @@
       return;
     }
   }
 
   // This move is not blocked.
   EmitMove(index);
 }
 
 
 }  // namespace dart