Encode inlining information in CodeSourceMap and remove inlining interval arrays.

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 178 matching lines @@
       zone_(Thread::Current()->zone()),
       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),
       code_source_map_builder_(NULL),
-      saved_code_size_(0),
       block_info_(block_order_.length()),
       deopt_infos_(),
       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(isolate()->object_store()->float64x2_class())),
       int32x4_class_(
           Class::ZoneHandle(isolate()->object_store()->int32x4_class())),
       list_class_(Class::ZoneHandle(Library::Handle(Library::CoreLibrary())
                                         .LookupClass(Symbols::List()))),
       parallel_move_resolver_(this),
       pending_deoptimization_env_(NULL),
       deopt_id_to_ic_data_(NULL),
-      edge_counters_array_(Array::ZoneHandle()),
-      inlined_code_intervals_(Array::ZoneHandle(Object::empty_array().raw())),
-      inline_id_to_function_(inline_id_to_function),
-      inline_id_to_token_pos_(inline_id_to_token_pos),
-      caller_inline_id_(caller_inline_id) {
+      edge_counters_array_(Array::ZoneHandle()) {
   ASSERT(flow_graph->parsed_function().function().raw() ==
          parsed_function.function().raw());
   if (!is_optimizing) {
     const intptr_t len = thread()->deopt_id();
     deopt_id_to_ic_data_ = new (zone()) ZoneGrowableArray<const ICData*>(len);
     deopt_id_to_ic_data_->SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       (*deopt_id_to_ic_data_)[i] = NULL;
     }
     // TODO(fschneider): Abstract iteration into ICDataArrayIterator.
     const Array& old_saved_ic_data =
         Array::Handle(zone(), flow_graph->function().ic_data_array());
     const intptr_t saved_len =
         old_saved_ic_data.IsNull() ? 0 : old_saved_ic_data.Length();
     for (intptr_t i = 1; i < saved_len; i++) {
       ICData& ic_data = ICData::ZoneHandle(zone());
       ic_data ^= old_saved_ic_data.At(i);
       (*deopt_id_to_ic_data_)[ic_data.deopt_id()] = &ic_data;
     }
   }
   ASSERT(assembler != NULL);
   ASSERT(!list_class_.IsNull());
+
+  code_source_map_builder_ = new (zone_) CodeSourceMapBuilder(
+      caller_inline_id, inline_id_to_token_pos, inline_id_to_function);
 }
 
 
 bool FlowGraphCompiler::IsUnboxedField(const Field& field) {
   bool valid_class =
       (SupportsUnboxedDoubles() && (field.guarded_cid() == kDoubleCid)) ||
       (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat32x4Cid)) ||
       (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat64x2Cid));
   return field.is_unboxing_candidate() && !field.is_final() &&
          !field.is_nullable() && valid_class;
@@ skipping 199 matching lines @@
            !loop_it.Done(); loop_it.Advance()) {
         if (loop_it.Current() == block.preorder_number()) {
           assembler->Comment("  Loop %" Pd "", loop_id);
         }
       }
     }
   }
 }
 
 
-// We collect intervals while generating code.
-struct IntervalStruct {
-  // 'start' is the pc-offsets where the inlined code started.
-  // 'pos' is the token position where the inlined call occured.
-  intptr_t start;
-  TokenPosition pos;
-  intptr_t inlining_id;
-  IntervalStruct(intptr_t s, TokenPosition tp, intptr_t id)
-      : start(s), pos(tp), inlining_id(id) {}
-  void Dump() {
-    THR_Print("start: 0x%" Px " iid: %" Pd " pos: %s", start, inlining_id,
-              pos.ToCString());
-  }
-};
-
-
 void FlowGraphCompiler::VisitBlocks() {
   CompactBlocks();
   const ZoneGrowableArray<BlockEntryInstr*>* loop_headers = NULL;
   if (Assembler::EmittingComments()) {
     // 'loop_headers' were cleared, recompute.
     loop_headers = flow_graph().ComputeLoops();
     ASSERT(loop_headers != NULL);
   }
 
-  // For collecting intervals of inlined code.
-  GrowableArray<IntervalStruct> intervals;
-  intptr_t prev_offset = 0;
-  intptr_t prev_inlining_id = 0;
-  TokenPosition prev_inlining_pos = parsed_function_.function().token_pos();
-  intptr_t max_inlining_id = 0;
   for (intptr_t i = 0; i < block_order().length(); ++i) {
     // Compile the block entry.
     BlockEntryInstr* entry = block_order()[i];
     assembler()->Comment("B%" Pd "", entry->block_id());
     set_current_block(entry);
 
     if (WasCompacted(entry)) {
       continue;
     }
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
     if (!is_optimizing()) {
       FrameStateClear();
     }
 #endif
 
     LoopInfoComment(assembler(), *entry, *loop_headers);
 
     entry->set_offset(assembler()->CodeSize());
     BeginCodeSourceRange();
     ASSERT(pending_deoptimization_env_ == NULL);
     pending_deoptimization_env_ = entry->env();
     entry->EmitNativeCode(this);
     pending_deoptimization_env_ = NULL;
     EndCodeSourceRange(entry->token_pos());
     // Compile all successors until an exit, branch, or a block entry.
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       // Compose intervals.
-      if (instr->has_inlining_id() && is_optimizing()) {
-        if (prev_inlining_id != instr->inlining_id()) {
-          intervals.Add(
-              IntervalStruct(prev_offset, prev_inlining_pos, prev_inlining_id));
-          prev_offset = assembler()->CodeSize();
-          prev_inlining_id = instr->inlining_id();
-          if (prev_inlining_id < inline_id_to_token_pos_.length()) {
-            prev_inlining_pos = inline_id_to_token_pos_[prev_inlining_id];
-          } else {
-            // We will add this token position later when generating the
-            // profile.
-            prev_inlining_pos = TokenPosition::kNoSource;
-          }
-          if (prev_inlining_id > max_inlining_id) {
-            max_inlining_id = prev_inlining_id;
-          }
-        }
-      }
+      code_source_map_builder_->StartInliningInterval(assembler()->CodeSize(),
+                                                      instr->inlining_id());
       if (FLAG_code_comments || FLAG_disassemble ||
           FLAG_disassemble_optimized) {
         if (FLAG_source_lines) {
           EmitSourceLine(instr);
         }
         EmitComment(instr);
       }
       if (instr->IsParallelMove()) {
         parallel_move_resolver_.EmitNativeCode(instr->AsParallelMove());
       } else {
@@ skipping 12 matching lines @@
         FrameStateUpdateWith(instr);
       }
 #endif
     }
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
     ASSERT(is_optimizing() || FrameStateIsSafeToCall());
 #endif
   }
 
-  if (is_optimizing()) {
-    LogBlock lb;
-    intervals.Add(
-        IntervalStruct(prev_offset, prev_inlining_pos, prev_inlining_id));
-    inlined_code_intervals_ =
-        Array::New(intervals.length() * Code::kInlIntNumEntries, Heap::kOld);
-    Smi& start_h = Smi::Handle();
-    Smi& caller_inline_id = Smi::Handle();
-    Smi& inline_id = Smi::Handle();
-    for (intptr_t i = 0; i < intervals.length(); i++) {
-      if (FLAG_trace_inlining_intervals && is_optimizing()) {
-        const Function& function =
-            *inline_id_to_function_.At(intervals[i].inlining_id);
-        intervals[i].Dump();
-        THR_Print(" parent iid %" Pd " %s\n",
-                  caller_inline_id_[intervals[i].inlining_id],
-                  function.ToQualifiedCString());
-      }
-
-      const intptr_t id = intervals[i].inlining_id;
-      start_h = Smi::New(intervals[i].start);
-      inline_id = Smi::New(id);
-      caller_inline_id = Smi::New(caller_inline_id_[intervals[i].inlining_id]);
-
-      const intptr_t p = i * Code::kInlIntNumEntries;
-      inlined_code_intervals_.SetAt(p + Code::kInlIntStart, start_h);
-      inlined_code_intervals_.SetAt(p + Code::kInlIntInliningId, inline_id);
-    }
-  }
   set_current_block(NULL);
-  if (FLAG_trace_inlining_intervals && is_optimizing()) {
-    LogBlock lb;
-    THR_Print("Intervals:\n");
-    for (intptr_t cc = 0; cc < caller_inline_id_.length(); cc++) {
-      THR_Print("  iid: %" Pd " caller iid: %" Pd "\n", cc,
-                caller_inline_id_[cc]);
-    }
-    Smi& temp = Smi::Handle();
-    for (intptr_t i = 0; i < inlined_code_intervals_.Length();
-         i += Code::kInlIntNumEntries) {
-      temp ^= inlined_code_intervals_.At(i + Code::kInlIntStart);
-      ASSERT(!temp.IsNull());
-      THR_Print("% " Pd " start: 0x%" Px " ", i, temp.Value());
-      temp ^= inlined_code_intervals_.At(i + Code::kInlIntInliningId);
-      THR_Print("iid: %" Pd " ", temp.Value());
-    }
-  }
 }
 
 
 void FlowGraphCompiler::Bailout(const char* reason) {
   parsed_function_.Bailout("FlowGraphCompiler", reason);
 }
 
 
 void FlowGraphCompiler::EmitTrySync(Instruction* instr, intptr_t try_index) {
   ASSERT(is_optimizing());
@@ skipping 472 matching lines @@
       targets.SetAt(target_ix + Code::kSCallTableCodeEntry,
                     *static_calls_target_table_[i]->code);
     }
   }
   code.set_static_calls_target_table(targets);
   INC_STAT(Thread::Current(), total_code_size,
            targets.Length() * sizeof(uword));
 }
 
 
+void FlowGraphCompiler::FinalizeCodeSourceMap(const Code& code) {
+#ifdef PRODUCT
+// This data is only used by the profiler.
+#else
+  if (FLAG_precompiled_mode) {
+    // TODO(rmacnak): Include a filtered verion of this to produce stack traces
+    // with inlined frames.
+    return;
+  }
+
+  const Array& inlined_id_array =
+      Array::Handle(zone(), code_source_map_builder_->InliningIdToFunction());
+  INC_STAT(Thread::Current(), total_code_size,
+           inlined_id_array.Length() * sizeof(uword));
+  code.set_inlined_id_to_function(inlined_id_array);
+
+  const CodeSourceMap& map =
+      CodeSourceMap::Handle(code_source_map_builder_->Finalize());
+  INC_STAT(Thread::Current(), total_code_size, map.Length() * sizeof(uint8_t));
+  code.set_code_source_map(map);
+#endif
+
+#if defined(DEBUG)
+  // Force simulation through the last pc offset.

[Cutch, 2017/02/07 17:14:24]

what is this doing?

[rmacnak, 2017/02/07 18:04:13]

This checks we can decode the CodeSourceMap. E.g., simulate to the end without
hitting an unknown opcode, stack underflow, etc.

+  GrowableArray<const Function*> fs;
+  GrowableArray<TokenPosition> tokens;
+  code.GetInlinedFunctionsAt(code.Size() - 1, &fs, &tokens);
+#endif
+}
+
+
 // Returns 'true' if regular code generation should be skipped.
 bool FlowGraphCompiler::TryIntrinsify() {
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
   if (FLAG_intrinsify && !isolate()->type_checks()) {
     const Class& owner = Class::Handle(parsed_function().function().Owner());
     String& name = String::Handle(parsed_function().function().name());
 
     if (parsed_function().function().kind() == RawFunction::kImplicitGetter) {
       // TODO(27590) Store Field object inside RawFunction::data_ if possible.
@@ skipping 656 matching lines @@
       return int32x4_class();
     case kUnboxedMint:
       return mint_class();
     default:
       UNREACHABLE();
       return Class::ZoneHandle();
   }
 }
 
 
-RawArray* FlowGraphCompiler::InliningIdToFunction() const {
-  if (inline_id_to_function_.length() == 0) {
-    return Object::empty_array().raw();
-  }
-  const Array& res =
-      Array::Handle(Array::New(inline_id_to_function_.length(), Heap::kOld));
-  for (intptr_t i = 0; i < inline_id_to_function_.length(); i++) {
-    res.SetAt(i, *inline_id_to_function_[i]);
-  }
-  return res.raw();
-}
-
-
-RawArray* FlowGraphCompiler::InliningIdToTokenPos() const {
-  if (inline_id_to_token_pos_.length() == 0) {
-    return Object::empty_array().raw();
-  }
-  const Array& res = Array::Handle(
-      zone(), Array::New(inline_id_to_token_pos_.length(), Heap::kOld));
-  Smi& smi = Smi::Handle(zone());
-  for (intptr_t i = 0; i < inline_id_to_token_pos_.length(); i++) {
-    smi = Smi::New(inline_id_to_token_pos_[i].value());
-    res.SetAt(i, smi);
-  }
-  return res.raw();
-}
-
-
-RawArray* FlowGraphCompiler::CallerInliningIdMap() const {
-  if (caller_inline_id_.length() == 0) {
-    return Object::empty_array().raw();
-  }
-  const Array& res =
-      Array::Handle(Array::New(caller_inline_id_.length(), Heap::kOld));
-  Smi& smi = Smi::Handle();
-  for (intptr_t i = 0; i < caller_inline_id_.length(); i++) {
-    smi = Smi::New(caller_inline_id_[i]);
-    res.SetAt(i, smi);
-  }
-  return res.raw();
-}
-
-
 void FlowGraphCompiler::BeginCodeSourceRange() {
-#if !defined(PRODUCT)
-  // Remember how many bytes of code we emitted so far. This function
-  // is called before we call into an instruction's EmitNativeCode.
-  saved_code_size_ = assembler()->CodeSize();
-#endif  // !defined(PRODUCT)
+  code_source_map_builder_->BeginCodeSourceRange(assembler()->CodeSize());
 }
 
 
-bool FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
-#if !defined(PRODUCT)
-  // This function is called after each instructions' EmitNativeCode.
-  if (saved_code_size_ < assembler()->CodeSize()) {
-    // We emitted more code, now associate the emitted code chunk with
-    // |token_pos|.
-    code_source_map_builder()->AddEntry(saved_code_size_, token_pos);
-    BeginCodeSourceRange();
-    return true;
-  }
-#endif  // !defined(PRODUCT)
-  return false;
+void FlowGraphCompiler::EndCodeSourceRange(TokenPosition token_pos) {
+  code_source_map_builder_->EndCodeSourceRange(assembler()->CodeSize(),
+                                               token_pos);
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 // DBC emits calls very differently from other architectures due to its
 // interpreted nature.
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(const ICData& ic_data,
                                                     intptr_t argument_count,
                                                     const Array& argument_names,
                                                     intptr_t deopt_id,
@@ skipping 94 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart