Line data Source code
1 : // Copyright 2015 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_FRAME_STATES_H_
6 : #define V8_COMPILER_FRAME_STATES_H_
7 :
8 : #include "src/handles.h"
9 : #include "src/utils.h"
10 :
11 : namespace v8 {
12 : namespace internal {
13 :
14 : // Forward declarations.
15 : class SharedFunctionInfo;
16 :
17 : namespace compiler {
18 :
19 : // Flag that describes how to combine the current environment with
20 : // the output of a node to obtain a framestate for lazy bailout.
21 : class OutputFrameStateCombine {
22 : public:
23 : enum Kind {
24 : kPushOutput, // Push the output on the expression stack.
25 : kPokeAt // Poke at the given environment location,
26 : // counting from the top of the stack.
27 : };
28 :
29 : static OutputFrameStateCombine Ignore() {
30 : return OutputFrameStateCombine(kPushOutput, 0);
31 : }
32 : static OutputFrameStateCombine Push(size_t count = 1) {
33 : return OutputFrameStateCombine(kPushOutput, count);
34 : }
35 : static OutputFrameStateCombine PokeAt(size_t index) {
36 : return OutputFrameStateCombine(kPokeAt, index);
37 : }
38 :
39 : Kind kind() const { return kind_; }
40 : size_t GetPushCount() const {
41 : DCHECK_EQ(kPushOutput, kind());
42 : return parameter_;
43 : }
44 : size_t GetOffsetToPokeAt() const {
45 : DCHECK_EQ(kPokeAt, kind());
46 : return parameter_;
47 : }
48 :
49 : bool IsOutputIgnored() const {
50 2398148 : return kind_ == kPushOutput && parameter_ == 0;
51 : }
52 :
53 : size_t ConsumedOutputCount() const {
54 2413433 : return kind_ == kPushOutput ? GetPushCount() : 1;
55 : }
56 :
57 : bool operator==(OutputFrameStateCombine const& other) const {
58 497345 : return kind_ == other.kind_ && parameter_ == other.parameter_;
59 : }
60 : bool operator!=(OutputFrameStateCombine const& other) const {
61 : return !(*this == other);
62 : }
63 :
64 : friend size_t hash_value(OutputFrameStateCombine const&);
65 : friend std::ostream& operator<<(std::ostream&,
66 : OutputFrameStateCombine const&);
67 :
68 : private:
69 : OutputFrameStateCombine(Kind kind, size_t parameter)
70 : : kind_(kind), parameter_(parameter) {}
71 :
72 : Kind const kind_;
73 : size_t const parameter_;
74 : };
75 :
76 :
77 : // The type of stack frame that a FrameState node represents.
78 : enum class FrameStateType {
79 : kJavaScriptFunction, // Represents an unoptimized JavaScriptFrame.
80 : kInterpretedFunction, // Represents an InterpretedFrame.
81 : kArgumentsAdaptor, // Represents an ArgumentsAdaptorFrame.
82 : kTailCallerFunction, // Represents a frame removed by tail call elimination.
83 : kConstructStub, // Represents a ConstructStubFrame.
84 : kGetterStub, // Represents a GetterStubFrame.
85 : kSetterStub // Represents a SetterStubFrame.
86 : };
87 :
88 : class FrameStateFunctionInfo {
89 : public:
90 : FrameStateFunctionInfo(FrameStateType type, int parameter_count,
91 : int local_count,
92 : Handle<SharedFunctionInfo> shared_info)
93 : : type_(type),
94 : parameter_count_(parameter_count),
95 : local_count_(local_count),
96 447500 : shared_info_(shared_info) {}
97 :
98 : int local_count() const { return local_count_; }
99 : int parameter_count() const { return parameter_count_; }
100 : Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
101 : FrameStateType type() const { return type_; }
102 :
103 : static bool IsJSFunctionType(FrameStateType type) {
104 43803308 : return type == FrameStateType::kJavaScriptFunction ||
105 : type == FrameStateType::kInterpretedFunction;
106 : }
107 :
108 : private:
109 : FrameStateType const type_;
110 : int const parameter_count_;
111 : int const local_count_;
112 : Handle<SharedFunctionInfo> const shared_info_;
113 : };
114 :
115 :
116 : class FrameStateInfo final {
117 : public:
118 : FrameStateInfo(BailoutId bailout_id, OutputFrameStateCombine state_combine,
119 : const FrameStateFunctionInfo* info)
120 : : bailout_id_(bailout_id),
121 : frame_state_combine_(state_combine),
122 : info_(info) {}
123 :
124 : FrameStateType type() const {
125 28232437 : return info_ == nullptr ? FrameStateType::kJavaScriptFunction
126 28244398 : : info_->type();
127 : }
128 : BailoutId bailout_id() const { return bailout_id_; }
129 : OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
130 : MaybeHandle<SharedFunctionInfo> shared_info() const {
131 : return info_ == nullptr ? MaybeHandle<SharedFunctionInfo>()
132 3003641 : : info_->shared_info();
133 : }
134 : int parameter_count() const {
135 2519 : return info_ == nullptr ? 0 : info_->parameter_count();
136 : }
137 : int local_count() const {
138 : return info_ == nullptr ? 0 : info_->local_count();
139 : }
140 : const FrameStateFunctionInfo* function_info() const { return info_; }
141 :
142 : private:
143 : BailoutId const bailout_id_;
144 : OutputFrameStateCombine const frame_state_combine_;
145 : const FrameStateFunctionInfo* const info_;
146 : };
147 :
148 : bool operator==(FrameStateInfo const&, FrameStateInfo const&);
149 : bool operator!=(FrameStateInfo const&, FrameStateInfo const&);
150 :
151 : size_t hash_value(FrameStateInfo const&);
152 :
153 : std::ostream& operator<<(std::ostream&, FrameStateInfo const&);
154 :
155 : static const int kFrameStateParametersInput = 0;
156 : static const int kFrameStateLocalsInput = 1;
157 : static const int kFrameStateStackInput = 2;
158 : static const int kFrameStateContextInput = 3;
159 : static const int kFrameStateFunctionInput = 4;
160 : static const int kFrameStateOuterStateInput = 5;
161 : static const int kFrameStateInputCount = kFrameStateOuterStateInput + 1;
162 :
163 : } // namespace compiler
164 : } // namespace internal
165 : } // namespace v8
166 :
167 : #endif // V8_COMPILER_FRAME_STATES_H_
|
