1// Copyright 2013 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef V8_COMPILER_COMMON_OPERATOR_H_
6#define V8_COMPILER_COMMON_OPERATOR_H_
7
8#include "src/compiler/machine-type.h"
9#include "src/unique.h"
10
11namespace v8 {
12namespace internal {
13
14// Forward declarations.
15class ExternalReference;
16class OStream;
17
18
19namespace compiler {
20
21// Forward declarations.
22class CallDescriptor;
23struct CommonOperatorBuilderImpl;
24class Operator;
25
26
27// Flag that describes how to combine the current environment with
28// the output of a node to obtain a framestate for lazy bailout.
29enum OutputFrameStateCombine {
30  kPushOutput,   // Push the output on the expression stack.
31  kIgnoreOutput  // Use the frame state as-is.
32};
33
34
35// The type of stack frame that a FrameState node represents.
36enum FrameStateType {
37  JS_FRAME,          // Represents an unoptimized JavaScriptFrame.
38  ARGUMENTS_ADAPTOR  // Represents an ArgumentsAdaptorFrame.
39};
40
41
42class FrameStateCallInfo FINAL {
43 public:
44  FrameStateCallInfo(
45      FrameStateType type, BailoutId bailout_id,
46      OutputFrameStateCombine state_combine,
47      MaybeHandle<JSFunction> jsfunction = MaybeHandle<JSFunction>())
48      : type_(type),
49        bailout_id_(bailout_id),
50        frame_state_combine_(state_combine),
51        jsfunction_(jsfunction) {}
52
53  FrameStateType type() const { return type_; }
54  BailoutId bailout_id() const { return bailout_id_; }
55  OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
56  MaybeHandle<JSFunction> jsfunction() const { return jsfunction_; }
57
58 private:
59  FrameStateType type_;
60  BailoutId bailout_id_;
61  OutputFrameStateCombine frame_state_combine_;
62  MaybeHandle<JSFunction> jsfunction_;
63};
64
65
66// Interface for building common operators that can be used at any level of IR,
67// including JavaScript, mid-level, and low-level.
68class CommonOperatorBuilder FINAL {
69 public:
70  explicit CommonOperatorBuilder(Zone* zone);
71
72  const Operator* Dead();
73  const Operator* End();
74  const Operator* Branch();
75  const Operator* IfTrue();
76  const Operator* IfFalse();
77  const Operator* Throw();
78  const Operator* Return();
79
80  const Operator* Start(int num_formal_parameters);
81  const Operator* Merge(int controls);
82  const Operator* Loop(int controls);
83  const Operator* Parameter(int index);
84
85  const Operator* Int32Constant(int32_t);
86  const Operator* Int64Constant(int64_t);
87  const Operator* Float32Constant(volatile float);
88  const Operator* Float64Constant(volatile double);
89  const Operator* ExternalConstant(const ExternalReference&);
90  const Operator* NumberConstant(volatile double);
91  const Operator* HeapConstant(const Unique<Object>&);
92
93  const Operator* Phi(MachineType type, int arguments);
94  const Operator* EffectPhi(int arguments);
95  const Operator* ControlEffect();
96  const Operator* ValueEffect(int arguments);
97  const Operator* Finish(int arguments);
98  const Operator* StateValues(int arguments);
99  const Operator* FrameState(
100      FrameStateType type, BailoutId bailout_id,
101      OutputFrameStateCombine state_combine,
102      MaybeHandle<JSFunction> jsfunction = MaybeHandle<JSFunction>());
103  const Operator* Call(const CallDescriptor* descriptor);
104  const Operator* Projection(size_t index);
105
106 private:
107  Zone* zone() const { return zone_; }
108
109  const CommonOperatorBuilderImpl& impl_;
110  Zone* const zone_;
111};
112
113}  // namespace compiler
114}  // namespace internal
115}  // namespace v8
116
117#endif  // V8_COMPILER_COMMON_OPERATOR_H_
118