Checking for stack height equality between full codegen and hydrogen.

src/objects.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_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include "allocation.h"
 #include "assert-scope.h"
 #include "builtins.h"
@@ skipping 5207 matching lines @@
  private:
   static int IndexForEntry(int i) {
     return kFirstDeoptEntryIndex + (i * kDeoptEntrySize);
   }
 
   static int LengthFor(int entry_count) {
     return IndexForEntry(entry_count);
   }
 };
 
+#if (defined(DEBUG) || defined(VERIFY_STACK_HEIGHT)) && V8_TARGET_ARCH_IA32
+#define COMPARE_OPT_STACK_HEIGHT
+#endif
 
 // DeoptimizationOutputData is a fixed array used to hold the deoptimization
 // data for code generated by the full compiler.
-// The format of the these objects is
+// The format of the these objects in release mode is
 //   [i * 2]: Ast ID for ith deoptimization.
 //   [i * 2 + 1]: PC and state of ith deoptimization
+// In debug mode, we use 3 slots per deopt point, with the stack height
+// information at [i * 3 + 2] slots
 class DeoptimizationOutputData: public FixedArray {
  public:
-  int DeoptPoints() { return length() / 2; }
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+  static const int kDeoptPointElementCount = 3;
+
+  Smi* StackHeight(int index) {
+    return Smi::cast(get(2 + index * kDeoptPointElementCount));
+  }
+
+  void SetStackHeight(int index, Smi* stack_height) {
+    set(2 + index * kDeoptPointElementCount, stack_height);
+  }
+
+#else
+  static const int kDeoptPointElementCount = 2;
+#endif
+
+  int DeoptPoints() { return length() / kDeoptPointElementCount; }
 
   BailoutId AstId(int index) {
-    return BailoutId(Smi::cast(get(index * 2))->value());
+    return BailoutId(Smi::cast(get(index * kDeoptPointElementCount))->value());
   }
 
   void SetAstId(int index, BailoutId id) {
-    set(index * 2, Smi::FromInt(id.ToInt()));
+    set(index * kDeoptPointElementCount, Smi::FromInt(id.ToInt()));
   }
 
-  Smi* PcAndState(int index) { return Smi::cast(get(1 + index * 2)); }
-  void SetPcAndState(int index, Smi* offset) { set(1 + index * 2, offset); }
+  Smi* PcAndState(int index) {
+    return Smi::cast(get(1 + index * kDeoptPointElementCount));
+  }
+
+  void SetPcAndState(int index, Smi* offset) {
+    set(1 + index * kDeoptPointElementCount, offset);
+  }
 
   static int LengthOfFixedArray(int deopt_points) {
-    return deopt_points * 2;
+    return deopt_points * kDeoptPointElementCount;
   }
 
   // Allocates a DeoptimizationOutputData.
   static Handle<DeoptimizationOutputData> New(Isolate* isolate,
                                               int number_of_deopt_points,
                                               PretenureFlag pretenure);
 
   // Casting.
   static inline DeoptimizationOutputData* cast(Object* obj);
 
@@ skipping 1947 matching lines @@
   // shared function info.
   void DisableOptimization(BailoutReason reason);
 
   inline BailoutReason DisableOptimizationReason();
 
   // Lookup the bailout ID and ASSERT that it exists in the non-optimized
   // code, returns whether it asserted (i.e., always true if assertions are
   // disabled).
   bool VerifyBailoutId(BailoutId id);
 
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+  // Get expected stack height after deoptimization
+  int GetExpectedStackHeight(BailoutId id);
+#endif
+
   // [source code]: Source code for the function.
   bool HasSourceCode();
   Handle<Object> GetSourceCode();
 
   // Number of times the function was optimized.
   inline int opt_count();
   inline void set_opt_count(int opt_count);
 
   // Number of times the function was deoptimized.
   inline void set_deopt_count(int value);
@@ skipping 3882 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_