DBC: Fix checked mode stack traces

runtime/vm/flow_graph_compiler_dbc.cc

 // Copyright (c) 2016, 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_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 158 matching lines @@
 
   // For the outermost environment, set the incoming arguments.
   for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
     builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i), slot_ix++);
   }
 
   return builder->CreateDeoptInfo(deopt_table);
 }
 
 
-void FlowGraphCompiler::RecordAfterCall(Instruction* instr) {
-  RecordSafepoint(instr->locs());
+void FlowGraphCompiler::RecordAfterCallHelper(TokenPosition token_pos,
+                                              intptr_t deopt_id,
+                                              intptr_t argument_count,
+                                              LocationSummary* locs) {
+  RecordSafepoint(locs);
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
-  const intptr_t deopt_id_after = Thread::ToDeoptAfter(instr->deopt_id());
+  const intptr_t deopt_id_after = Thread::ToDeoptAfter(deopt_id);
   if (is_optimizing()) {
     // Return/ReturnTOS instruction drops incoming arguments so
     // we have to drop outgoing arguments from the innermost environment.
     // On all other architectures caller drops outgoing arguments itself
     // hence the difference.
-    pending_deoptimization_env_->DropArguments(instr->ArgumentCount());
+    pending_deoptimization_env_->DropArguments(argument_count);
     AddDeoptIndexAtCall(deopt_id_after);
     // This descriptor is needed for exception handling in optimized code.
-    AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id_after,
-                         instr->token_pos());
+    AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id_after, token_pos);
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
-    AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id_after,
-                         instr->token_pos());
+    AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id_after, token_pos);
   }
 }
 
 
+void FlowGraphCompiler::RecordAfterCall(Instruction* instr) {
+  RecordAfterCallHelper(instr->token_pos(), instr->deopt_id(),
+                        instr->ArgumentCount(), instr->locs());
+}
+
+
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   UNREACHABLE();
 }
 
 
 #define __ assembler()->
 
 
 void FlowGraphCompiler::GenerateAssertAssignable(TokenPosition token_pos,
@@ skipping 35 matching lines @@
   if (is_optimizing()) {
     // Register allocator does not think that our first input (also used as
     // output) needs to be kept alive across the call because that is how code
     // is written on other platforms (where registers are always spilled across
     // the call): inputs are consumed by operation and output is produced so
     // neither are alive at the safepoint.
     // We have to mark the slot alive manually to ensure that GC
     // visits it.
     locs->SetStackBit(locs->out(0).reg());
   }
-  RecordSafepoint(locs);
   AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id, token_pos);

[Florian Schneider, 2016/11/11 23:48:59]

Is this descriptor still needed?

[zra, 2016/11/12 05:29:03]

I believe so yes. For the other architectures as well, there are two descriptors
created in FlowGraphCompiler::GenerateRuntimeCall().

+  RecordAfterCallHelper(token_pos, deopt_id, 0, locs);
   if (is_optimizing()) {
     // Assert assignable keeps the instance on the stack as the result,
     // all other arguments are popped.
     ASSERT(locs->out(0).reg() == locs->in(0).reg());
     __ Drop1();
   }
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
@@ skipping 278 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC