A64: Synchronize with r15358.

src/frames.h

 // Copyright 2012 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 33 matching lines @@
 // Get the number of registers in a given register list.
 int NumRegs(RegList list);
 
 void SetUpJSCallerSavedCodeData();
 
 // Return the code of the n-th saved register available to JavaScript.
 int JSCallerSavedCode(int n);
 
 
 // Forward declarations.
-class StackFrameIterator;
+class StackFrameIteratorBase;
 class ThreadLocalTop;
 class Isolate;
 
 class InnerPointerToCodeCache {
  public:
   struct InnerPointerToCodeCacheEntry {
     Address inner_pointer;
     Code* code;
     SafepointEntry safepoint_entry;
   };
@@ skipping 238 matching lines @@
 
   // Printing support.
   enum PrintMode { OVERVIEW, DETAILS };
   virtual void Print(StringStream* accumulator,
                      PrintMode mode,
                      int index) const { }
 
   Isolate* isolate() const { return isolate_; }
 
  protected:
-  inline explicit StackFrame(StackFrameIterator* iterator);
+  inline explicit StackFrame(StackFrameIteratorBase* iterator);
   virtual ~StackFrame() { }
 
   // Compute the stack pointer for the calling frame.
   virtual Address GetCallerStackPointer() const = 0;
 
   // Printing support.
   static void PrintIndex(StringStream* accumulator,
                          PrintMode mode,
                          int index);
 
   // Get the top handler from the current stack iterator.
   inline StackHandler* top_handler() const;
 
   // Compute the stack frame type for the given state.
-  static Type ComputeType(Isolate* isolate, State* state);
+  static Type ComputeType(const StackFrameIteratorBase* iterator, State* state);
+
+#ifdef DEBUG
+  bool can_access_heap_objects() const;
+#endif
 
  private:
-  const StackFrameIterator* iterator_;
+  const StackFrameIteratorBase* iterator_;
   Isolate* isolate_;
   State state_;
 
   // Fill in the state of the calling frame.
   virtual void ComputeCallerState(State* state) const = 0;
 
   // Get the type and the state of the calling frame.
   virtual Type GetCallerState(State* state) const;
 
   static const intptr_t kIsolateTag = 1;
 
   friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
   friend class StackHandlerIterator;
   friend class SafeStackFrameIterator;
 
  private:
   void operator=(const StackFrame& original);
 };
 
 
 // Entry frames are used to enter JavaScript execution from C.
 class EntryFrame: public StackFrame {
  public:
   virtual Type type() const { return ENTRY; }
 
   virtual Code* unchecked_code() const;
 
   // Garbage collection support.
   virtual void Iterate(ObjectVisitor* v) const;
 
   static EntryFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_entry());
     return static_cast<EntryFrame*>(frame);
   }
   virtual void SetCallerFp(Address caller_fp);
 
  protected:
-  inline explicit EntryFrame(StackFrameIterator* iterator);
+  inline explicit EntryFrame(StackFrameIteratorBase* iterator);
 
   // The caller stack pointer for entry frames is always zero. The
   // real information about the caller frame is available through the
   // link to the top exit frame.
   virtual Address GetCallerStackPointer() const { return 0; }
 
  private:
   virtual void ComputeCallerState(State* state) const;
   virtual Type GetCallerState(State* state) const;
 
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class EntryConstructFrame: public EntryFrame {
  public:
   virtual Type type() const { return ENTRY_CONSTRUCT; }
 
   virtual Code* unchecked_code() const;
 
   static EntryConstructFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_entry_construct());
     return static_cast<EntryConstructFrame*>(frame);
   }
 
  protected:
-  inline explicit EntryConstructFrame(StackFrameIterator* iterator);
+  inline explicit EntryConstructFrame(StackFrameIteratorBase* iterator);
 
  private:
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 // Exit frames are used to exit JavaScript execution and go to C.
 class ExitFrame: public StackFrame {
  public:
   virtual Type type() const { return EXIT; }
 
   virtual Code* unchecked_code() const;
 
@@ skipping 10 matching lines @@
   }
 
   // Compute the state and type of an exit frame given a frame
   // pointer. Used when constructing the first stack frame seen by an
   // iterator and the frames following entry frames.
   static Type GetStateForFramePointer(Address fp, State* state);
   static Address ComputeStackPointer(Address fp);
   static void FillState(Address fp, Address sp, State* state);
 
  protected:
-  inline explicit ExitFrame(StackFrameIterator* iterator);
+  inline explicit ExitFrame(StackFrameIteratorBase* iterator);
 
   virtual Address GetCallerStackPointer() const;
 
  private:
   virtual void ComputeCallerState(State* state) const;
 
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class StandardFrame: public StackFrame {
  public:
   // Testers.
   virtual bool is_standard() const { return true; }
 
   // Accessors.
   inline Object* context() const;
 
   // Access the expressions in the stack frame including locals.
   inline Object* GetExpression(int index) const;
   inline void SetExpression(int index, Object* value);
   int ComputeExpressionsCount() const;
   static Object* GetExpression(Address fp, int index);
 
   virtual void SetCallerFp(Address caller_fp);
 
   static StandardFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_standard());
     return static_cast<StandardFrame*>(frame);
   }
 
  protected:
-  inline explicit StandardFrame(StackFrameIterator* iterator);
+  inline explicit StandardFrame(StackFrameIteratorBase* iterator);
 
   virtual void ComputeCallerState(State* state) const;
 
   // Accessors.
   inline Address caller_fp() const;
   inline Address caller_pc() const;
 
   // Computes the address of the PC field in the standard frame given
   // by the provided frame pointer.
   static inline Address ComputePCAddress(Address fp);
@@ skipping 16 matching lines @@
 
   // Determines if the standard frame for the given frame pointer is a
   // construct frame.
   static inline bool IsConstructFrame(Address fp);
 
   // Used by OptimizedFrames and StubFrames.
   void IterateCompiledFrame(ObjectVisitor* v) const;
 
  private:
   friend class StackFrame;
-  friend class StackFrameIterator;
+  friend class SafeStackFrameIterator;
 };
 
 
 class FrameSummary BASE_EMBEDDED {
  public:
   FrameSummary(Object* receiver,
                JSFunction* function,
                Code* code,
                int offset,
                bool is_constructor)
@@ skipping 85 matching lines @@
     ASSERT(frame->is_java_script());
     return static_cast<JavaScriptFrame*>(frame);
   }
 
   static void PrintTop(Isolate* isolate,
                        FILE* file,
                        bool print_args,
                        bool print_line_number);
 
  protected:
-  inline explicit JavaScriptFrame(StackFrameIterator* iterator);
+  inline explicit JavaScriptFrame(StackFrameIteratorBase* iterator);
 
   virtual Address GetCallerStackPointer() const;
 
   virtual int GetNumberOfIncomingArguments() const;
 
   // Garbage collection support. Iterates over incoming arguments,
   // receiver, and any callee-saved registers.
   void IterateArguments(ObjectVisitor* v) const;
 
  private:
   inline Object* function_slot_object() const;
 
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class StubFrame : public StandardFrame {
  public:
   virtual Type type() const { return STUB; }
 
   // GC support.
   virtual void Iterate(ObjectVisitor* v) const;
 
   // Determine the code for the frame.
   virtual Code* unchecked_code() const;
 
  protected:
-  inline explicit StubFrame(StackFrameIterator* iterator);
+  inline explicit StubFrame(StackFrameIteratorBase* iterator);
 
   virtual Address GetCallerStackPointer() const;
 
   virtual int GetNumberOfIncomingArguments() const;
 
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class OptimizedFrame : public JavaScriptFrame {
  public:
   virtual Type type() const { return OPTIMIZED; }
 
   // GC support.
   virtual void Iterate(ObjectVisitor* v) const;
 
   virtual int GetInlineCount();
 
   // Return a list with JSFunctions of this frame.
   // The functions are ordered bottom-to-top (i.e. functions.last()
   // is the top-most activation)
   virtual void GetFunctions(List<JSFunction*>* functions);
 
   virtual void Summarize(List<FrameSummary>* frames);
 
   DeoptimizationInputData* GetDeoptimizationData(int* deopt_index);
 
  protected:
-  inline explicit OptimizedFrame(StackFrameIterator* iterator);
+  inline explicit OptimizedFrame(StackFrameIteratorBase* iterator);
 
  private:
   JSFunction* LiteralAt(FixedArray* literal_array, int literal_id);
 
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 // Arguments adaptor frames are automatically inserted below
 // JavaScript frames when the actual number of parameters does not
 // match the formal number of parameters.
 class ArgumentsAdaptorFrame: public JavaScriptFrame {
  public:
   virtual Type type() const { return ARGUMENTS_ADAPTOR; }
 
   // Determine the code for the frame.
   virtual Code* unchecked_code() const;
 
   static ArgumentsAdaptorFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_arguments_adaptor());
     return static_cast<ArgumentsAdaptorFrame*>(frame);
   }
 
   // Printing support.
   virtual void Print(StringStream* accumulator,
                      PrintMode mode,
                      int index) const;
 
  protected:
-  inline explicit ArgumentsAdaptorFrame(StackFrameIterator* iterator);
+  inline explicit ArgumentsAdaptorFrame(StackFrameIteratorBase* iterator);
 
   virtual int GetNumberOfIncomingArguments() const;
 
   virtual Address GetCallerStackPointer() const;
 
  private:
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class InternalFrame: public StandardFrame {
  public:
   virtual Type type() const { return INTERNAL; }
 
   // Garbage collection support.
   virtual void Iterate(ObjectVisitor* v) const;
 
   // Determine the code for the frame.
   virtual Code* unchecked_code() const;
 
   static InternalFrame* cast(StackFrame* frame) {
     ASSERT(frame->is_internal());
     return static_cast<InternalFrame*>(frame);
   }
 
  protected:
-  inline explicit InternalFrame(StackFrameIterator* iterator);
+  inline explicit InternalFrame(StackFrameIteratorBase* iterator);
 
   virtual Address GetCallerStackPointer() const;
 
  private:
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 class StubFailureTrampolineFrame: public StandardFrame {
  public:
   // sizeof(Arguments) - sizeof(Arguments*) is 3 * kPointerSize), but the
   // presubmit script complains about using sizeof() on a type.
   static const int kFirstRegisterParameterFrameOffset =
       StandardFrameConstants::kMarkerOffset - 3 * kPointerSize;
 
   static const int kCallerStackParameterCountFrameOffset =
       StandardFrameConstants::kMarkerOffset - 2 * kPointerSize;
 
   virtual Type type() const { return STUB_FAILURE_TRAMPOLINE; }
 
   // Get the code associated with this frame.
   // This method could be called during marking phase of GC.
   virtual Code* unchecked_code() const;
 
   virtual void Iterate(ObjectVisitor* v) const;
 
   // Architecture-specific register description.
   static Register fp_register();
   static Register context_register();
 
  protected:
   inline explicit StubFailureTrampolineFrame(
-      StackFrameIterator* iterator);
+      StackFrameIteratorBase* iterator);
 
   virtual Address GetCallerStackPointer() const;
 
  private:
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
 // 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:
-  inline explicit ConstructFrame(StackFrameIterator* iterator);
+  inline explicit ConstructFrame(StackFrameIteratorBase* iterator);
 
  private:
-  friend class StackFrameIterator;
+  friend class StackFrameIteratorBase;
 };
 
 
-class StackFrameIterator BASE_EMBEDDED {
+class StackFrameIteratorBase BASE_EMBEDDED {
  public:
-  // An iterator that iterates over the isolate's current thread's stack,
-  explicit StackFrameIterator(Isolate* isolate);
-
-  // An iterator that iterates over a given thread's stack.
-  StackFrameIterator(Isolate* isolate, ThreadLocalTop* t);
-
-  // An iterator that can start from a given FP address.
-  // If use_top, then work as usual, if fp isn't NULL, use it,
-  // otherwise, do nothing.
-  StackFrameIterator(Isolate* isolate, bool use_top, Address fp, Address sp);
-
-  StackFrame* frame() const {
-    ASSERT(!done());
-    return frame_;
-  }
-
   Isolate* isolate() const { return isolate_; }
 
   bool done() const { return frame_ == NULL; }
-  void Advance() { (this->*advance_)(); }
 
-  // Go back to the first frame.
-  void Reset();
+ protected:
+  // An iterator that iterates over a given thread's stack.
+  StackFrameIteratorBase(Isolate* isolate, bool can_access_heap_objects);
 
- private:
   Isolate* isolate_;
 #define DECLARE_SINGLETON(ignore, type) type type##_;
   STACK_FRAME_TYPE_LIST(DECLARE_SINGLETON)
 #undef DECLARE_SINGLETON
   StackFrame* frame_;
   StackHandler* handler_;
-  ThreadLocalTop* thread_;
-  Address fp_;
-  Address sp_;
-  void (StackFrameIterator::*advance_)();
+  const bool can_access_heap_objects_;
 
   StackHandler* handler() const {
     ASSERT(!done());
     return handler_;
   }
 
   // Get the type-specific frame singleton in a given state.
   StackFrame* SingletonFor(StackFrame::Type type, StackFrame::State* state);
   // A helper function, can return a NULL pointer.
   StackFrame* SingletonFor(StackFrame::Type type);
 
-  void AdvanceWithHandler();
-  void AdvanceWithoutHandler();
+ private:
+  friend class StackFrame;
+  DISALLOW_COPY_AND_ASSIGN(StackFrameIteratorBase);
+};
 
-  friend class StackFrame;
-  friend class SafeStackFrameIterator;
+
+class StackFrameIterator: public StackFrameIteratorBase {
+ public:
+  // An iterator that iterates over the isolate's current thread's stack,
+  explicit StackFrameIterator(Isolate* isolate);
+  // An iterator that iterates over a given thread's stack.
+  StackFrameIterator(Isolate* isolate, ThreadLocalTop* t);
+
+  StackFrame* frame() const {
+    ASSERT(!done());
+    return frame_;
+  }
+  void Advance();
+
+ private:
+  // Go back to the first frame.
+  void Reset(ThreadLocalTop* top);
+
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
 
 // Iterator that supports iterating through all JavaScript frames.
-template<typename Iterator>
-class JavaScriptFrameIteratorTemp BASE_EMBEDDED {
+class JavaScriptFrameIterator BASE_EMBEDDED {
  public:
-  inline explicit JavaScriptFrameIteratorTemp(Isolate* isolate);
-
-  inline JavaScriptFrameIteratorTemp(Isolate* isolate, ThreadLocalTop* top);
-
+  inline explicit JavaScriptFrameIterator(Isolate* isolate);
+  inline JavaScriptFrameIterator(Isolate* isolate, ThreadLocalTop* top);
   // Skip frames until the frame with the given id is reached.
-  explicit JavaScriptFrameIteratorTemp(StackFrame::Id id) { AdvanceToId(id); }
-
-  inline JavaScriptFrameIteratorTemp(Isolate* isolate, StackFrame::Id id);
-
-  JavaScriptFrameIteratorTemp(Address fp,
-                              Address sp,
-                              Address low_bound,
-                              Address high_bound) :
-      iterator_(fp, sp, low_bound, high_bound) {
-    if (!done()) Advance();
-  }
-
-  JavaScriptFrameIteratorTemp(Isolate* isolate,
-                              Address fp,
-                              Address sp,
-                              Address low_bound,
-                              Address high_bound) :
-      iterator_(isolate, fp, sp, low_bound, high_bound) {
-    if (!done()) Advance();
-  }
+  JavaScriptFrameIterator(Isolate* isolate, StackFrame::Id id);
 
   inline JavaScriptFrame* frame() const;
 
   bool done() const { return iterator_.done(); }
   void Advance();
 
   // Advance to the frame holding the arguments for the current
   // frame. This only affects the current frame if it has adapted
   // arguments.
   void AdvanceToArgumentsFrame();
 
-  // Go back to the first frame.
-  void Reset();
-
  private:
-  inline void AdvanceToId(StackFrame::Id id);
-
-  Iterator iterator_;
+  StackFrameIterator iterator_;
 };
 
 
-typedef JavaScriptFrameIteratorTemp<StackFrameIterator> JavaScriptFrameIterator;
-
-
 // NOTE: The stack trace frame iterator is an iterator that only
 // traverse proper JavaScript frames; that is JavaScript frames that
 // have proper JavaScript functions. This excludes the problematic
 // functions in runtime.js.
 class StackTraceFrameIterator: public JavaScriptFrameIterator {
  public:
-  StackTraceFrameIterator();
   explicit StackTraceFrameIterator(Isolate* isolate);
   void Advance();
 
  private:
   bool IsValidFrame();
 };
 
 
-class SafeStackFrameIterator BASE_EMBEDDED {
+class SafeStackFrameIterator: public StackFrameIteratorBase {
  public:
   SafeStackFrameIterator(Isolate* isolate,
                          Address fp, Address sp,
                          Address low_bound, Address high_bound);
 
-  StackFrame* frame() const {
-    ASSERT(is_working_iterator_);
-    return iterator_.frame();
-  }
-
-  bool done() const { return iteration_done_ ? true : iterator_.done(); }
-
+  inline JavaScriptFrame* frame() const;
   void Advance();
-  void Reset();
-
-  static bool is_active(Isolate* isolate);
-
-  static bool IsWithinBounds(
-      Address low_bound, Address high_bound, Address addr) {
-    return low_bound <= addr && addr <= high_bound;
-  }
 
  private:
-  class StackAddressValidator {
-   public:
-    StackAddressValidator(Address low_bound, Address high_bound)
-        : low_bound_(low_bound), high_bound_(high_bound) { }
-    bool IsValid(Address addr) const {
-      return IsWithinBounds(low_bound_, high_bound_, addr);
-    }
-   private:
-    Address low_bound_;
-    Address high_bound_;
-  };
-
-  class ExitFrameValidator {
-   public:
-    explicit ExitFrameValidator(const StackAddressValidator& validator)
-        : validator_(validator) { }
-    ExitFrameValidator(Address low_bound, Address high_bound)
-        : validator_(low_bound, high_bound) { }
-    bool IsValidFP(Address fp);
-   private:
-    StackAddressValidator validator_;
-  };
+  void AdvanceOneFrame();
 
   bool IsValidStackAddress(Address addr) const {
-    return stack_validator_.IsValid(addr);
+    return low_bound_ <= addr && addr <= high_bound_;
   }
-  bool CanIterateHandles(StackFrame* frame, StackHandler* handler);
   bool IsValidFrame(StackFrame* frame) const;
   bool IsValidCaller(StackFrame* frame);
-  static bool IsValidTop(Isolate* isolate,
-                         Address low_bound, Address high_bound);
+  bool IsValidExitFrame(Address fp) const;
+  bool IsValidTop(ThreadLocalTop* top) const;
 
-  // This is a nasty hack to make sure the active count is incremented
-  // before the constructor for the embedded iterator is invoked. This
-  // is needed because the constructor will start looking at frames
-  // right away and we need to make sure it doesn't start inspecting
-  // heap objects.
-  class ActiveCountMaintainer BASE_EMBEDDED {
-   public:
-    explicit ActiveCountMaintainer(Isolate* isolate);
-    ~ActiveCountMaintainer();
-   private:
-    Isolate* isolate_;
-  };
-
-  ActiveCountMaintainer maintainer_;
-  StackAddressValidator stack_validator_;
-  const bool is_valid_top_;
-  const bool is_valid_fp_;
-  const bool is_working_iterator_;
-  bool iteration_done_;
-  StackFrameIterator iterator_;
+  const Address low_bound_;
+  const Address high_bound_;
 };
 
 
-typedef JavaScriptFrameIteratorTemp<SafeStackFrameIterator>
-    SafeJavaScriptFrameIterator;
-
-
-class SafeStackTraceFrameIterator: public SafeJavaScriptFrameIterator {
- public:
-  explicit SafeStackTraceFrameIterator(Isolate* isolate,
-                                       Address fp, Address sp,
-                                       Address low_bound, Address high_bound);
-  void Advance();
-};
-
-
 class StackFrameLocator BASE_EMBEDDED {
  public:
   explicit StackFrameLocator(Isolate* isolate) : iterator_(isolate) {}
 
   // Find the nth JavaScript frame on the stack. The caller must
   // guarantee that such a frame exists.
   JavaScriptFrame* FindJavaScriptFrame(int n);
 
  private:
   StackFrameIterator iterator_;
 };
 
 
 // Reads all frames on the current stack and copies them into the current
 // zone memory.
 Vector<StackFrame*> CreateStackMap(Isolate* isolate, Zone* zone);
 
 } }  // namespace v8::internal
 
 #endif  // V8_FRAMES_H_