Use zone allocated growable array to populate interim static and stub calls table, thus allocating …

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 156 matching lines @@
         assembler_(assembler),
         parsed_function_(parsed_function),
         flow_graph_(*flow_graph),
         block_order_(*flow_graph->CodegenBlockOrder(is_optimizing)),
         current_block_(NULL),
         exception_handlers_list_(NULL),
         pc_descriptors_list_(NULL),
         stackmap_table_builder_(NULL),
         block_info_(block_order_.length()),
         deopt_infos_(),
-        static_calls_target_table_(GrowableObjectArray::ZoneHandle(
-            GrowableObjectArray::New())),
+        static_calls_target_table_(),
         is_optimizing_(is_optimizing),
         may_reoptimize_(false),
         intrinsic_mode_(false),
         double_class_(Class::ZoneHandle(
             isolate_->object_store()->double_class())),
         mint_class_(Class::ZoneHandle(
             isolate_->object_store()->mint_class())),
         float32x4_class_(Class::ZoneHandle(
             isolate_->object_store()->float32x4_class())),
         float64x2_class_(Class::ZoneHandle(
@@ skipping 521 matching lines @@
   if (!CanOptimize() && (kind == RawPcDescriptors::kDeopt)) return;
   pc_descriptors_list()->AddDescriptor(kind,
                                        assembler()->CodeSize(),
                                        deopt_id,
                                        token_pos,
                                        CurrentTryIndex());
 }
 
 
 void FlowGraphCompiler::AddStaticCallTarget(const Function& func) {
-  ASSERT(Code::kSCallTableEntryLength == 3);
-  ASSERT(Code::kSCallTableOffsetEntry == 0);
+  ASSERT(func.IsZoneHandle());
   static_calls_target_table_.Add(
-      Smi::Handle(Smi::New(assembler()->CodeSize())));
-  ASSERT(Code::kSCallTableFunctionEntry == 1);
-  static_calls_target_table_.Add(func);
-  ASSERT(Code::kSCallTableCodeEntry == 2);
-  static_calls_target_table_.Add(Code::Handle());
+      StaticCallsStruct(assembler()->CodeSize(),
+                        &func,
+                        &Code::ZoneHandle(zone())));
 }
 
 
 void FlowGraphCompiler::AddStubCallTarget(const Code& code) {
-  ASSERT(Code::kSCallTableEntryLength == 3);
-  ASSERT(Code::kSCallTableOffsetEntry == 0);
+  ASSERT(code.IsZoneHandle());
   static_calls_target_table_.Add(
-      Smi::Handle(Smi::New(assembler()->CodeSize())));
-  ASSERT(Code::kSCallTableFunctionEntry == 1);
-  static_calls_target_table_.Add(Function::Handle());
-  ASSERT(Code::kSCallTableCodeEntry == 2);
-  static_calls_target_table_.Add(code);
+      StaticCallsStruct(assembler()->CodeSize(),
+                        &Function::ZoneHandle(zone()),

[koda, 2015/08/20 14:14:14]

As I understand it, exactly one of the 'code' and 'function' of each struct
instance is used, while the unused one remains a handle containing null. So,
it's basically a union, right?

If so, then you could easily avoid some redundant handle allocation by storing a
(C++) NULL instead, and skip those when finalizing the array (and preferably
also ASSERT that exactly one of them is NULL). Although allocating handles is
fairly cheap, the GC might need to traverse them, etc.

(Of course, you could go even further and try to make it an actual union with a
tag bit somewhere, but that seems like overkill.)

[srdjan, 2015/08/20 16:25:39]

Using (C++) NULL instead of creating Null handles.

+                        &code));
 }
 
 
 void FlowGraphCompiler::AddDeoptIndexAtCall(intptr_t deopt_id,
                                             intptr_t token_pos) {
   ASSERT(is_optimizing());
   ASSERT(!intrinsic_mode());
   CompilerDeoptInfo* info =
       new CompilerDeoptInfo(deopt_id,
                             ICData::kDeoptAtCall,
@@ skipping 243 matching lines @@
     info.end_pos = 0;
     info.set_index(parsed_function().current_context_var()->index());
     var_descs.SetVar(0, Symbols::CurrentContextVar(), &info);
   }
   code.set_var_descriptors(var_descs);
 }
 
 
 void FlowGraphCompiler::FinalizeStaticCallTargetsTable(const Code& code) {
   ASSERT(code.static_calls_target_table() == Array::null());
-  const Array& targets =
-      Array::Handle(Array::MakeArray(static_calls_target_table_));
+  const Array& targets = Array::Handle(zone(), Array::New(
+      static_calls_target_table_.length() * Code::kSCallTableEntryLength));
+  Smi& smi_offset = Smi::Handle(zone());
+  for (intptr_t i = 0; i < static_calls_target_table_.length(); i++) {
+    const intptr_t target_ix = Code::kSCallTableEntryLength * i;
+    smi_offset = Smi::New(static_calls_target_table_[i].offset);
+    targets.SetAt(target_ix + Code::kSCallTableOffsetEntry, smi_offset);
+    targets.SetAt(target_ix + Code::kSCallTableFunctionEntry,
+        *static_calls_target_table_[i].function);
+    targets.SetAt(target_ix + Code::kSCallTableCodeEntry,
+        *static_calls_target_table_[i].code);
+  }
   code.set_static_calls_target_table(targets);
   INC_STAT(isolate(), total_code_size, targets.Length() * sizeof(uword));
 }
 
 
 // Returns 'true' if code generation for this function is complete, i.e.,
 // no fall-through to regular code is needed.
 void FlowGraphCompiler::TryIntrinsify() {
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
@@ skipping 803 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart