Revert "Reapply "Use CodeSourceMap for stack traces (still JIT only).""

runtime/vm/code_descriptors.cc

Index: runtime/vm/code_descriptors.cc
diff --git a/runtime/vm/code_descriptors.cc b/runtime/vm/code_descriptors.cc
index 7bccb7d2e3efc36dafaa4e52cc84c0c2fd4bf578..0631bfee3f588446607221bb43bd48133a093a26 100644
--- a/runtime/vm/code_descriptors.cc
+++ b/runtime/vm/code_descriptors.cc
@@ -128,86 +128,26 @@ const TokenPosition CodeSourceMapBuilder::kInitialPosition =
 
 
 CodeSourceMapBuilder::CodeSourceMapBuilder(
-    bool stack_traces_only,
     const GrowableArray<intptr_t>& caller_inline_id,
     const GrowableArray<TokenPosition>& inline_id_to_token_pos,
     const GrowableArray<const Function*>& inline_id_to_function)
-    : buffered_pc_offset_(0),
-      buffered_inline_id_stack_(),
-      buffered_token_pos_stack_(),
-      written_pc_offset_(0),
-      written_inline_id_stack_(),
-      written_token_pos_stack_(),
+    : pc_offset_(0),
+      advance_pc_peephole_(0),
+      inline_id_stack_(),
+      token_pos_stack_(),
       caller_inline_id_(caller_inline_id),
       inline_id_to_token_pos_(inline_id_to_token_pos),
       inline_id_to_function_(inline_id_to_function),
       buffer_(NULL),
-      stream_(&buffer_, zone_allocator, 64),
-      stack_traces_only_(stack_traces_only) {
-  buffered_inline_id_stack_.Add(0);
-  buffered_token_pos_stack_.Add(kInitialPosition);
-  written_inline_id_stack_.Add(0);
-  written_token_pos_stack_.Add(kInitialPosition);
-}
-
-
-void CodeSourceMapBuilder::FlushBuffer() {
-  FlushBufferStack();
-  FlushBufferPosition();
-  FlushBufferPC();
-}
-
-
-void CodeSourceMapBuilder::FlushBufferStack() {
-  for (intptr_t i = buffered_inline_id_stack_.length() - 1; i >= 0; i--) {
-    intptr_t buffered_id = buffered_inline_id_stack_[i];
-    if (i < written_inline_id_stack_.length()) {
-      intptr_t written_id = written_inline_id_stack_[i];
-      if (buffered_id == written_id) {
-        // i is the top-most position where the buffered and written stack
-        // match.
-        while (written_inline_id_stack_.length() > i + 1) {
-          WritePop();
-        }
-        for (intptr_t j = i + 1; j < buffered_inline_id_stack_.length(); j++) {
-          TokenPosition buffered_pos = buffered_token_pos_stack_[j - 1];
-          TokenPosition written_pos = written_token_pos_stack_[j - 1];
-          if (buffered_pos != written_pos) {
-            WriteChangePosition(buffered_pos);
-          }
-          WritePush(buffered_inline_id_stack_[j]);
-        }
-        return;
-      }
-    }
-  }
-  UNREACHABLE();
-}
-
-
-void CodeSourceMapBuilder::FlushBufferPosition() {
-  ASSERT(buffered_token_pos_stack_.length() ==
-         written_token_pos_stack_.length());
-
-  intptr_t top = buffered_token_pos_stack_.length() - 1;
-  TokenPosition buffered_pos = buffered_token_pos_stack_[top];
-  TokenPosition written_pos = written_token_pos_stack_[top];
-  if (buffered_pos != written_pos) {
-    WriteChangePosition(buffered_pos);
-  }
-}
-
-
-void CodeSourceMapBuilder::FlushBufferPC() {
-  if (buffered_pc_offset_ != written_pc_offset_) {
-    WriteAdvancePC(buffered_pc_offset_ - written_pc_offset_);
-  }
+      stream_(&buffer_, zone_allocator, 64) {
+  inline_id_stack_.Add(0);
+  token_pos_stack_.Add(TokenPosition::kDartCodePrologue);
 }
 
 
 void CodeSourceMapBuilder::StartInliningInterval(int32_t pc_offset,
                                                  intptr_t inline_id) {
-  if (buffered_inline_id_stack_.Last() == inline_id) {
+  if (inline_id_stack_.Last() == inline_id) {
     // No change in function stack.
     return;
   }
@@ -216,20 +156,18 @@ void CodeSourceMapBuilder::StartInliningInterval(int32_t pc_offset,
     return;
   }
 
-  if (!stack_traces_only_) {
-    FlushBuffer();
-  }
-
   // Find a minimal set of pops and pushes to bring us to the new function
   // stack.
 
   // Pop to a common ancestor.
   intptr_t common_parent = inline_id;
-  while (!IsOnBufferedStack(common_parent)) {
+  while (!IsOnStack(common_parent)) {
     common_parent = caller_inline_id_[common_parent];
   }
-  while (buffered_inline_id_stack_.Last() != common_parent) {
-    BufferPop();
+  while (inline_id_stack_.Last() != common_parent) {
+    EmitPop();
+    inline_id_stack_.RemoveLast();
+    token_pos_stack_.RemoveLast();
   }
 
   // Push to the new top-of-stack function.
@@ -240,19 +178,23 @@ void CodeSourceMapBuilder::StartInliningInterval(int32_t pc_offset,
     id = caller_inline_id_[id];
   }
   for (intptr_t i = to_push.length() - 1; i >= 0; i--) {
-    intptr_t callee_id = to_push[i];
+    intptr_t push_id = to_push[i];
     TokenPosition call_token;
-    if (callee_id != 0) {
+    if (push_id != 0) {
       // TODO(rmacnak): Should make this array line up with the others.
-      call_token = inline_id_to_token_pos_[callee_id - 1];
-    } else {
-      UNREACHABLE();
+      call_token = inline_id_to_token_pos_[push_id - 1];
     }
 
     // Report caller as at the position of the call.
-    BufferChangePosition(call_token);
+    if (call_token != token_pos_stack_.Last()) {
+      EmitPosition(call_token);
+      token_pos_stack_[token_pos_stack_.length() - 1] = call_token;
+    }
 
-    BufferPush(callee_id);
+    // Push the callee.
+    EmitPush(push_id);
+    inline_id_stack_.Add(push_id);
+    token_pos_stack_.Add(TokenPosition::kDartCodePrologue);
   }
 }
 
@@ -262,30 +204,15 @@ void CodeSourceMapBuilder::BeginCodeSourceRange(int32_t pc_offset) {}
 
 void CodeSourceMapBuilder::EndCodeSourceRange(int32_t pc_offset,
                                               TokenPosition pos) {
-  if (pc_offset == buffered_pc_offset_) {
+  if (pc_offset == pc_offset_) {
     return;  // Empty intermediate instruction.
   }
-  if (pos != buffered_token_pos_stack_.Last()) {
-    if (!stack_traces_only_) {
-      FlushBuffer();
-    }
-    BufferChangePosition(pos);
-  }
-  BufferAdvancePC(pc_offset - buffered_pc_offset_);
-}
-
-
-void CodeSourceMapBuilder::NoteDescriptor(RawPcDescriptors::Kind kind,
-                                          int32_t pc_offset,
-                                          TokenPosition pos) {
-  const uint8_t kCanThrow =
-      RawPcDescriptors::kIcCall | RawPcDescriptors::kUnoptStaticCall |
-      RawPcDescriptors::kRuntimeCall | RawPcDescriptors::kOther;
-  if (stack_traces_only_ && ((kind & kCanThrow) != 0)) {
-    BufferChangePosition(pos);
-    BufferAdvancePC(pc_offset - buffered_pc_offset_);
-    FlushBuffer();
+  if (pos != token_pos_stack_.Last()) {
+    EmitPosition(pos);
+    token_pos_stack_[token_pos_stack_.length() - 1] = pos;
   }
+  EmitAdvancePC(pc_offset - pc_offset_);
+  pc_offset_ = pc_offset;
 }
 
 
@@ -304,9 +231,7 @@ RawArray* CodeSourceMapBuilder::InliningIdToFunction() {
 
 
 RawCodeSourceMap* CodeSourceMapBuilder::Finalize() {
-  if (!stack_traces_only_) {
-    FlushBuffer();
-  }
+  FlushPeephole();
   intptr_t length = stream_.bytes_written();
   const CodeSourceMap& map = CodeSourceMap::Handle(CodeSourceMap::New(length));
   NoSafepointScope no_safepoint;