Add handling for deopt and argument adaptor frames.

src/compiler/common-operator.h

Index: src/compiler/common-operator.h
diff --git a/src/compiler/common-operator.h b/src/compiler/common-operator.h
index 137155e0f6f2302fd36925c2c31533ac0520cbf1..925807b6ce4213aaf47b31877d443c695e4b655d 100644
--- a/src/compiler/common-operator.h
+++ b/src/compiler/common-operator.h
@@ -6,6 +6,7 @@
 #define V8_COMPILER_COMMON_OPERATOR_H_
 
 #include "src/compiler/machine-type.h"
+#include "src/unique.h"
 
 namespace v8 {
 namespace internal {
@@ -13,9 +14,6 @@ namespace internal {
 // Forward declarations.
 class ExternalReference;
 class OStream;
-template <typename>
-class Unique;
-class Zone;
 
 
 namespace compiler {
@@ -34,18 +32,29 @@ enum OutputFrameStateCombine {
 };
 
 
+enum FrameStateType { JS_FRAME, ARGUMENTS_ADAPTOR };

[Michael Starzinger, 2014/09/16 14:12:56]

nit: This needs some comments I think. How about the following?

// The type of stack frame that a FrameState node represents.
enum FrameStateType {
  JS_FRAME,          // Represents an unoptimized JavaScriptFrame. 
  ARGUMENTS_ADAPTOR  // Represents an ArgumentsAdaptorFrame.
};

[sigurds, 2014/09/17 10:02:47]

Done.

+
+
 class FrameStateCallInfo FINAL {
  public:
-  FrameStateCallInfo(BailoutId bailout_id,
-                     OutputFrameStateCombine state_combine)
-      : bailout_id_(bailout_id), frame_state_combine_(state_combine) {}
-
+  FrameStateCallInfo(FrameStateType type, BailoutId bailout_id,
+                     OutputFrameStateCombine state_combine,
+                     Unique<JSFunction> jsfunction = Unique<JSFunction>())
+      : type_(type),
+        bailout_id_(bailout_id),
+        frame_state_combine_(state_combine),
+        jsfunction_(jsfunction) {}
+
+  FrameStateType type() const { return type_; }
   BailoutId bailout_id() const { return bailout_id_; }
   OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
+  Unique<JSFunction> jsfunction() const { return jsfunction_; }
 
  private:
+  FrameStateType type_;
   BailoutId bailout_id_;
   OutputFrameStateCombine frame_state_combine_;
+  Unique<JSFunction> jsfunction_;

[Michael Starzinger, 2014/09/16 14:12:56]

nit: IMHO we should just use Handle<JSFunction> instead of Unique<JSFunction>
here. Not sure what a Unique buys us here.

For posterity only: Also this will not necessarily be a constant JSFunction in
the long run. At some point we want to support inlining of non-constant
functions when we know they have a constant underlying SharedFunctionInfo. At
that point this will become an input operand instead of a constant parameter.
Correct?

[sigurds, 2014/09/17 10:02:47]

Yes, absolutely correct. I propose leaving it as-is, and fixing it when we
support inlining based on SharedFunctionInfo without constant closure.

 };
 
 
@@ -81,8 +90,10 @@ class CommonOperatorBuilder FINAL {
   const Operator* ValueEffect(int arguments);
   const Operator* Finish(int arguments);
   const Operator* StateValues(int arguments);
-  const Operator* FrameState(BailoutId bailout_id,
-                             OutputFrameStateCombine combine);
+  const Operator* FrameState(
+      FrameStateType type, BailoutId bailout_id,
+      OutputFrameStateCombine state_combine,
+      Unique<JSFunction> jsfunction = Unique<JSFunction>());
   const Operator* Call(const CallDescriptor* descriptor);
   const Operator* Projection(size_t index);