Put the type feedback vector in the unoptimized JavaScript frame.

src/frames.cc

 // Copyright 2012 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/frames.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 547 matching lines @@
   state->sp = sp;
   state->fp = fp;
   state->pc_address = ResolveReturnAddressLocation(
       reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
   state->constant_pool_address =
       reinterpret_cast<Address*>(fp + ExitFrameConstants::kConstantPoolOffset);
 }
 
 
 Address StandardFrame::GetExpressionAddress(int n) const {
-  const int offset = StandardFrameConstants::kExpressionsOffset;
+  const int offset = (is_java_script() && !is_optimized())
+                         ? JavaScriptFrameConstants::kLocal0Offset
+                         : StandardFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
 
-Object* StandardFrame::GetExpression(Address fp, int index) {
-  return Memory::Object_at(GetExpressionAddress(fp, index));
+Object* StandardFrame::GetStandardFrameExpression(Address fp, int index) {
+  return Memory::Object_at(GetStandardFrameExpressionAddress(fp, index));
 }
 
 
-Address StandardFrame::GetExpressionAddress(Address fp, int n) {
+Address StandardFrame::GetStandardFrameExpressionAddress(Address fp, int n) {
   const int offset = StandardFrameConstants::kExpressionsOffset;
   return fp + offset - n * kPointerSize;
 }
 
 
 int StandardFrame::ComputeExpressionsCount() const {
-  const int offset =
-      StandardFrameConstants::kExpressionsOffset + kPointerSize;
+  const int offsetStart = (is_java_script() && !is_optimized())
+                              ? JavaScriptFrameConstants::kLocal0Offset
+                              : StandardFrameConstants::kExpressionsOffset;
+  const int offset = offsetStart + kPointerSize;
   Address base = fp() + offset;
   Address limit = sp();
   DCHECK(base >= limit);  // stack grows downwards
   // Include register-allocated locals in number of expressions.
   return static_cast<int>((base - limit) / kPointerSize);
 }
 
 
 void StandardFrame::ComputeCallerState(State* state) const {
   state->sp = caller_sp();
@@ skipping 27 matching lines @@
 
   // Compute the safepoint information.
   unsigned stack_slots = 0;
   SafepointEntry safepoint_entry;
   Code* code = StackFrame::GetSafepointData(
       isolate(), pc(), &safepoint_entry, &stack_slots);
   unsigned slot_space = stack_slots * kPointerSize;
 
   // Visit the outgoing parameters.
   Object** parameters_base = &Memory::Object_at(sp());
-  Object** parameters_limit = &Memory::Object_at(
-      fp() + JavaScriptFrameConstants::kFunctionOffset - slot_space);
+  Object** parameters_limit =
+      &Memory::Object_at(fp() + StandardFrameConstants::kMarkerOffset -
+                         slot_space);
 
   // Visit the parameters that may be on top of the saved registers.
   if (safepoint_entry.argument_count() > 0) {
     v->VisitPointers(parameters_base,
                      parameters_base + safepoint_entry.argument_count());
     parameters_base += safepoint_entry.argument_count();
   }
 
   // Skip saved double registers.
   if (safepoint_entry.has_doubles()) {
@@ skipping 85 matching lines @@
     // Skip the arguments adaptor frame and look at the real caller.
     fp = Memory::Address_at(fp + StandardFrameConstants::kCallerFPOffset);
   }
   return IsConstructFrame(fp);
 }
 
 
 int JavaScriptFrame::GetArgumentsLength() const {
   // If there is an arguments adaptor frame get the arguments length from it.
   if (has_adapted_arguments()) {
-    return Smi::cast(GetExpression(caller_fp(), 0))->value();
+    return ArgumentsAdaptorFrame::GetArgumentsLength(caller_fp());
   } else {
     return GetNumberOfIncomingArguments();
   }
 }
 
 
 Code* JavaScriptFrame::unchecked_code() const {
   return function()->code();
 }
 
@@ skipping 363 matching lines @@
       it.Next();  // Skip height.
       functions->Add(function);
     } else {
       // Skip over operands to advance to the next opcode.
       it.Skip(Translation::NumberOfOperandsFor(opcode));
     }
   }
 }
 
 
+int ArgumentsAdaptorFrame::GetArgumentsLength(Address fp) {
+  return Smi::cast(GetStandardFrameExpression(fp, 0))->value();
+}
+
+
 int ArgumentsAdaptorFrame::GetNumberOfIncomingArguments() const {
   return Smi::cast(GetExpression(0))->value();
 }
 
 
 Address ArgumentsAdaptorFrame::GetCallerStackPointer() const {
   return fp() + StandardFrameConstants::kCallerSPOffset;
 }
 
 
@@ skipping 504 matching lines @@
   ZoneList<StackFrame*> list(10, zone);
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 } }  // namespace v8::internal