VM: [DBC] Fix lazy deoptimization after calls that return no values.

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 100 matching lines @@
   builder->AddCallerFp(slot_ix++);
   builder->AddReturnAddress(current->function(), deopt_id(), slot_ix++);
   builder->AddPcMarker(Function::ZoneHandle(zone), slot_ix++);
   builder->AddConstant(Function::ZoneHandle(zone), slot_ix++);
 
   // Emit all values that are needed for materialization as a part of the
   // expression stack for the bottom-most frame. This guarantees that GC
   // will be able to find them during materialization.
   slot_ix = builder->EmitMaterializationArguments(slot_ix);
 
+  if (lazy_deopt_with_result_) {
+    ASSERT(reason() == ICData::kDeoptAtCall);
+    builder->AddCopy(NULL, Location::StackSlot(stack_height), slot_ix++);
+  }
+
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
        i >= current->fixed_parameter_count(); i--) {
     builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
   }
 
   builder->AddCallerFp(slot_ix++);
 
   Environment* previous = current;
   current = current->outer();
@@ skipping 41 matching lines @@
     builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i), slot_ix++);
   }
 
   return builder->CreateDeoptInfo(deopt_table);
 }
 
 
 void FlowGraphCompiler::RecordAfterCallHelper(TokenPosition token_pos,
                                               intptr_t deopt_id,
                                               intptr_t argument_count,
+                                              CallResult result,
                                               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(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(argument_count);
-    AddDeoptIndexAtCall(deopt_id_after);
+    CompilerDeoptInfo* info = AddDeoptIndexAtCall(deopt_id_after);
+    if (result == kHasResult) {
+      info->mark_lazy_deopt_with_result();
+    }
     // This descriptor is needed for exception handling in optimized code.
     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, token_pos);
   }
 }
 
 
-void FlowGraphCompiler::RecordAfterCall(Instruction* instr) {
+void FlowGraphCompiler::RecordAfterCall(Instruction* instr, CallResult result) {
   RecordAfterCallHelper(instr->token_pos(), instr->deopt_id(),
-                        instr->ArgumentCount(), instr->locs());
+                        instr->ArgumentCount(), result, instr->locs());
 }
 
 
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   UNREACHABLE();
 }
 
 
 #define __ assembler()->
@@ skipping 39 matching lines @@
     // 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());
   }
   AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id, token_pos);
-  RecordAfterCallHelper(token_pos, deopt_id, 0, locs);
+  const intptr_t kArgCount = 0;
+  RecordAfterCallHelper(token_pos, deopt_id, kArgCount,
+                        FlowGraphCompiler::kHasResult, 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