Introduce a special kind of frames for construct frames, e.g....

src/frames.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 80 matching lines @@
 };
 
 
 #define STACK_FRAME_TYPE_LIST(V)              \
   V(ENTRY,             EntryFrame)            \
   V(ENTRY_CONSTRUCT,   EntryConstructFrame)   \
   V(EXIT,              ExitFrame)             \
   V(EXIT_DEBUG,        ExitDebugFrame)        \
   V(JAVA_SCRIPT,       JavaScriptFrame)       \
   V(INTERNAL,          InternalFrame)         \
+  V(CONSTRUCT,         ConstructFrame)        \
   V(ARGUMENTS_ADAPTOR, ArgumentsAdaptorFrame)
 
 
 // Abstract base class for all stack frames.
 class StackFrame BASE_EMBEDDED {
  public:
 #define DECLARE_TYPE(type, ignore) type,
   enum Type {
     NONE = 0,
     STACK_FRAME_TYPE_LIST(DECLARE_TYPE)
     NUMBER_OF_TYPES
   };
 #undef DECLARE_TYPE
 
   // Opaque data type for identifying stack frames. Used extensively
   // by the debugger.
   enum Id { NO_ID = 0 };
 
   // Type testers.
   bool is_entry() const { return type() == ENTRY; }
   bool is_entry_construct() const { return type() == ENTRY_CONSTRUCT; }
   bool is_exit() const { return type() == EXIT; }
   bool is_exit_debug() const { return type() == EXIT_DEBUG; }
   bool is_java_script() const { return type() == JAVA_SCRIPT; }
   bool is_arguments_adaptor() const { return type() == ARGUMENTS_ADAPTOR; }
   bool is_internal() const { return type() == INTERNAL; }
+  bool is_construct() const { return type() == CONSTRUCT; }
   virtual bool is_standard() const { return false; }
 
   // Accessors.
   Address sp() const { return state_.sp; }
   Address fp() const { return state_.fp; }
   Address pp() const { return GetCallerStackPointer(); }
 
   Address pc() const { return *pc_address(); }
   void set_pc(Address pc) { *pc_address() = pc; }
 
@@ skipping 208 matching lines @@
   Address GetExpressionAddress(int n) const;
 
   // Determines if the n'th expression stack element is in a stack
   // handler or not. Requires traversing all handlers in this frame.
   bool IsExpressionInsideHandler(int n) const;
 
   // Determines if the standard frame for the given frame pointer is
   // an arguments adaptor frame.
   static inline bool IsArgumentsAdaptorFrame(Address fp);
 
-  // Determines if the standard frame for the given program counter is
-  // a construct trampoline.
-  static inline bool IsConstructTrampolineFrame(Address pc);
+  // Determines if the standard frame for the given frame pointer is a
+  // construct frame.
+  static inline bool IsConstructFrame(Address fp);
 
  private:
   friend class StackFrame;
 };
 
 
 class JavaScriptFrame: public StandardFrame {
  public:
   virtual Type type() const { return JAVA_SCRIPT; }
 
   // Accessors.
   inline Object* function() const;
   inline Object* receiver() const;
   inline void set_receiver(Object* value);
 
   // Access the parameters.
   Object* GetParameter(int index) const;
   int ComputeParametersCount() const;
 
   // Temporary way of getting access to the number of parameters
   // passed on the stack by the caller. Once argument adaptor frames
   // has been introduced on ARM, this number will always match the
   // computed parameters count.
   int GetProvidedParametersCount() const;
 
-  // Check if this frame is a constructor frame invoked through
-  // 'new'. The operation may involve digging through a few stack
-  // frames to account for arguments adaptors.
+  // Check if this frame is a constructor frame invoked through 'new'.
   bool IsConstructor() const;
 
   // Check if this frame has "adapted" arguments in the sense that the
   // actual passed arguments are available in an arguments adaptor
   // frame below it on the stack.
   inline bool has_adapted_arguments() const;
 
   // Garbage colletion support.
   virtual void Iterate(ObjectVisitor* v) const;
 
@@ skipping 56 matching lines @@
 
  private:
   friend class StackFrameIterator;
 };
 
 
 class InternalFrame: public StandardFrame {
  public:
   virtual Type type() const { return INTERNAL; }
 
-  // Returns if this frame is a special trampoline frame introduced by
-  // the construct trampoline. NOTE: We should consider introducing a
-  // special stack frame type for this.
-  inline bool is_construct_trampoline() const;
-
   // Garbage colletion support.
   virtual void Iterate(ObjectVisitor* v) const;
 
   // Determine the code for the frame.
   virtual Code* FindCode() const;
 
   static InternalFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_internal());
     return static_cast<InternalFrame*>(frame);
   }
 
  protected:
   explicit InternalFrame(StackFrameIterator* iterator)
       : StandardFrame(iterator) { }
 
   virtual Address GetCallerStackPointer() const;
 
  private:
   friend class StackFrameIterator;
 };
 
 
+// Construct frames are special trampoline frames introduced to handle
+// function invocations through 'new'.
+class ConstructFrame: public InternalFrame {
+ public:
+  virtual Type type() const { return CONSTRUCT; }
+
+  static ConstructFrame* cast(StackFrame* frame) {
+    ASSERT(frame->is_construct());
+    return static_cast<ConstructFrame*>(frame);
+  }
+
+ protected:
+  explicit ConstructFrame(StackFrameIterator* iterator)
+      : InternalFrame(iterator) { }
+
+ private:
+  friend class StackFrameIterator;
+};
+
+
 class StackFrameIterator BASE_EMBEDDED {
  public:
   // An iterator that iterates over the current thread's stack.
   StackFrameIterator();
 
   // An iterator that iterates over a given thread's stack.
   explicit StackFrameIterator(ThreadLocalTop* thread);
 
   StackFrame* frame() const {
     ASSERT(!done());
@@ skipping 64 matching lines @@
   JavaScriptFrame* FindJavaScriptFrame(int n);
 
  private:
   StackFrameIterator iterator_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FRAMES_H_