Upgrade to 3.29
Update V8 to 3.29.88.17 and update makefiles to support building on
all the relevant platforms.
Bug: 17370214
Change-Id: Ia3407c157fd8d72a93e23d8318ccaf6ecf77fa4e
diff --git a/src/compiler/common-operator.h b/src/compiler/common-operator.h
new file mode 100644
index 0000000..a3659ad
--- /dev/null
+++ b/src/compiler/common-operator.h
@@ -0,0 +1,117 @@
+// Copyright 2013 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_COMPILER_COMMON_OPERATOR_H_
+#define V8_COMPILER_COMMON_OPERATOR_H_
+
+#include "src/compiler/machine-type.h"
+#include "src/unique.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+class ExternalReference;
+class OStream;
+
+
+namespace compiler {
+
+// Forward declarations.
+class CallDescriptor;
+struct CommonOperatorBuilderImpl;
+class Operator;
+
+
+// Flag that describes how to combine the current environment with
+// the output of a node to obtain a framestate for lazy bailout.
+enum OutputFrameStateCombine {
+ kPushOutput, // Push the output on the expression stack.
+ kIgnoreOutput // Use the frame state as-is.
+};
+
+
+// The type of stack frame that a FrameState node represents.
+enum FrameStateType {
+ JS_FRAME, // Represents an unoptimized JavaScriptFrame.
+ ARGUMENTS_ADAPTOR // Represents an ArgumentsAdaptorFrame.
+};
+
+
+class FrameStateCallInfo FINAL {
+ public:
+ FrameStateCallInfo(
+ FrameStateType type, BailoutId bailout_id,
+ OutputFrameStateCombine state_combine,
+ MaybeHandle<JSFunction> jsfunction = MaybeHandle<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_; }
+ MaybeHandle<JSFunction> jsfunction() const { return jsfunction_; }
+
+ private:
+ FrameStateType type_;
+ BailoutId bailout_id_;
+ OutputFrameStateCombine frame_state_combine_;
+ MaybeHandle<JSFunction> jsfunction_;
+};
+
+
+// Interface for building common operators that can be used at any level of IR,
+// including JavaScript, mid-level, and low-level.
+class CommonOperatorBuilder FINAL {
+ public:
+ explicit CommonOperatorBuilder(Zone* zone);
+
+ const Operator* Dead();
+ const Operator* End();
+ const Operator* Branch();
+ const Operator* IfTrue();
+ const Operator* IfFalse();
+ const Operator* Throw();
+ const Operator* Return();
+
+ const Operator* Start(int num_formal_parameters);
+ const Operator* Merge(int controls);
+ const Operator* Loop(int controls);
+ const Operator* Parameter(int index);
+
+ const Operator* Int32Constant(int32_t);
+ const Operator* Int64Constant(int64_t);
+ const Operator* Float32Constant(volatile float);
+ const Operator* Float64Constant(volatile double);
+ const Operator* ExternalConstant(const ExternalReference&);
+ const Operator* NumberConstant(volatile double);
+ const Operator* HeapConstant(const Unique<Object>&);
+
+ const Operator* Phi(MachineType type, int arguments);
+ const Operator* EffectPhi(int arguments);
+ const Operator* ControlEffect();
+ const Operator* ValueEffect(int arguments);
+ const Operator* Finish(int arguments);
+ const Operator* StateValues(int arguments);
+ const Operator* FrameState(
+ FrameStateType type, BailoutId bailout_id,
+ OutputFrameStateCombine state_combine,
+ MaybeHandle<JSFunction> jsfunction = MaybeHandle<JSFunction>());
+ const Operator* Call(const CallDescriptor* descriptor);
+ const Operator* Projection(size_t index);
+
+ private:
+ Zone* zone() const { return zone_; }
+
+ const CommonOperatorBuilderImpl& impl_;
+ Zone* const zone_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_COMMON_OPERATOR_H_