Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(40)

Side by Side Diff: src/arm64/lithium-gap-resolver-arm64.cc

Issue 1405363003: Move Hydrogen and Lithium to src/crankshaft/ (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: rebased Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/arm64/lithium-gap-resolver-arm64.h ('k') | src/code-stubs-hydrogen.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 #include "src/arm64/delayed-masm-arm64-inl.h"
6 #include "src/arm64/lithium-codegen-arm64.h"
7 #include "src/arm64/lithium-gap-resolver-arm64.h"
8
9 namespace v8 {
10 namespace internal {
11
12 #define __ ACCESS_MASM((&masm_))
13
14
15 void DelayedGapMasm::EndDelayedUse() {
16 DelayedMasm::EndDelayedUse();
17 if (scratch_register_used()) {
18 DCHECK(ScratchRegister().Is(root));
19 DCHECK(!pending());
20 InitializeRootRegister();
21 reset_scratch_register_used();
22 }
23 }
24
25
26 LGapResolver::LGapResolver(LCodeGen* owner)
27 : cgen_(owner), masm_(owner, owner->masm()), moves_(32, owner->zone()),
28 root_index_(0), in_cycle_(false), saved_destination_(NULL) {
29 }
30
31
32 void LGapResolver::Resolve(LParallelMove* parallel_move) {
33 DCHECK(moves_.is_empty());
34 DCHECK(!masm_.pending());
35
36 // Build up a worklist of moves.
37 BuildInitialMoveList(parallel_move);
38
39 for (int i = 0; i < moves_.length(); ++i) {
40 LMoveOperands move = moves_[i];
41
42 // Skip constants to perform them last. They don't block other moves
43 // and skipping such moves with register destinations keeps those
44 // registers free for the whole algorithm.
45 if (!move.IsEliminated() && !move.source()->IsConstantOperand()) {
46 root_index_ = i; // Any cycle is found when we reach this move again.
47 PerformMove(i);
48 if (in_cycle_) RestoreValue();
49 }
50 }
51
52 // Perform the moves with constant sources.
53 for (int i = 0; i < moves_.length(); ++i) {
54 LMoveOperands move = moves_[i];
55
56 if (!move.IsEliminated()) {
57 DCHECK(move.source()->IsConstantOperand());
58 EmitMove(i);
59 }
60 }
61
62 __ EndDelayedUse();
63
64 moves_.Rewind(0);
65 }
66
67
68 void LGapResolver::BuildInitialMoveList(LParallelMove* parallel_move) {
69 // Perform a linear sweep of the moves to add them to the initial list of
70 // moves to perform, ignoring any move that is redundant (the source is
71 // the same as the destination, the destination is ignored and
72 // unallocated, or the move was already eliminated).
73 const ZoneList<LMoveOperands>* moves = parallel_move->move_operands();
74 for (int i = 0; i < moves->length(); ++i) {
75 LMoveOperands move = moves->at(i);
76 if (!move.IsRedundant()) moves_.Add(move, cgen_->zone());
77 }
78 Verify();
79 }
80
81
82 void LGapResolver::PerformMove(int index) {
83 // Each call to this function performs a move and deletes it from the move
84 // graph. We first recursively perform any move blocking this one. We
85 // mark a move as "pending" on entry to PerformMove in order to detect
86 // cycles in the move graph.
87 LMoveOperands& current_move = moves_[index];
88
89 DCHECK(!current_move.IsPending());
90 DCHECK(!current_move.IsRedundant());
91
92 // Clear this move's destination to indicate a pending move. The actual
93 // destination is saved in a stack allocated local. Multiple moves can
94 // be pending because this function is recursive.
95 DCHECK(current_move.source() != NULL); // Otherwise it will look eliminated.
96 LOperand* destination = current_move.destination();
97 current_move.set_destination(NULL);
98
99 // Perform a depth-first traversal of the move graph to resolve
100 // dependencies. Any unperformed, unpending move with a source the same
101 // as this one's destination blocks this one so recursively perform all
102 // such moves.
103 for (int i = 0; i < moves_.length(); ++i) {
104 LMoveOperands other_move = moves_[i];
105 if (other_move.Blocks(destination) && !other_move.IsPending()) {
106 PerformMove(i);
107 // If there is a blocking, pending move it must be moves_[root_index_]
108 // and all other moves with the same source as moves_[root_index_] are
109 // sucessfully executed (because they are cycle-free) by this loop.
110 }
111 }
112
113 // We are about to resolve this move and don't need it marked as
114 // pending, so restore its destination.
115 current_move.set_destination(destination);
116
117 // The move may be blocked on a pending move, which must be the starting move.
118 // In this case, we have a cycle, and we save the source of this move to
119 // a scratch register to break it.
120 LMoveOperands other_move = moves_[root_index_];
121 if (other_move.Blocks(destination)) {
122 DCHECK(other_move.IsPending());
123 BreakCycle(index);
124 return;
125 }
126
127 // This move is no longer blocked.
128 EmitMove(index);
129 }
130
131
132 void LGapResolver::Verify() {
133 #ifdef ENABLE_SLOW_DCHECKS
134 // No operand should be the destination for more than one move.
135 for (int i = 0; i < moves_.length(); ++i) {
136 LOperand* destination = moves_[i].destination();
137 for (int j = i + 1; j < moves_.length(); ++j) {
138 SLOW_DCHECK(!destination->Equals(moves_[j].destination()));
139 }
140 }
141 #endif
142 }
143
144
145 void LGapResolver::BreakCycle(int index) {
146 DCHECK(moves_[index].destination()->Equals(moves_[root_index_].source()));
147 DCHECK(!in_cycle_);
148
149 // We save in a register the source of that move and we remember its
150 // destination. Then we mark this move as resolved so the cycle is
151 // broken and we can perform the other moves.
152 in_cycle_ = true;
153 LOperand* source = moves_[index].source();
154 saved_destination_ = moves_[index].destination();
155
156 if (source->IsRegister()) {
157 AcquireSavedValueRegister();
158 __ Mov(SavedValueRegister(), cgen_->ToRegister(source));
159 } else if (source->IsStackSlot()) {
160 AcquireSavedValueRegister();
161 __ Load(SavedValueRegister(), cgen_->ToMemOperand(source));
162 } else if (source->IsDoubleRegister()) {
163 __ Fmov(SavedFPValueRegister(), cgen_->ToDoubleRegister(source));
164 } else if (source->IsDoubleStackSlot()) {
165 __ Load(SavedFPValueRegister(), cgen_->ToMemOperand(source));
166 } else {
167 UNREACHABLE();
168 }
169
170 // Mark this move as resolved.
171 // This move will be actually performed by moving the saved value to this
172 // move's destination in LGapResolver::RestoreValue().
173 moves_[index].Eliminate();
174 }
175
176
177 void LGapResolver::RestoreValue() {
178 DCHECK(in_cycle_);
179 DCHECK(saved_destination_ != NULL);
180
181 if (saved_destination_->IsRegister()) {
182 __ Mov(cgen_->ToRegister(saved_destination_), SavedValueRegister());
183 ReleaseSavedValueRegister();
184 } else if (saved_destination_->IsStackSlot()) {
185 __ Store(SavedValueRegister(), cgen_->ToMemOperand(saved_destination_));
186 ReleaseSavedValueRegister();
187 } else if (saved_destination_->IsDoubleRegister()) {
188 __ Fmov(cgen_->ToDoubleRegister(saved_destination_),
189 SavedFPValueRegister());
190 } else if (saved_destination_->IsDoubleStackSlot()) {
191 __ Store(SavedFPValueRegister(), cgen_->ToMemOperand(saved_destination_));
192 } else {
193 UNREACHABLE();
194 }
195
196 in_cycle_ = false;
197 saved_destination_ = NULL;
198 }
199
200
201 void LGapResolver::EmitMove(int index) {
202 LOperand* source = moves_[index].source();
203 LOperand* destination = moves_[index].destination();
204
205 // Dispatch on the source and destination operand kinds. Not all
206 // combinations are possible.
207
208 if (source->IsRegister()) {
209 Register source_register = cgen_->ToRegister(source);
210 if (destination->IsRegister()) {
211 __ Mov(cgen_->ToRegister(destination), source_register);
212 } else {
213 DCHECK(destination->IsStackSlot());
214 __ Store(source_register, cgen_->ToMemOperand(destination));
215 }
216
217 } else if (source->IsStackSlot()) {
218 MemOperand source_operand = cgen_->ToMemOperand(source);
219 if (destination->IsRegister()) {
220 __ Load(cgen_->ToRegister(destination), source_operand);
221 } else {
222 DCHECK(destination->IsStackSlot());
223 EmitStackSlotMove(index);
224 }
225
226 } else if (source->IsConstantOperand()) {
227 LConstantOperand* constant_source = LConstantOperand::cast(source);
228 if (destination->IsRegister()) {
229 Register dst = cgen_->ToRegister(destination);
230 if (cgen_->IsSmi(constant_source)) {
231 __ Mov(dst, cgen_->ToSmi(constant_source));
232 } else if (cgen_->IsInteger32Constant(constant_source)) {
233 __ Mov(dst, cgen_->ToInteger32(constant_source));
234 } else {
235 __ LoadObject(dst, cgen_->ToHandle(constant_source));
236 }
237 } else if (destination->IsDoubleRegister()) {
238 DoubleRegister result = cgen_->ToDoubleRegister(destination);
239 __ Fmov(result, cgen_->ToDouble(constant_source));
240 } else {
241 DCHECK(destination->IsStackSlot());
242 DCHECK(!in_cycle_); // Constant moves happen after all cycles are gone.
243 if (cgen_->IsSmi(constant_source)) {
244 Smi* smi = cgen_->ToSmi(constant_source);
245 __ StoreConstant(reinterpret_cast<intptr_t>(smi),
246 cgen_->ToMemOperand(destination));
247 } else if (cgen_->IsInteger32Constant(constant_source)) {
248 __ StoreConstant(cgen_->ToInteger32(constant_source),
249 cgen_->ToMemOperand(destination));
250 } else {
251 Handle<Object> handle = cgen_->ToHandle(constant_source);
252 AllowDeferredHandleDereference smi_object_check;
253 if (handle->IsSmi()) {
254 Object* obj = *handle;
255 DCHECK(!obj->IsHeapObject());
256 __ StoreConstant(reinterpret_cast<intptr_t>(obj),
257 cgen_->ToMemOperand(destination));
258 } else {
259 AcquireSavedValueRegister();
260 __ LoadObject(SavedValueRegister(), handle);
261 __ Store(SavedValueRegister(), cgen_->ToMemOperand(destination));
262 ReleaseSavedValueRegister();
263 }
264 }
265 }
266
267 } else if (source->IsDoubleRegister()) {
268 DoubleRegister src = cgen_->ToDoubleRegister(source);
269 if (destination->IsDoubleRegister()) {
270 __ Fmov(cgen_->ToDoubleRegister(destination), src);
271 } else {
272 DCHECK(destination->IsDoubleStackSlot());
273 __ Store(src, cgen_->ToMemOperand(destination));
274 }
275
276 } else if (source->IsDoubleStackSlot()) {
277 MemOperand src = cgen_->ToMemOperand(source);
278 if (destination->IsDoubleRegister()) {
279 __ Load(cgen_->ToDoubleRegister(destination), src);
280 } else {
281 DCHECK(destination->IsDoubleStackSlot());
282 EmitStackSlotMove(index);
283 }
284
285 } else {
286 UNREACHABLE();
287 }
288
289 // The move has been emitted, we can eliminate it.
290 moves_[index].Eliminate();
291 }
292
293 } // namespace internal
294 } // namespace v8
OLDNEW
« no previous file with comments | « src/arm64/lithium-gap-resolver-arm64.h ('k') | src/code-stubs-hydrogen.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698