1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
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_
|
