[turbofan] Unify referencing of stack slots

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 2591 matching lines @@
 
 int TranslatedValue::GetChildrenCount() const {
   if (kind() == kCapturedObject || kind() == kArgumentsObject) {
     return object_length();
   } else {
     return 0;
   }
 }
 
 
-int TranslatedState::SlotOffsetFp(int slot_index) {
-  if (slot_index >= 0) {
-    const int offset = StandardFrameConstants::kExpressionsOffset;
-    return offset - (slot_index * kPointerSize);
-  } else {
-    const int offset = StandardFrameConstants::kCallerSPOffset;
-    return offset - ((slot_index + 1) * kPointerSize);
-  }
-}
-
-
-Address TranslatedState::SlotAddress(Address fp, int slot_index) {
-  return fp + SlotOffsetFp(slot_index);
-}
-
-
 uint32_t TranslatedState::GetUInt32Slot(Address fp, int slot_offset) {
   Address address = fp + slot_offset;
 #if V8_TARGET_BIG_ENDIAN && V8_HOST_ARCH_64_BIT
   return Memory::uint32_at(address + kIntSize);
 #else
   return Memory::uint32_at(address);
 #endif
 }
 
 
@@ skipping 302 matching lines @@
       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());
+      int slot_offset =
+          OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       intptr_t value = *(reinterpret_cast<intptr_t*>(fp + slot_offset));
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
       return TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
     }
 
     case Translation::INT32_STACK_SLOT: {
-      int slot_offset = SlotOffsetFp(iterator->Next());
+      int slot_offset =
+          OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%d ; (int) [fp %c %d] ",
                static_cast<int32_t>(value), slot_offset < 0 ? '-' : '+',
                std::abs(slot_offset));
       }
       return TranslatedValue::NewInt32(this, value);
     }
 
     case Translation::UINT32_STACK_SLOT: {
-      int slot_offset = SlotOffsetFp(iterator->Next());
+      int slot_offset =
+          OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%u ; (uint) [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
       return TranslatedValue::NewUInt32(this, value);
     }
 
     case Translation::BOOL_STACK_SLOT: {
-      int slot_offset = SlotOffsetFp(iterator->Next());
+      int slot_offset =
+          OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%u ; (bool) [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
       return TranslatedValue::NewBool(this, value);
     }
 
     case Translation::DOUBLE_STACK_SLOT: {
-      int slot_offset = SlotOffsetFp(iterator->Next());
+      int slot_offset =
+          OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       double value = ReadDoubleValue(fp + slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; (double) [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
       return TranslatedValue::NewDouble(this, value);
     }
 
     case Translation::LITERAL: {
       int literal_index = iterator->Next();
@@ skipping 420 matching lines @@
       DCHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8