Checking for stack height equality between full codegen and hydrogen.

src/hydrogen.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_HYDROGEN_H_
 #define V8_HYDROGEN_H_
 
 #include "v8.h"
 
 #include "accessors.h"
@@ skipping 91 matching lines @@
   void UpdateEnvironment(HEnvironment* env);
   HBasicBlock* parent_loop_header() const { return parent_loop_header_; }
 
   void set_parent_loop_header(HBasicBlock* block) {
     ASSERT(parent_loop_header_ == NULL);
     parent_loop_header_ = block;
   }
 
   bool HasParentLoopHeader() const { return parent_loop_header_ != NULL; }
 
-  void SetJoinId(BailoutId ast_id);
+  void SetJoinId(BailoutId ast_id, int stack_checker_offset = 0);
 
   int PredecessorIndexOf(HBasicBlock* predecessor) const;
   HPhi* AddNewPhi(int merged_index);
   HSimulate* AddNewSimulate(BailoutId ast_id,
                             HSourcePosition position,
-                            RemovableSimulate removable = FIXED_SIMULATE) {
-    HSimulate* instr = CreateSimulate(ast_id, removable);
-    AddInstruction(instr, position);
-    return instr;
-  }
+                            RemovableSimulate removable = FIXED_SIMULATE,
+                            int arguments_offset = 0);
   void AssignCommonDominator(HBasicBlock* other);
   void AssignLoopSuccessorDominators();
 
   // If a target block is tagged as an inline function return, all
   // predecessors should contain the inlined exit sequence:
   //
   // LeaveInlined
   // Simulate (caller's environment)
   // Goto (target block)
   bool IsInlineReturnTarget() const { return is_inline_return_target_; }
@@ skipping 25 matching lines @@
 
   inline Zone* zone() const;
 
 #ifdef DEBUG
   void Verify();
 #endif
 
  protected:
   friend class HGraphBuilder;
 
-  HSimulate* CreateSimulate(BailoutId ast_id, RemovableSimulate removable);
+  HSimulate* CreateSimulate(BailoutId ast_id, RemovableSimulate removable,
+                            int arguments_offset);
   void Finish(HControlInstruction* last, HSourcePosition position);
   void FinishExit(HControlInstruction* instruction, HSourcePosition position);
   void Goto(HBasicBlock* block,
             HSourcePosition position,
             FunctionState* state = NULL,
             bool add_simulate = true);
   void GotoNoSimulate(HBasicBlock* block, HSourcePosition position) {
     Goto(block, position, NULL, false);
   }
 
@@ skipping 517 matching lines @@
 
   bool is_special_index(int i) const {
     return i >= parameter_count() && i < parameter_count() + specials_count();
   }
 
   void PrintTo(StringStream* stream);
   void PrintToStd();
 
   Zone* zone() const { return zone_; }
 
+  void VerifyStackHeight(BailoutId ast_id,
+                         int hydrogen_id,
+                         int stack_height_offset = 0);
+
  private:
   HEnvironment(const HEnvironment* other, Zone* zone);
 
   HEnvironment(HEnvironment* outer,
                Handle<JSFunction> closure,
                FrameType frame_type,
                int arguments,
                Zone* zone);
 
   // Create an artificial stub environment (e.g. for argument adaptor or
@@ skipping 570 matching lines @@
                             P5 p5, P6 p6, P7 p7, P8 p8) {
     return AddInstruction(NewUncasted<I>(p1, p2, p3, p4, p5, p6, p7, p8));
   }
 
   template<class I, class P1, class P2, class P3, class P4,
            class P5, class P6, class P7, class P8>
   I* Add(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) {
     return AddInstructionTyped(New<I>(p1, p2, p3, p4, p5, p6, p7, p8));
   }
 
-  void AddSimulate(BailoutId id, RemovableSimulate removable = FIXED_SIMULATE);
+  void AddSimulate(BailoutId id, RemovableSimulate removable = FIXED_SIMULATE,
+                   int arguments_offset = 0);
 
  protected:
   virtual bool BuildGraph() = 0;
 
   HBasicBlock* CreateBasicBlock(HEnvironment* env);
   HBasicBlock* CreateLoopHeaderBlock();
 
   HValue* BuildCheckHeapObject(HValue* object);
   HValue* BuildCheckString(HValue* string);
   HValue* BuildWrapReceiver(HValue* object, HValue* function);
@@ skipping 574 matching lines @@
 inline HInstruction* HGraphBuilder::AddUncasted<HDeoptimize>(
     const char* reason, Deoptimizer::BailoutType type) {
   return Add<HDeoptimize>(reason, type);
 }
 
 
 template<>
 inline HSimulate* HGraphBuilder::Add<HSimulate>(
     BailoutId id,
     RemovableSimulate removable) {
-  HSimulate* instr = current_block()->CreateSimulate(id, removable);
+  HSimulate* instr = current_block()->CreateSimulate(id, removable, 0);
   AddInstruction(instr);
   return instr;
 }
 
 
 template<>
 inline HSimulate* HGraphBuilder::Add<HSimulate>(
     BailoutId id) {
   return Add<HSimulate>(id, FIXED_SIMULATE);
 }
@@ skipping 894 matching lines @@
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_