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 : #include "src/interpreter/control-flow-builders.h"
6 : #include "src/objects-inl.h"
7 :
8 : namespace v8 {
9 : namespace internal {
10 : namespace interpreter {
11 :
12 :
13 11078223 : BreakableControlFlowBuilder::~BreakableControlFlowBuilder() {
14 : BindBreakTarget();
15 : DCHECK(break_labels_.empty() || break_labels_.is_bound());
16 5539111 : if (block_coverage_builder_ != nullptr) {
17 : block_coverage_builder_->IncrementBlockCounter(
18 1532 : node_, SourceRangeKind::kContinuation);
19 : }
20 5539132 : }
21 :
22 0 : void BreakableControlFlowBuilder::BindBreakTarget() {
23 5539091 : break_labels_.Bind(builder());
24 0 : }
25 :
26 52891 : void BreakableControlFlowBuilder::EmitJump(BytecodeLabels* sites) {
27 52891 : builder()->Jump(sites->New());
28 52891 : }
29 :
30 37711 : void BreakableControlFlowBuilder::EmitJumpIfTrue(
31 : BytecodeArrayBuilder::ToBooleanMode mode, BytecodeLabels* sites) {
32 37711 : builder()->JumpIfTrue(mode, sites->New());
33 37708 : }
34 :
35 4755 : void BreakableControlFlowBuilder::EmitJumpIfFalse(
36 : BytecodeArrayBuilder::ToBooleanMode mode, BytecodeLabels* sites) {
37 4755 : builder()->JumpIfFalse(mode, sites->New());
38 4755 : }
39 :
40 4755 : void BreakableControlFlowBuilder::EmitJumpIfUndefined(BytecodeLabels* sites) {
41 4755 : builder()->JumpIfUndefined(sites->New());
42 4755 : }
43 :
44 0 : void BreakableControlFlowBuilder::EmitJumpIfNull(BytecodeLabels* sites) {
45 0 : builder()->JumpIfNull(sites->New());
46 0 : }
47 :
48 556568 : LoopBuilder::~LoopBuilder() {
49 : DCHECK(continue_labels_.empty() || continue_labels_.is_bound());
50 278286 : }
51 :
52 262347 : void LoopBuilder::LoopHeader() {
53 : // Jumps from before the loop header into the loop violate ordering
54 : // requirements of bytecode basic blocks. The only entry into a loop
55 : // must be the loop header. Surely breaks is okay? Not if nested
56 : // and misplaced between the headers.
57 : DCHECK(break_labels_.empty() && continue_labels_.empty());
58 262347 : builder()->Bind(&loop_header_);
59 262351 : }
60 :
61 262501 : void LoopBuilder::LoopBody() {
62 262501 : if (block_coverage_builder_ != nullptr) {
63 228 : block_coverage_builder_->IncrementBlockCounter(block_coverage_body_slot_);
64 : }
65 262501 : }
66 :
67 262352 : void LoopBuilder::JumpToHeader(int loop_depth) {
68 : // Pass the proper loop nesting level to the backwards branch, to trigger
69 : // on-stack replacement when armed for the given loop nesting depth.
70 : int level = Min(loop_depth, AbstractCode::kMaxLoopNestingMarker - 1);
71 : // Loop must have closed form, i.e. all loop elements are within the loop,
72 : // the loop header precedes the body and next elements in the loop.
73 262352 : builder()->JumpLoop(&loop_header_, level);
74 262358 : }
75 :
76 262703 : void LoopBuilder::BindContinueTarget() { continue_labels_.Bind(builder()); }
77 :
78 21314 : SwitchBuilder::~SwitchBuilder() {
79 : #ifdef DEBUG
80 : for (auto site : case_sites_) {
81 : DCHECK(!site.has_referrer_jump() || site.is_bound());
82 : }
83 : #endif
84 10657 : }
85 :
86 80516 : void SwitchBuilder::SetCaseTarget(int index, CaseClause* clause) {
87 80516 : BytecodeLabel& site = case_sites_.at(index);
88 80516 : builder()->Bind(&site);
89 80516 : if (block_coverage_builder_) {
90 : block_coverage_builder_->IncrementBlockCounter(clause,
91 24 : SourceRangeKind::kBody);
92 : }
93 80516 : }
94 :
95 225978 : TryCatchBuilder::~TryCatchBuilder() {
96 112989 : if (block_coverage_builder_ != nullptr) {
97 : block_coverage_builder_->IncrementBlockCounter(
98 68 : statement_, SourceRangeKind::kContinuation);
99 : }
100 112989 : }
101 :
102 112992 : void TryCatchBuilder::BeginTry(Register context) {
103 112992 : builder()->MarkTryBegin(handler_id_, context);
104 112993 : }
105 :
106 :
107 112992 : void TryCatchBuilder::EndTry() {
108 112992 : builder()->MarkTryEnd(handler_id_);
109 112994 : builder()->Jump(&exit_);
110 112995 : builder()->MarkHandler(handler_id_, catch_prediction_);
111 :
112 112995 : if (block_coverage_builder_ != nullptr) {
113 68 : block_coverage_builder_->IncrementBlockCounter(statement_,
114 68 : SourceRangeKind::kCatch);
115 : }
116 112995 : }
117 :
118 112992 : void TryCatchBuilder::EndCatch() { builder()->Bind(&exit_); }
119 :
120 83096 : TryFinallyBuilder::~TryFinallyBuilder() {
121 41548 : if (block_coverage_builder_ != nullptr) {
122 : block_coverage_builder_->IncrementBlockCounter(
123 28 : statement_, SourceRangeKind::kContinuation);
124 : }
125 41548 : }
126 :
127 41545 : void TryFinallyBuilder::BeginTry(Register context) {
128 41545 : builder()->MarkTryBegin(handler_id_, context);
129 41549 : }
130 :
131 :
132 52454 : void TryFinallyBuilder::LeaveTry() {
133 52454 : builder()->Jump(finalization_sites_.New());
134 52457 : }
135 :
136 :
137 41546 : void TryFinallyBuilder::EndTry() {
138 41546 : builder()->MarkTryEnd(handler_id_);
139 41547 : }
140 :
141 :
142 41549 : void TryFinallyBuilder::BeginHandler() {
143 41549 : builder()->Bind(&handler_);
144 41549 : builder()->MarkHandler(handler_id_, catch_prediction_);
145 41550 : }
146 :
147 41548 : void TryFinallyBuilder::BeginFinally() {
148 41548 : finalization_sites_.Bind(builder());
149 :
150 41548 : if (block_coverage_builder_ != nullptr) {
151 28 : block_coverage_builder_->IncrementBlockCounter(statement_,
152 28 : SourceRangeKind::kFinally);
153 : }
154 41548 : }
155 :
156 41549 : void TryFinallyBuilder::EndFinally() {
157 : // Nothing to be done here.
158 41549 : }
159 :
160 1222679 : ConditionalControlFlowBuilder::~ConditionalControlFlowBuilder() {
161 611338 : if (!else_labels_.is_bound()) else_labels_.Bind(builder());
162 611337 : end_labels_.Bind(builder());
163 :
164 : DCHECK(end_labels_.empty() || end_labels_.is_bound());
165 : DCHECK(then_labels_.empty() || then_labels_.is_bound());
166 : DCHECK(else_labels_.empty() || else_labels_.is_bound());
167 :
168 : // IfStatement requires a continuation counter, Conditional does not (as it
169 : // can only contain expressions).
170 611864 : if (block_coverage_builder_ != nullptr && node_->IsIfStatement()) {
171 : block_coverage_builder_->IncrementBlockCounter(
172 444 : node_, SourceRangeKind::kContinuation);
173 : }
174 611341 : }
175 :
176 72185 : void ConditionalControlFlowBuilder::JumpToEnd() {
177 : DCHECK(end_labels_.empty()); // May only be called once.
178 72185 : builder()->Jump(end_labels_.New());
179 72186 : }
180 :
181 602922 : void ConditionalControlFlowBuilder::Then() {
182 602922 : then_labels()->Bind(builder());
183 602922 : if (block_coverage_builder_ != nullptr) {
184 504 : block_coverage_builder_->IncrementBlockCounter(block_coverage_then_slot_);
185 : }
186 602922 : }
187 :
188 79343 : void ConditionalControlFlowBuilder::Else() {
189 79343 : else_labels()->Bind(builder());
190 79342 : if (block_coverage_builder_ != nullptr) {
191 124 : block_coverage_builder_->IncrementBlockCounter(block_coverage_else_slot_);
192 : }
193 79342 : }
194 :
195 : } // namespace interpreter
196 : } // namespace internal
197 122028 : } // namespace v8
|
