Checking for stack height equality between full codegen and hydrogen.

src/full-codegen.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_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_H_
 
 #include "v8.h"
 
 #include "allocation.h"
 #include "assert-scope.h"
 #include "ast.h"
 #include "code-stubs.h"
 #include "codegen.h"
 #include "compiler.h"
 #include "data-flow.h"
 #include "globals.h"
 #include "objects.h"
 
 namespace v8 {
 namespace internal {
 
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+
+class StackHeightWrapper {
+ public:
+  StackHeightWrapper() : stack_height_(0) { }
+
+  void updateBy(int incrementBy) {
+    stack_height_ += incrementBy;
+    ASSERT(stack_height_ >= 0);
+  }
+
+  int get() const { return stack_height_; }
+
+ private:
+  int stack_height_;
+};
+
+#else
+
+class StackHeightWrapper {
+ public:
+  StackHeightWrapper() { }
+  void updateBy(int incrementBy) { }
+  int get() const { return 0; }
+};
+
+#endif  // defined(COMPARE_OPT_STACK_HEIGHT)
+
 // Forward declarations.
 class JumpPatchSite;
 
 // AST node visitor which can tell whether a given statement will be breakable
 // when the code is compiled by the full compiler in the debugger. This means
 // that there will be an IC (load/store/call) in the code generated for the
 // debugger to piggybag on.
 class BreakableStatementChecker: public AstVisitor {
  public:
   explicit BreakableStatementChecker(Zone* zone) : is_breakable_(false) {
@@ skipping 115 matching lines @@
     // return and give it a chance to generate cleanup code.  Return the
     // next outer statement in the nesting stack.  We accumulate in
     // *stack_depth the amount to drop the stack and in *context_length the
     // number of context chain links to unwind as we traverse the nesting
     // stack from an exit to its target.
     virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
       return previous_;
     }
 
    protected:
+    FullCodeGenerator* codegen() { return codegen_; }
+
     MacroAssembler* masm() { return codegen_->masm(); }
 
     FullCodeGenerator* codegen_;
     NestedStatement* previous_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(NestedStatement);
   };
 
   // A breakable statement such as a block.
@@ skipping 390 matching lines @@
                   TypeFeedbackId id = TypeFeedbackId::None());
   void CallStoreIC(TypeFeedbackId id = TypeFeedbackId::None());
 
   void SetFunctionPosition(FunctionLiteral* fun);
   void SetReturnPosition(FunctionLiteral* fun);
   void SetStatementPosition(Statement* stmt);
   void SetExpressionPosition(Expression* expr);
   void SetStatementPosition(int pos);
   void SetSourcePosition(int pos);
 
+  void AsmPush(Register reg) {
+    masm()->push(reg);
+    UpdateStackHeight(1);
+  }
+
+  void AsmPush(const Operand& op);
+
+  void AsmPushHandle(Handle<Object> handle) {
+    masm()->Push(handle);
+    UpdateStackHeight(1);
+  }
+
+  void AsmPushSmi(Smi* smi) {
+    masm()->Push(smi);
+    UpdateStackHeight(1);
+  }
+
+  void AsmPop(Register reg) {
+    masm()->pop(reg);
+    UpdateStackHeight(-1);
+  }
+
+  void AsmInvokeBuiltin(Builtins::JavaScript id,
+                     InvokeFlag flag,
+                     int arg_count,
+                     const CallWrapper& call_wrapper = NullCallWrapper()) {
+    masm()->InvokeBuiltin(id, flag, call_wrapper);
+    UpdateStackHeight(-arg_count);
+  }
+
+  void AsmDrop(int n) {
+    masm()->Drop(n);
+    UpdateStackHeight(-n);
+  }
+
+  void AsmCallRuntime(const Runtime::Function* f,
+                 int num_arguments,
+                 SaveFPRegsMode save_doubles = kDontSaveFPRegs) {
+    masm()->CallRuntime(f, num_arguments, save_doubles);
+    UpdateStackHeight(-num_arguments);
+  }
+
+  void AsmCallRuntime(Runtime::FunctionId id,
+                 int num_arguments,
+                 SaveFPRegsMode save_doubles = kDontSaveFPRegs) {
+    masm()->CallRuntime(id, num_arguments, save_doubles);
+    UpdateStackHeight(-num_arguments);
+  }
+
+  void AsmPushTryHandler(StackHandler::Kind kind, int handler_index) {
+    masm()->PushTryHandler(kind, handler_index);
+    UpdateStackHeight(StackHandlerConstants::kSize / kPointerSize);
+  }
+
+  void AsmPopTryHandler() {
+    masm()->PopTryHandler();
+    UpdateStackHeight(-StackHandlerConstants::kSize / kPointerSize);
+  }
+
+  // Call a code stub.  Generate the code if necessary.
+  void AsmCallStub(CodeStub* stub,
+                   int arg_count) {
+    masm()->CallStub(stub);
+    UpdateStackHeight(-arg_count);
+  }
+
   // Non-local control flow support.
   void EnterFinallyBlock();
   void ExitFinallyBlock();
 
   // Loop nesting counter.
   int loop_depth() { return loop_depth_; }
   void increment_loop_depth() { loop_depth_++; }
   void decrement_loop_depth() {
     ASSERT(loop_depth_ > 0);
     loop_depth_--;
@@ skipping 40 matching lines @@
 
   void Generate();
   void PopulateDeoptimizationData(Handle<Code> code);
   void PopulateTypeFeedbackInfo(Handle<Code> code);
 
   Handle<FixedArray> handler_table() { return handler_table_; }
 
   struct BailoutEntry {
     BailoutId id;
     unsigned pc_and_state;
+    int stack_height;
   };
 
   struct BackEdgeEntry {
     BailoutId id;
     unsigned pc;
     uint32_t loop_depth;
   };
 
   class ExpressionContext BASE_EMBEDDED {
    public:
@@ skipping 164 matching lines @@
     virtual void PlugTOS() const;
     virtual void DropAndPlug(int count, Register reg) const;
     virtual void PrepareTest(Label* materialize_true,
                              Label* materialize_false,
                              Label** if_true,
                              Label** if_false,
                              Label** fall_through) const;
     virtual bool IsEffect() const { return true; }
   };
 
+  void CheckStackHeight() {
+#if defined(VERIFY_STACK_HEIGHT)
+    AddStackHeightVerifier();
+#endif  // defined(VERIFY_STACK_HEIGHT)
+  }
+
+  void UpdateStackHeight(int difference) {
+    stack_height_.updateBy(difference);
+  }
+
+  void SetStackHeight(StackHeightWrapper height) {
+    stack_height_ = height;
+  }
+
+  StackHeightWrapper CurrentStackHeight() {
+    return stack_height_;
+  }
+
+#if defined(VERIFY_STACK_HEIGHT)
+  void AddStackHeightVerifier();
+#endif  // defined(VERIFY_STACK_HEIGHT)
+
   MacroAssembler* masm_;
   CompilationInfo* info_;
   Scope* scope_;
   Label return_label_;
   NestedStatement* nesting_stack_;
   int loop_depth_;
+  StackHeightWrapper stack_height_;
   ZoneList<Handle<Object> >* globals_;
   Handle<FixedArray> modules_;
   int module_index_;
   const ExpressionContext* context_;
   ZoneList<BailoutEntry> bailout_entries_;
   ZoneList<BackEdgeEntry> back_edges_;
   int ic_total_count_;
   Handle<FixedArray> handler_table_;
   Handle<Cell> profiling_counter_;
   bool generate_debug_code_;
@@ skipping 110 matching lines @@
 
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_