| OLD | NEW |
|---|
| (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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1405363003:
Move Hydrogen and Lithium to src/crankshaft/ (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master