[deoptimizer] Remove uses of TranslationIterator outside the deoptimizer.

src/deoptimizer.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/v8.h"
 
 #include "src/accessors.h"
 #include "src/codegen.h"
 #include "src/cpu-profiler.h"
 #include "src/deoptimizer.h"
@@ skipping 2497 matching lines @@
 // static
 TranslatedValue TranslatedValue::NewTagged(TranslatedState* container,
                                            Object* literal) {
   TranslatedValue slot(container, kTagged);
   slot.raw_literal_ = literal;
   return slot;
 }
 
 
 // static
-TranslatedValue TranslatedValue::NewInvalid() {
-  return TranslatedValue(nullptr, kInvalid);
+TranslatedValue TranslatedValue::NewInvalid(TranslatedState* container) {
+  return TranslatedValue(container, kInvalid);
 }
 
 
 Isolate* TranslatedValue::isolate() const { return container_->isolate(); }
 
 
 Object* TranslatedValue::raw_literal() const {
   DCHECK_EQ(kTagged, kind());
   return raw_literal_;
 }
@@ skipping 448 matching lines @@
         PrintF(trace_file, "captured object #%d (length = %d)", object_index,
                field_count);
       }
       object_positions_.push_back({frame_index, value_index});
       return TranslatedValue::NewDeferredObject(this, field_count,
                                                 object_index);
     }
 
     case Translation::REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid();
+      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; %s ", value,
                converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
       return TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
     }
 
     case Translation::INT32_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid();
+      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIdPTR " ; %s ", value,
                converter.NameOfCPURegister(input_reg));
       }
       return TranslatedValue::NewInt32(this, static_cast<int32_t>(value));
     }
 
     case Translation::UINT32_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid();
+      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIuPTR " ; %s (uint)", value,
                converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
       return TranslatedValue::NewUInt32(this, static_cast<uint32_t>(value));
     }
 
     case Translation::BOOL_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid();
+      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIdPTR " ; %s (bool)", value,
                converter.NameOfCPURegister(input_reg));
       }
       return TranslatedValue::NewBool(this, static_cast<uint32_t>(value));
     }
 
     case Translation::DOUBLE_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid();
+      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
       double value = registers->GetDoubleRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; %s (bool)", value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       return TranslatedValue::NewDouble(this, value);
     }
 
     case Translation::STACK_SLOT: {
       int slot_offset = SlotOffsetFp(iterator->Next());
@@ skipping 460 matching lines @@
       DCHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8