Build CodeSourceMap for each code object

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 183 matching lines @@
       : thread_(Thread::Current()),
         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())),
@@ skipping 310 matching lines @@
 
 #if defined(DEBUG)
     if (!is_optimizing()) {
       FrameStateClear();
     }
 #endif
 
     LoopInfoComment(assembler(), *entry, *loop_headers);
 
     entry->set_offset(assembler()->CodeSize());
+    SaveCodeSize();
     entry->EmitNativeCode(this);
+    MaybeEmitCodeSourceMapEntry(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_id));
           prev_offset = assembler()->CodeSize();
           prev_inlining_id = instr->inlining_id();
           if (prev_inlining_id > max_inlining_id) {
             max_inlining_id = prev_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 {
+        SaveCodeSize();
         EmitInstructionPrologue(instr);
         ASSERT(pending_deoptimization_env_ == NULL);
         pending_deoptimization_env_ = instr->env();
         instr->EmitNativeCode(this);
         pending_deoptimization_env_ = NULL;
         EmitInstructionEpilogue(instr);
+        MaybeEmitCodeSourceMapEntry(instr->token_pos());
       }
 
 #if defined(DEBUG)
       if (!is_optimizing()) {
         FrameStateUpdateWith(instr);
       }
 #endif
     }
 
 #if defined(DEBUG)
@@ skipping 156 matching lines @@
 }
 
 
 void FlowGraphCompiler::AddSlowPathCode(SlowPathCode* code) {
   slow_path_code_.Add(code);
 }
 
 
 void FlowGraphCompiler::GenerateDeferredCode() {
   for (intptr_t i = 0; i < slow_path_code_.length(); i++) {
+    SaveCodeSize();
     slow_path_code_[i]->GenerateCode(this);
+    MaybeEmitCodeSourceMapEntry(TokenPosition::kDeferredSlowPath);
   }
   for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
+    SaveCodeSize();
     deopt_infos_[i]->GenerateCode(this, i);
+    MaybeEmitCodeSourceMapEntry(TokenPosition::kDeferredDeoptInfo);
   }
 }
 
 
 void FlowGraphCompiler::AddExceptionHandler(intptr_t try_index,
                                             intptr_t outer_try_index,
                                             intptr_t pc_offset,
                                             const Array& handler_types,
                                             bool needs_stacktrace) {
   exception_handlers_list_->AddHandler(try_index,
@@ skipping 676 matching lines @@
     // and skipping such moves with register destinations keeps those
     // registers free for the whole algorithm.
     if (!move.IsEliminated() && !move.src().IsConstant()) PerformMove(i);
   }
 
   // Perform the moves with constant sources.
   for (int i = 0; i < moves_.length(); ++i) {
     const MoveOperands& move = *moves_[i];
     if (!move.IsEliminated()) {
       ASSERT(move.src().IsConstant());
+      compiler_->SaveCodeSize();
       EmitMove(i);
+      compiler_->MaybeEmitCodeSourceMapEntry(TokenPosition::kParallelMove);
     }
   }
 
   moves_.Clear();
 }
 
 
 void ParallelMoveResolver::BuildInitialMoveList(
     ParallelMoveInstr* parallel_move) {
   // Perform a linear sweep of the moves to add them to the initial list of
@@ skipping 55 matching lines @@
     return;
   }
 
   // The move may be blocked on a (at most one) pending move, in which case
   // we have a cycle.  Search for such a blocking move and perform a swap to
   // resolve it.
   for (int i = 0; i < moves_.length(); ++i) {
     const MoveOperands& other_move = *moves_[i];
     if (other_move.Blocks(destination)) {
       ASSERT(other_move.IsPending());
+      compiler_->SaveCodeSize();
       EmitSwap(index);
+      compiler_->MaybeEmitCodeSourceMapEntry(TokenPosition::kParallelMove);
       return;
     }
   }
 
   // This move is not blocked.
+  compiler_->SaveCodeSize();
   EmitMove(index);
+  compiler_->MaybeEmitCodeSourceMapEntry(TokenPosition::kParallelMove);
 }
 
 
 bool ParallelMoveResolver::IsScratchLocation(Location loc) {
   for (int i = 0; i < moves_.length(); ++i) {
     if (moves_[i]->Blocks(loc)) {
       return false;
     }
   }
 
@@ skipping 237 matching lines @@
       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::SaveCodeSize() {
+  // Remember how many bytes of code we emitted. This function

[rmacnak, 2016/02/25 23:04:40]

NOT_IN_PRODUCT

[rmacnak, 2016/02/25 23:04:40]

emitted so far

[Cutch, 2016/02/26 15:59:22]

Done.

[Cutch, 2016/02/26 15:59:22]

Done.

+  // is called before we call into an instruction's EmitNativeCode.
+  saved_code_size_ = assembler()->CodeSize();
+}
+
+
+bool FlowGraphCompiler::MaybeEmitCodeSourceMapEntry(TokenPosition token_pos) {
+  // This function is called after each instructions' EmitNativeCode.

[rmacnak, 2016/02/25 23:04:40]

NOT_IN_PRODUCT

[Cutch, 2016/02/26 15:59:22]

Done.

+  if (saved_code_size_ < assembler()->CodeSize()) {
+    // We emitted code, now associate the emitted code chunk with |token_pos|.
+    code_source_map_builder()->AddEntry(saved_code_size_, token_pos);
+    SaveCodeSize();
+    return true;
+  }
+  return false;
+}
+
+
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(
     const ICData& ic_data,
     intptr_t argument_count,
     const Array& argument_names,
     intptr_t deopt_id,
     TokenPosition token_pos,
     LocationSummary* locs) {
   if (FLAG_polymorphic_with_deopt) {
     Label* deopt = AddDeoptStub(deopt_id,
                                 ICData::kDeoptPolymorphicInstanceCallTestFail);
@@ skipping 90 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart