Make the frame inspector use TranslatedState rather than the full deoptimizer.

src/deoptimizer.h

 // 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.
 
 #ifndef V8_DEOPTIMIZER_H_
 #define V8_DEOPTIMIZER_H_
 
 #include "src/allocation.h"
 #include "src/macro-assembler.h"
 
 
 namespace v8 {
 namespace internal {
 
 class FrameDescription;
 class TranslationIterator;
 class DeoptimizedFrameInfo;
 class TranslatedState;
 class RegisterValues;
 
 class TranslatedValue {
  public:
   // Allocation-less getter of the value.
   // Returns heap()->arguments_marker() if allocation would be
   // necessary to get the value.
   Object* GetRawValue() const;
   Handle<Object> GetValue();
 
   bool IsMaterializedObject() const;
+  bool IsMaterializableByDebugger() const;
 
  private:
   friend class TranslatedState;
   friend class TranslatedFrame;
 
   enum Kind {
     kInvalid,
     kTagged,
     kInt32,
     kUInt32,
@@ skipping 461 matching lines @@
   static void VisitAllOptimizedFunctions(
       Isolate* isolate, OptimizedFunctionVisitor* visitor);
 
   // The size in bytes of the code required at a lazy deopt patch site.
   static int patch_size();
 
   ~Deoptimizer();
 
   void MaterializeHeapObjects(JavaScriptFrameIterator* it);
 
-  void MaterializeHeapNumbersForDebuggerInspectableFrame(
-      int frame_index, int parameter_count, int expression_count,
-      DeoptimizedFrameInfo* info);
-
   static void ComputeOutputFrames(Deoptimizer* deoptimizer);
 
 
   enum GetEntryMode {
     CALCULATE_ENTRY_ADDRESS,
     ENSURE_ENTRY_CODE
   };
 
 
   static Address GetDeoptimizationEntry(
@@ skipping 113 matching lines @@
   static void DeoptimizeMarkedCodeForContext(Context* native_context);
 
   // Patch the given code so that it will deoptimize itself.
   static void PatchCodeForDeoptimization(Isolate* isolate, Code* code);
 
   // Searches the list of known deoptimizing code for a Code object
   // containing the given address (which is supposedly faster than
   // searching all code objects).
   Code* FindDeoptimizingCode(Address addr);
 
-  // Fill the input from from a JavaScript frame. This is used when
-  // the debugger needs to inspect an optimized frame. For normal
-  // deoptimizations the input frame is filled in generated code.
-  void FillInputFrame(Address tos, JavaScriptFrame* frame);
-
   // Fill the given output frame's registers to contain the failure handler
   // address and the number of parameters for a stub failure trampoline.
   void SetPlatformCompiledStubRegisters(FrameDescription* output_frame,
                                         CodeStubDescriptor* desc);
 
   // Fill the given output frame's double registers with the original values
   // from the input frame's double registers.
   void CopyDoubleRegisters(FrameDescription* output_frame);
 
   // Determines whether the input frame contains alignment padding by looking
@@ skipping 74 matching lines @@
     double_registers_[n] = value;
   }
 
   intptr_t registers_[Register::kNumRegisters];
   double double_registers_[DoubleRegister::kMaxNumRegisters];
 };
 
 
 class FrameDescription {
  public:
-  FrameDescription(uint32_t frame_size,
-                   JSFunction* function);
+  explicit FrameDescription(uint32_t frame_size, int parameter_count = 0);
 
   void* operator new(size_t size, uint32_t frame_size) {
     // Subtracts kPointerSize, as the member frame_content_ already supplies
     // the first element of the area to store the frame.
     return malloc(size + frame_size - kPointerSize);
   }
 
   void operator delete(void* pointer, uint32_t frame_size) {
     free(pointer);
   }
 
   void operator delete(void* description) {
     free(description);
   }
 
   uint32_t GetFrameSize() const {
     DCHECK(static_cast<uint32_t>(frame_size_) == frame_size_);
     return static_cast<uint32_t>(frame_size_);
   }
 
-  JSFunction* GetFunction() const { return function_; }
-
   unsigned GetOffsetFromSlotIndex(int slot_index);
 
   intptr_t GetFrameSlot(unsigned offset) {
     return *GetFrameSlotPointer(offset);
   }
 
   Address GetFramePointerAddress() {
-    int fp_offset = GetFrameSize() -
-                    (ComputeParametersCount() + 1) * kPointerSize -
+    int fp_offset = GetFrameSize() - parameter_count() * kPointerSize -
                     StandardFrameConstants::kCallerSPOffset;
     return reinterpret_cast<Address>(GetFrameSlotPointer(fp_offset));
   }
 
   RegisterValues* GetRegisterValues() { return &register_values_; }
 
   void SetFrameSlot(unsigned offset, intptr_t value) {
     *GetFrameSlotPointer(offset) = value;
   }
 
@@ skipping 37 matching lines @@
   }
 
   Smi* GetState() const { return state_; }
   void SetState(Smi* state) { state_ = state; }
 
   void SetContinuation(intptr_t pc) { continuation_ = pc; }
 
   StackFrame::Type GetFrameType() const { return type_; }
   void SetFrameType(StackFrame::Type type) { type_ = type; }
 
-  // Get the incoming arguments count.
-  int ComputeParametersCount();
-
-  // Get a parameter value for an unoptimized frame.
-  Object* GetParameter(int index);
-
-  // Get the expression stack height for a unoptimized frame.
-  unsigned GetExpressionCount();
-
-  // Get the expression stack value for an unoptimized frame.
-  Object* GetExpression(int index);
+  // Argument count, including receiver.
+  int parameter_count() { return parameter_count_; }
 
   static int registers_offset() {
     return OFFSET_OF(FrameDescription, register_values_.registers_);
   }
 
   static int double_registers_offset() {
     return OFFSET_OF(FrameDescription, register_values_.double_registers_);
   }
 
   static int frame_size_offset() {
@@ skipping 12 matching lines @@
     return offsetof(FrameDescription, frame_content_);
   }
 
  private:
   static const uint32_t kZapUint32 = 0xbeeddead;
 
   // Frame_size_ must hold a uint32_t value.  It is only a uintptr_t to
   // keep the variable-size array frame_content_ of type intptr_t at
   // the end of the structure aligned.
   uintptr_t frame_size_;  // Number of bytes.
-  JSFunction* function_;
+  int parameter_count_;
   RegisterValues register_values_;
   intptr_t top_;
   intptr_t pc_;
   intptr_t fp_;
   intptr_t context_;
   intptr_t constant_pool_;
   StackFrame::Type type_;
   Smi* state_;
 
   // Continuation is the PC where the execution continues after
@@ skipping 174 matching lines @@
 
 
 // Class used to represent an unoptimized frame when the debugger
 // needs to inspect a frame that is part of an optimized frame. The
 // internally used FrameDescription objects are not GC safe so for use
 // by the debugger frame information is copied to an object of this type.
 // Represents parameters in unadapted form so their number might mismatch
 // formal parameter count.
 class DeoptimizedFrameInfo : public Malloced {
  public:
-  DeoptimizedFrameInfo(Deoptimizer* deoptimizer,
-                       int frame_index,
-                       bool has_arguments_adaptor,
-                       bool has_construct_stub);
+  DeoptimizedFrameInfo(TranslatedState* state,
+                       TranslatedState::iterator frame_it, Isolate* isolate);
+
   // Return the number of incoming arguments.
   int parameters_count() { return static_cast<int>(parameters_.size()); }
 
   // Return the height of the expression stack.
   int expression_count() { return static_cast<int>(expression_stack_.size()); }
 
   // Get the frame function.
   Handle<JSFunction> GetFunction() { return function_; }
 
   // Get the frame context.
@@ skipping 41 matching lines @@
   std::vector<Handle<Object> > expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEOPTIMIZER_H_