[turbofan] Fix skipping of translations for lazy deopt return value stores.

src/compiler/code-generator.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/code-generator.h"
 
 #include "src/address-map.h"
 #include "src/base/adapters.h"
 #include "src/compilation-info.h"
 #include "src/compiler/code-generator-impl.h"
@@ skipping 654 matching lines @@
 DeoptimizeReason CodeGenerator::GetDeoptimizationReason(
     int deoptimization_id) const {
   size_t const index = static_cast<size_t>(deoptimization_id);
   DCHECK_LT(index, deoptimization_states_.size());
   return deoptimization_states_[index]->reason();
 }
 
 void CodeGenerator::TranslateStateValueDescriptor(
     StateValueDescriptor* desc, StateValueList* nested,
     Translation* translation, InstructionOperandIterator* iter) {
+  // Note:
+  // If translation is null, we just skip the relevant instruction operands.
   if (desc->IsNested()) {
-    translation->BeginCapturedObject(static_cast<int>(nested->size()));
+    if (translation != nullptr) {
+      translation->BeginCapturedObject(static_cast<int>(nested->size()));
+    }
     for (auto field : *nested) {
       TranslateStateValueDescriptor(field.desc, field.nested, translation,
                                     iter);
     }
   } else if (desc->IsDuplicate()) {
-    translation->DuplicateObject(static_cast<int>(desc->id()));
+    if (translation != nullptr) {
+      translation->DuplicateObject(static_cast<int>(desc->id()));
+    }
   } else if (desc->IsPlain()) {
-    AddTranslationForOperand(translation, iter->instruction(), iter->Advance(),
-                             desc->type());
+    InstructionOperand* op = iter->Advance();
+    if (translation != nullptr) {
+      AddTranslationForOperand(translation, iter->instruction(), op,
+                               desc->type());
+    }
   } else {
     DCHECK(desc->IsOptimizedOut());
-    if (optimized_out_literal_id_ == -1) {
-      optimized_out_literal_id_ =
-          DefineDeoptimizationLiteral(isolate()->factory()->optimized_out());
+    if (translation != nullptr) {
+      if (optimized_out_literal_id_ == -1) {
+        optimized_out_literal_id_ =
+            DefineDeoptimizationLiteral(isolate()->factory()->optimized_out());
+      }
+      translation->StoreLiteral(optimized_out_literal_id_);
     }
-    translation->StoreLiteral(optimized_out_literal_id_);
   }
 }
 
 
 void CodeGenerator::TranslateFrameStateDescriptorOperands(
     FrameStateDescriptor* desc, InstructionOperandIterator* iter,
     OutputFrameStateCombine combine, Translation* translation) {
   size_t index = 0;
   StateValueList* values = desc->GetStateValueDescriptors();
   for (StateValueList::iterator it = values->begin(); it != values->end();
        ++it, ++index) {
+    StateValueDescriptor* value_desc = (*it).desc;
     if (combine.kind() == OutputFrameStateCombine::kPokeAt) {
       // The result of the call should be placed at position
       // [index_from_top] in the stack (overwriting whatever was
       // previously there).
       size_t index_from_top =
           desc->GetSize(combine) - 1 - combine.GetOffsetToPokeAt();
       if (index >= index_from_top &&
           index < index_from_top + iter->instruction()->OutputCount()) {
+        DCHECK_NOT_NULL(translation);
         AddTranslationForOperand(
             translation, iter->instruction(),
             iter->instruction()->OutputAt(index - index_from_top),
             MachineType::AnyTagged());
-        iter->Advance();  // We do not use this input, but we need to
-                          // advace, as the input got replaced.
+        // Skip the instruction operands.
+        TranslateStateValueDescriptor(value_desc, (*it).nested, nullptr, iter);
         continue;
       }
     }
-    TranslateStateValueDescriptor((*it).desc, (*it).nested, translation, iter);
+    TranslateStateValueDescriptor(value_desc, (*it).nested, translation, iter);
   }
   DCHECK_EQ(desc->GetSize(OutputFrameStateCombine::Ignore()), index);
 
   if (combine.kind() == OutputFrameStateCombine::kPushOutput) {
     DCHECK(combine.GetPushCount() <= iter->instruction()->OutputCount());
     for (size_t output = 0; output < combine.GetPushCount(); output++) {
       // Materialize the result of the call instruction in this slot.
       AddTranslationForOperand(translation, iter->instruction(),
                                iter->instruction()->OutputAt(output),
                                MachineType::AnyTagged());
@@ skipping 235 matching lines @@
     : frame_(gen->frame()), masm_(gen->masm()), next_(gen->ools_) {
   gen->ools_ = this;
 }
 
 
 OutOfLineCode::~OutOfLineCode() {}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8