Fix issue 265 by handling extra statement state on the frame based on...

src/jump-target.h

 // Copyright 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 40 matching lines @@
 class JumpTarget : public ZoneObject {  // Shadows are dynamically allocated.
  public:
   // Forward-only jump targets can only be reached by forward CFG edges.
   enum Directionality { FORWARD_ONLY, BIDIRECTIONAL };
 
   // Construct a jump target with a given code generator used to generate
   // code and to provide access to a current frame.
   explicit JumpTarget(CodeGenerator* cgen,
                       Directionality direction = FORWARD_ONLY);
 
+  // Construct a jump target without a code generator.  A code
+  // generator must be supplied before using the jump target as a
+  // label.  This is useful, eg, when break targets are embedded in
+  // AST nodes.
+  JumpTarget();
+
+  // Supply a code generator and directionality to an already
+  // constructed jump target.  This function expects to be given a
+  // non-null code generator, and to be called only when the code
+  // generator is not yet set.
+  virtual void Initialize(CodeGenerator* cgen,
+                          Directionality direction = FORWARD_ONLY);
+
   virtual ~JumpTarget() { Unuse(); }
 
+  // Treat the jump target as a fresh one.  The state is reset and
+  // pointed-to virtual frames are deallocated.  There should be no
+  // dangling jumps to the target.
+  void Unuse();
+
+  // Reset the internal state of this jump target.  Pointed-to virtual
+  // frames are not deallocated and dangling jumps to the target are
+  // left dangling.
+  void Reset();
+
   // Accessors.
   CodeGenerator* code_generator() const { return cgen_; }
 
   Label* entry_label() { return &entry_label_; }
 
   VirtualFrame* entry_frame() const { return entry_frame_; }
   void set_entry_frame(VirtualFrame* frame) {
     entry_frame_ = frame;
   }
 
   void make_bidirectional() { direction_ = BIDIRECTIONAL; }
 
   // Predicates testing the state of the encapsulated label.
   bool is_bound() const { return is_bound_; }
   bool is_linked() const { return is_linked_; }
   bool is_unused() const { return !is_bound() && !is_linked(); }
 
-  // Treat the jump target as a fresh one.  The expected frame if any
-  // will be deallocated and there should be no dangling jumps to the
-  // target (thus no reaching frames).
-  void Unuse();
-
-  // Reset the internal state of this jump target.  Pointed-to virtual
-  // frames are not deallocated and dangling jumps to the target are
-  // left dangling.
-  void Reset();
-
   // Emit a jump to the target.  There must be a current frame at the
   // jump and there will be no current frame after the jump.
-  void Jump();
+  virtual void Jump();
   void Jump(Result* arg);
   void Jump(Result* arg0, Result* arg1);
   void Jump(Result* arg0, Result* arg1, Result* arg2);
 
   // Emit a conditional branch to the target.  There must be a current
   // frame at the branch.  The current frame will fall through to the
   // code after the branch.
-  void Branch(Condition cc, Hint hint = no_hint);
+  virtual void Branch(Condition cc, Hint hint = no_hint);
   void Branch(Condition cc, Result* arg, Hint hint = no_hint);
   void Branch(Condition cc, Result* arg0, Result* arg1, Hint hint = no_hint);
   void Branch(Condition cc,
               Result* arg0,
               Result* arg1,
               Result* arg2,
               Hint hint = no_hint);
   void Branch(Condition cc,
               Result* arg0,
               Result* arg1,
               Result* arg2,
               Result* arg3,
               Hint hint = no_hint);
 
   // Bind a jump target.  If there is no current frame at the binding
   // site, there must be at least one frame reaching via a forward
   // jump.
   //
   // The number of mergable elements is a number of frame elements
   // counting from the top down which must be "mergable" (not
   // constants or copies) in the entry frame at the jump target.
   // Backward jumps to the target must contain the same constants and
   // sharing as the entry frame, except for the mergable elements.
   //
   // A mergable elements argument of kAllElements indicates that all
   // frame elements must be mergable.  Mergable elements are ignored
   // completely for forward-only jump targets.
-  void Bind(int mergable_elements = kAllElements);
+  virtual void Bind(int mergable_elements = kAllElements);
   void Bind(Result* arg, int mergable_elements = kAllElements);
   void Bind(Result* arg0, Result* arg1, int mergable_elements = kAllElements);
   void Bind(Result* arg0,
             Result* arg1,
             Result* arg2,
             int mergable_elements = kAllElements);
   void Bind(Result* arg0,
             Result* arg1,
             Result* arg2,
             Result* arg3,
@@ skipping 63 matching lines @@
 // and will drop state from nested statements as part of merging.
 //
 // Break targets are used for return, break, and continue targets.
 
 class BreakTarget : public JumpTarget {
  public:
   // Construct a break target without a code generator.  A code
   // generator must be supplied before using the break target as a
   // label.  This is useful, eg, when break targets are embedded in AST
   // nodes.
-  BreakTarget();
+  BreakTarget() {}
 
-  // Supply a code generator and directionality to an already
-  // constructed jump target.  This function expects to be given a
-  // non-null code generator, and to be called only when the code
-  // generator is not yet set.
-  void Initialize(CodeGenerator* cgen,
-                  Directionality direction = FORWARD_ONLY);
+  // Supply a code generator, expected expression stack height, and
+  // directionality to an already constructed break target.  This
+  // function expects to be given a non-null code generator, and to be
+  // called only when the code generator is not yet set.
+  virtual void Initialize(CodeGenerator* cgen,
+                          Directionality direction = FORWARD_ONLY);
 
   // Copy the state of this break target to the destination.  The
   // lists of forward-reaching frames and merge-point labels are
   // copied.  All virtual frame pointers are copied, not the
   // pointed-to frames.  The previous state of the destination is
   // overwritten, without deallocating pointed-to virtual frames.
   void CopyTo(BreakTarget* destination);
 
+  // Emit a jump to the target.  There must be a current frame at the
+  // jump and there will be no current frame after the jump.
+  virtual void Jump();
+
+  // Emit a conditional branch to the target.  There must be a current
+  // frame at the branch.  The current frame will fall through to the
+  // code after the branch.
+  virtual void Branch(Condition cc, Hint hint = no_hint);
+
+  // Bind a break target.  If there is no current frame at the binding
+  // site, there must be at least one frame reaching via a forward
+  // jump.
+  virtual void Bind(int mergable_elements = kAllElements);
+
+  // Setter for expected height.
+  void set_expected_height(int expected) { expected_height_ = expected; }
+
  private:
+  // The expected height of the expression stack where the target will
+  // be bound, statically known at initialization time.
+  int expected_height_;
+
   DISALLOW_COPY_AND_ASSIGN(BreakTarget);
 };
 
 
 // -------------------------------------------------------------------------
 // Shadow break targets
 //
 // A shadow break target represents a break target that is temporarily
 // shadowed by another one (represented by the original during
 // shadowing).  They are used to catch jumps to labels in certain
@@ skipping 32 matching lines @@
   bool is_shadowing_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ShadowTarget);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JUMP_TARGET_H_