First part of static call cleanup: store static call targets into code object, referenced by code-o…

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"
@@ skipping 126 matching lines @@
     : assembler_(assembler),
       parsed_function_(flow_graph.parsed_function()),
       block_order_(flow_graph.reverse_postorder()),
       current_block_(NULL),
       exception_handlers_list_(NULL),
       pc_descriptors_list_(NULL),
       stackmap_table_builder_(
           is_optimizing ? new StackmapTableBuilder() : NULL),
       block_info_(block_order_.length()),
       deopt_infos_(),
+      static_calls_target_table_(GrowableObjectArray::ZoneHandle(
+          GrowableObjectArray::New())),
       is_optimizing_(is_optimizing),
       may_reoptimize_(false),
       bool_true_(Bool::ZoneHandle(Bool::True())),
       bool_false_(Bool::ZoneHandle(Bool::False())),
       double_class_(Class::ZoneHandle(
           Isolate::Current()->object_store()->double_class())),
       parallel_move_resolver_(this) {
   ASSERT(assembler != NULL);
 }
 
@@ skipping 118 matching lines @@
                                              intptr_t deopt_id,
                                              intptr_t token_pos) {
   pc_descriptors_list()->AddDescriptor(kind,
                                        assembler()->CodeSize(),
                                        deopt_id,
                                        token_pos,
                                        CurrentTryIndex());
 }
 
 
+void FlowGraphCompiler::AddStaticCallTarget(const Function& func) {
+  static_calls_target_table_.Add(
+      Smi::Handle(Smi::New(assembler()->CodeSize())));
+  static_calls_target_table_.Add(func);
+}
+
+
 void FlowGraphCompiler::AddDeoptIndexAtCall(intptr_t deopt_id,
                                             intptr_t token_pos) {
   ASSERT(is_optimizing());
   CompilerDeoptInfo* info = new CompilerDeoptInfo(deopt_id, kDeoptAtCall);
   ASSERT(pending_deoptimization_env_ != NULL);
   info->set_deoptimization_env(pending_deoptimization_env_);
   info->set_pc_offset(assembler()->CodeSize());
   deopt_infos_.Add(info);
 }
 
@@ skipping 94 matching lines @@
   Smi& reason = Smi::Handle();
   for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
     offset = Smi::New(deopt_infos_[i]->pc_offset());
     info = deopt_infos_[i]->CreateDeoptInfo(this, &builder);
     reason = Smi::New(deopt_infos_[i]->reason());
     DeoptTable::SetEntry(array, i, offset, info, reason);
   }
   code.set_deopt_info_array(array);
   const Array& object_array =
       Array::Handle(Array::MakeArray(builder.object_table()));
+  ASSERT(code.object_table() == Array::null());
   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.
@@ skipping 10 matching lines @@
               parsed_function_.function()));
   code.set_var_descriptors(var_descs);
 }
 
 
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
   code.set_comments(assembler()->GetCodeComments());
 }
 
 
+void FlowGraphCompiler::FinalizeStaticCallTargetsTable(const Code& code) {

[siva, 2012/11/16 23:15:23]

ASSERT(code.static_calls_target_table() == Array::null());

[srdjan, 2012/11/17 00:47:24]

Done.

+  code.set_static_calls_target_table(
+      Array::Handle(Array::MakeArray(static_calls_target_table_)));
+}
+
+
 // Returns 'true' if code generation for this function is complete, i.e.,
 // no fall-through to regular code is needed.
 bool FlowGraphCompiler::TryIntrinsify() {
   if (!CanOptimize()) return false;
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
   if (FLAG_intrinsify && !FLAG_enable_type_checks) {
     if (parsed_function().function().kind() == RawFunction::kImplicitGetter) {
       // An implicit getter must have a specific AST structure.
       const SequenceNode& sequence_node = *parsed_function().node_sequence();
@@ skipping 511 matching lines @@
       ASSERT(Utils::IsInt(31, disp));
       return FieldAddress(array, disp);
     }
     default:
       UNIMPLEMENTED();
       return FieldAddress(SPREG, 0);
   }
 }
 
 }  // namespace dart