OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/compiler/instruction-selector-impl.h" | 5 #include "src/compiler/instruction-selector-impl.h" |
6 #include "src/compiler/node-matchers.h" | 6 #include "src/compiler/node-matchers.h" |
7 | 7 |
8 namespace v8 { | 8 namespace v8 { |
9 namespace internal { | 9 namespace internal { |
10 namespace compiler { | 10 namespace compiler { |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
76 Arm64OperandGenerator g(selector); | 76 Arm64OperandGenerator g(selector); |
77 selector->Emit(opcode, g.DefineAsRegister(node), | 77 selector->Emit(opcode, g.DefineAsRegister(node), |
78 g.UseRegister(node->InputAt(0)), | 78 g.UseRegister(node->InputAt(0)), |
79 g.UseRegister(node->InputAt(1))); | 79 g.UseRegister(node->InputAt(1))); |
80 } | 80 } |
81 | 81 |
82 | 82 |
83 static void VisitRRRFloat64(InstructionSelector* selector, ArchOpcode opcode, | 83 static void VisitRRRFloat64(InstructionSelector* selector, ArchOpcode opcode, |
84 Node* node) { | 84 Node* node) { |
85 Arm64OperandGenerator g(selector); | 85 Arm64OperandGenerator g(selector); |
86 selector->Emit(opcode, g.DefineAsDoubleRegister(node), | 86 selector->Emit(opcode, g.DefineAsRegister(node), |
87 g.UseDoubleRegister(node->InputAt(0)), | 87 g.UseRegister(node->InputAt(0)), |
88 g.UseDoubleRegister(node->InputAt(1))); | 88 g.UseRegister(node->InputAt(1))); |
89 } | 89 } |
90 | 90 |
91 | 91 |
92 static void VisitRRO(InstructionSelector* selector, ArchOpcode opcode, | 92 static void VisitRRO(InstructionSelector* selector, ArchOpcode opcode, |
93 Node* node, ImmediateMode operand_mode) { | 93 Node* node, ImmediateMode operand_mode) { |
94 Arm64OperandGenerator g(selector); | 94 Arm64OperandGenerator g(selector); |
95 selector->Emit(opcode, g.DefineAsRegister(node), | 95 selector->Emit(opcode, g.DefineAsRegister(node), |
96 g.UseRegister(node->InputAt(0)), | 96 g.UseRegister(node->InputAt(0)), |
97 g.UseOperand(node->InputAt(1), operand_mode)); | 97 g.UseOperand(node->InputAt(1), operand_mode)); |
98 } | 98 } |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
140 VisitBinop(selector, node, opcode, operand_mode, &cont); | 140 VisitBinop(selector, node, opcode, operand_mode, &cont); |
141 } | 141 } |
142 | 142 |
143 | 143 |
144 void InstructionSelector::VisitLoad(Node* node) { | 144 void InstructionSelector::VisitLoad(Node* node) { |
145 MachineType rep = RepresentationOf(OpParameter<MachineType>(node)); | 145 MachineType rep = RepresentationOf(OpParameter<MachineType>(node)); |
146 MachineType typ = TypeOf(OpParameter<MachineType>(node)); | 146 MachineType typ = TypeOf(OpParameter<MachineType>(node)); |
147 Arm64OperandGenerator g(this); | 147 Arm64OperandGenerator g(this); |
148 Node* base = node->InputAt(0); | 148 Node* base = node->InputAt(0); |
149 Node* index = node->InputAt(1); | 149 Node* index = node->InputAt(1); |
150 | |
151 InstructionOperand* result = (rep == kRepFloat32 || rep == kRepFloat64) | |
152 ? g.DefineAsDoubleRegister(node) | |
153 : g.DefineAsRegister(node); | |
154 | |
155 ArchOpcode opcode; | 150 ArchOpcode opcode; |
156 // TODO(titzer): signed/unsigned small loads | |
157 switch (rep) { | 151 switch (rep) { |
158 case kRepFloat32: | 152 case kRepFloat32: |
159 opcode = kArm64LdrS; | 153 opcode = kArm64LdrS; |
160 break; | 154 break; |
161 case kRepFloat64: | 155 case kRepFloat64: |
162 opcode = kArm64LdrD; | 156 opcode = kArm64LdrD; |
163 break; | 157 break; |
164 case kRepBit: // Fall through. | 158 case kRepBit: // Fall through. |
165 case kRepWord8: | 159 case kRepWord8: |
166 opcode = typ == kTypeInt32 ? kArm64Ldrsb : kArm64Ldrb; | 160 opcode = typ == kTypeInt32 ? kArm64Ldrsb : kArm64Ldrb; |
167 break; | 161 break; |
168 case kRepWord16: | 162 case kRepWord16: |
169 opcode = typ == kTypeInt32 ? kArm64Ldrsh : kArm64Ldrh; | 163 opcode = typ == kTypeInt32 ? kArm64Ldrsh : kArm64Ldrh; |
170 break; | 164 break; |
171 case kRepWord32: | 165 case kRepWord32: |
172 opcode = kArm64LdrW; | 166 opcode = kArm64LdrW; |
173 break; | 167 break; |
174 case kRepTagged: // Fall through. | 168 case kRepTagged: // Fall through. |
175 case kRepWord64: | 169 case kRepWord64: |
176 opcode = kArm64Ldr; | 170 opcode = kArm64Ldr; |
177 break; | 171 break; |
178 default: | 172 default: |
179 UNREACHABLE(); | 173 UNREACHABLE(); |
180 return; | 174 return; |
181 } | 175 } |
182 if (g.CanBeImmediate(index, kLoadStoreImm)) { | 176 if (g.CanBeImmediate(index, kLoadStoreImm)) { |
183 Emit(opcode | AddressingModeField::encode(kMode_MRI), result, | 177 Emit(opcode | AddressingModeField::encode(kMode_MRI), |
184 g.UseRegister(base), g.UseImmediate(index)); | 178 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index)); |
185 } else { | 179 } else { |
186 Emit(opcode | AddressingModeField::encode(kMode_MRR), result, | 180 Emit(opcode | AddressingModeField::encode(kMode_MRR), |
187 g.UseRegister(base), g.UseRegister(index)); | 181 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(index)); |
188 } | 182 } |
189 } | 183 } |
190 | 184 |
191 | 185 |
192 void InstructionSelector::VisitStore(Node* node) { | 186 void InstructionSelector::VisitStore(Node* node) { |
193 Arm64OperandGenerator g(this); | 187 Arm64OperandGenerator g(this); |
194 Node* base = node->InputAt(0); | 188 Node* base = node->InputAt(0); |
195 Node* index = node->InputAt(1); | 189 Node* index = node->InputAt(1); |
196 Node* value = node->InputAt(2); | 190 Node* value = node->InputAt(2); |
197 | 191 |
198 StoreRepresentation store_rep = OpParameter<StoreRepresentation>(node); | 192 StoreRepresentation store_rep = OpParameter<StoreRepresentation>(node); |
199 MachineType rep = RepresentationOf(store_rep.machine_type); | 193 MachineType rep = RepresentationOf(store_rep.machine_type); |
200 if (store_rep.write_barrier_kind == kFullWriteBarrier) { | 194 if (store_rep.write_barrier_kind == kFullWriteBarrier) { |
201 DCHECK(rep == kRepTagged); | 195 DCHECK(rep == kRepTagged); |
202 // TODO(dcarney): refactor RecordWrite function to take temp registers | 196 // TODO(dcarney): refactor RecordWrite function to take temp registers |
203 // and pass them here instead of using fixed regs | 197 // and pass them here instead of using fixed regs |
204 // TODO(dcarney): handle immediate indices. | 198 // TODO(dcarney): handle immediate indices. |
205 InstructionOperand* temps[] = {g.TempRegister(x11), g.TempRegister(x12)}; | 199 InstructionOperand* temps[] = {g.TempRegister(x11), g.TempRegister(x12)}; |
206 Emit(kArm64StoreWriteBarrier, NULL, g.UseFixed(base, x10), | 200 Emit(kArm64StoreWriteBarrier, NULL, g.UseFixed(base, x10), |
207 g.UseFixed(index, x11), g.UseFixed(value, x12), ARRAY_SIZE(temps), | 201 g.UseFixed(index, x11), g.UseFixed(value, x12), ARRAY_SIZE(temps), |
208 temps); | 202 temps); |
209 return; | 203 return; |
210 } | 204 } |
211 DCHECK_EQ(kNoWriteBarrier, store_rep.write_barrier_kind); | 205 DCHECK_EQ(kNoWriteBarrier, store_rep.write_barrier_kind); |
212 InstructionOperand* val; | |
213 if (rep == kRepFloat32 || rep == kRepFloat64) { | |
214 val = g.UseDoubleRegister(value); | |
215 } else { | |
216 val = g.UseRegister(value); | |
217 } | |
218 ArchOpcode opcode; | 206 ArchOpcode opcode; |
219 switch (rep) { | 207 switch (rep) { |
220 case kRepFloat32: | 208 case kRepFloat32: |
221 opcode = kArm64StrS; | 209 opcode = kArm64StrS; |
222 break; | 210 break; |
223 case kRepFloat64: | 211 case kRepFloat64: |
224 opcode = kArm64StrD; | 212 opcode = kArm64StrD; |
225 break; | 213 break; |
226 case kRepBit: // Fall through. | 214 case kRepBit: // Fall through. |
227 case kRepWord8: | 215 case kRepWord8: |
228 opcode = kArm64Strb; | 216 opcode = kArm64Strb; |
229 break; | 217 break; |
230 case kRepWord16: | 218 case kRepWord16: |
231 opcode = kArm64Strh; | 219 opcode = kArm64Strh; |
232 break; | 220 break; |
233 case kRepWord32: | 221 case kRepWord32: |
234 opcode = kArm64StrW; | 222 opcode = kArm64StrW; |
235 break; | 223 break; |
236 case kRepTagged: // Fall through. | 224 case kRepTagged: // Fall through. |
237 case kRepWord64: | 225 case kRepWord64: |
238 opcode = kArm64Str; | 226 opcode = kArm64Str; |
239 break; | 227 break; |
240 default: | 228 default: |
241 UNREACHABLE(); | 229 UNREACHABLE(); |
242 return; | 230 return; |
243 } | 231 } |
244 if (g.CanBeImmediate(index, kLoadStoreImm)) { | 232 if (g.CanBeImmediate(index, kLoadStoreImm)) { |
245 Emit(opcode | AddressingModeField::encode(kMode_MRI), NULL, | 233 Emit(opcode | AddressingModeField::encode(kMode_MRI), NULL, |
246 g.UseRegister(base), g.UseImmediate(index), val); | 234 g.UseRegister(base), g.UseImmediate(index), g.UseRegister(value)); |
247 } else { | 235 } else { |
248 Emit(opcode | AddressingModeField::encode(kMode_MRR), NULL, | 236 Emit(opcode | AddressingModeField::encode(kMode_MRR), NULL, |
249 g.UseRegister(base), g.UseRegister(index), val); | 237 g.UseRegister(base), g.UseRegister(index), g.UseRegister(value)); |
250 } | 238 } |
251 } | 239 } |
252 | 240 |
253 | 241 |
254 void InstructionSelector::VisitWord32And(Node* node) { | 242 void InstructionSelector::VisitWord32And(Node* node) { |
255 VisitBinop(this, node, kArm64And32, kLogical32Imm); | 243 VisitBinop(this, node, kArm64And32, kLogical32Imm); |
256 } | 244 } |
257 | 245 |
258 | 246 |
259 void InstructionSelector::VisitWord64And(Node* node) { | 247 void InstructionSelector::VisitWord64And(Node* node) { |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
414 } | 402 } |
415 | 403 |
416 | 404 |
417 void InstructionSelector::VisitInt64UMod(Node* node) { | 405 void InstructionSelector::VisitInt64UMod(Node* node) { |
418 VisitRRR(this, kArm64Umod, node); | 406 VisitRRR(this, kArm64Umod, node); |
419 } | 407 } |
420 | 408 |
421 | 409 |
422 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) { | 410 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) { |
423 Arm64OperandGenerator g(this); | 411 Arm64OperandGenerator g(this); |
424 Emit(kArm64Int32ToFloat64, g.DefineAsDoubleRegister(node), | 412 Emit(kArm64Int32ToFloat64, g.DefineAsRegister(node), |
425 g.UseRegister(node->InputAt(0))); | 413 g.UseRegister(node->InputAt(0))); |
426 } | 414 } |
427 | 415 |
428 | 416 |
429 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) { | 417 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) { |
430 Arm64OperandGenerator g(this); | 418 Arm64OperandGenerator g(this); |
431 Emit(kArm64Uint32ToFloat64, g.DefineAsDoubleRegister(node), | 419 Emit(kArm64Uint32ToFloat64, g.DefineAsRegister(node), |
432 g.UseRegister(node->InputAt(0))); | 420 g.UseRegister(node->InputAt(0))); |
433 } | 421 } |
434 | 422 |
435 | 423 |
436 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) { | 424 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) { |
437 Arm64OperandGenerator g(this); | 425 Arm64OperandGenerator g(this); |
438 Emit(kArm64Float64ToInt32, g.DefineAsRegister(node), | 426 Emit(kArm64Float64ToInt32, g.DefineAsRegister(node), |
439 g.UseDoubleRegister(node->InputAt(0))); | 427 g.UseRegister(node->InputAt(0))); |
440 } | 428 } |
441 | 429 |
442 | 430 |
443 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) { | 431 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) { |
444 Arm64OperandGenerator g(this); | 432 Arm64OperandGenerator g(this); |
445 Emit(kArm64Float64ToUint32, g.DefineAsRegister(node), | 433 Emit(kArm64Float64ToUint32, g.DefineAsRegister(node), |
446 g.UseDoubleRegister(node->InputAt(0))); | 434 g.UseRegister(node->InputAt(0))); |
447 } | 435 } |
448 | 436 |
449 | 437 |
450 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) { | 438 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) { |
451 Arm64OperandGenerator g(this); | 439 Arm64OperandGenerator g(this); |
452 Emit(kArm64Sxtw, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0))); | 440 Emit(kArm64Sxtw, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0))); |
453 } | 441 } |
454 | 442 |
455 | 443 |
456 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) { | 444 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) { |
(...skipping 23 matching lines...) Expand all Loading... |
480 } | 468 } |
481 | 469 |
482 | 470 |
483 void InstructionSelector::VisitFloat64Div(Node* node) { | 471 void InstructionSelector::VisitFloat64Div(Node* node) { |
484 VisitRRRFloat64(this, kArm64Float64Div, node); | 472 VisitRRRFloat64(this, kArm64Float64Div, node); |
485 } | 473 } |
486 | 474 |
487 | 475 |
488 void InstructionSelector::VisitFloat64Mod(Node* node) { | 476 void InstructionSelector::VisitFloat64Mod(Node* node) { |
489 Arm64OperandGenerator g(this); | 477 Arm64OperandGenerator g(this); |
490 Emit(kArm64Float64Mod, g.DefineAsFixedDouble(node, d0), | 478 Emit(kArm64Float64Mod, g.DefineAsFixed(node, d0), |
491 g.UseFixedDouble(node->InputAt(0), d0), | 479 g.UseFixed(node->InputAt(0), d0), |
492 g.UseFixedDouble(node->InputAt(1), d1))->MarkAsCall(); | 480 g.UseFixed(node->InputAt(1), d1))->MarkAsCall(); |
493 } | 481 } |
494 | 482 |
495 | 483 |
496 void InstructionSelector::VisitInt32AddWithOverflow(Node* node, | 484 void InstructionSelector::VisitInt32AddWithOverflow(Node* node, |
497 FlagsContinuation* cont) { | 485 FlagsContinuation* cont) { |
498 VisitBinop(this, node, kArm64Add32, kArithimeticImm, cont); | 486 VisitBinop(this, node, kArm64Add32, kArithimeticImm, cont); |
499 } | 487 } |
500 | 488 |
501 | 489 |
502 void InstructionSelector::VisitInt32SubWithOverflow(Node* node, | 490 void InstructionSelector::VisitInt32SubWithOverflow(Node* node, |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
581 FlagsContinuation* cont) { | 569 FlagsContinuation* cont) { |
582 VisitWordCompare(this, node, kArm64Cmp, cont, false); | 570 VisitWordCompare(this, node, kArm64Cmp, cont, false); |
583 } | 571 } |
584 | 572 |
585 | 573 |
586 void InstructionSelector::VisitFloat64Compare(Node* node, | 574 void InstructionSelector::VisitFloat64Compare(Node* node, |
587 FlagsContinuation* cont) { | 575 FlagsContinuation* cont) { |
588 Arm64OperandGenerator g(this); | 576 Arm64OperandGenerator g(this); |
589 Node* left = node->InputAt(0); | 577 Node* left = node->InputAt(0); |
590 Node* right = node->InputAt(1); | 578 Node* right = node->InputAt(1); |
591 VisitCompare(this, kArm64Float64Cmp, g.UseDoubleRegister(left), | 579 VisitCompare(this, kArm64Float64Cmp, g.UseRegister(left), |
592 g.UseDoubleRegister(right), cont); | 580 g.UseRegister(right), cont); |
593 } | 581 } |
594 | 582 |
595 | 583 |
596 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation, | 584 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation, |
597 BasicBlock* deoptimization) { | 585 BasicBlock* deoptimization) { |
598 Arm64OperandGenerator g(this); | 586 Arm64OperandGenerator g(this); |
599 CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call); | 587 CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call); |
600 | 588 |
601 FrameStateDescriptor* frame_state_descriptor = NULL; | 589 FrameStateDescriptor* frame_state_descriptor = NULL; |
602 if (descriptor->NeedsFrameState()) { | 590 if (descriptor->NeedsFrameState()) { |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
679 // Caller clean up of stack for C-style calls. | 667 // Caller clean up of stack for C-style calls. |
680 if (is_c_frame && aligned_push_count > 0) { | 668 if (is_c_frame && aligned_push_count > 0) { |
681 DCHECK(deoptimization == NULL && continuation == NULL); | 669 DCHECK(deoptimization == NULL && continuation == NULL); |
682 Emit(kArm64Drop | MiscField::encode(aligned_push_count), NULL); | 670 Emit(kArm64Drop | MiscField::encode(aligned_push_count), NULL); |
683 } | 671 } |
684 } | 672 } |
685 | 673 |
686 } // namespace compiler | 674 } // namespace compiler |
687 } // namespace internal | 675 } // namespace internal |
688 } // namespace v8 | 676 } // namespace v8 |
OLD | NEW |