OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 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 #ifndef V8_X64_LITHIUM_X64_H_ | 5 #ifndef V8_X64_LITHIUM_X64_H_ |
6 #define V8_X64_LITHIUM_X64_H_ | 6 #define V8_X64_LITHIUM_X64_H_ |
7 | 7 |
8 #include "src/hydrogen.h" | 8 #include "src/hydrogen.h" |
9 #include "src/lithium.h" | 9 #include "src/lithium.h" |
10 #include "src/lithium-allocator.h" | 10 #include "src/lithium-allocator.h" |
(...skipping 144 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 V(TransitionElementsKind) \ | 155 V(TransitionElementsKind) \ |
156 V(TrapAllocationMemento) \ | 156 V(TrapAllocationMemento) \ |
157 V(Typeof) \ | 157 V(Typeof) \ |
158 V(TypeofIsAndBranch) \ | 158 V(TypeofIsAndBranch) \ |
159 V(Uint32ToDouble) \ | 159 V(Uint32ToDouble) \ |
160 V(UnknownOSRValue) \ | 160 V(UnknownOSRValue) \ |
161 V(WrapReceiver) | 161 V(WrapReceiver) |
162 | 162 |
163 | 163 |
164 #define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \ | 164 #define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \ |
165 Opcode opcode() const FINAL { return LInstruction::k##type; } \ | 165 Opcode opcode() const final { return LInstruction::k##type; } \ |
166 void CompileToNative(LCodeGen* generator) FINAL; \ | 166 void CompileToNative(LCodeGen* generator) final; \ |
167 const char* Mnemonic() const FINAL { return mnemonic; } \ | 167 const char* Mnemonic() const final { return mnemonic; } \ |
168 static L##type* cast(LInstruction* instr) { \ | 168 static L##type* cast(LInstruction* instr) { \ |
169 DCHECK(instr->Is##type()); \ | 169 DCHECK(instr->Is##type()); \ |
170 return reinterpret_cast<L##type*>(instr); \ | 170 return reinterpret_cast<L##type*>(instr); \ |
171 } | 171 } |
172 | 172 |
173 | 173 |
174 #define DECLARE_HYDROGEN_ACCESSOR(type) \ | 174 #define DECLARE_HYDROGEN_ACCESSOR(type) \ |
175 H##type* hydrogen() const { \ | 175 H##type* hydrogen() const { \ |
176 return H##type::cast(hydrogen_value()); \ | 176 return H##type::cast(hydrogen_value()); \ |
177 } | 177 } |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
279 int bit_field_; | 279 int bit_field_; |
280 }; | 280 }; |
281 | 281 |
282 | 282 |
283 // R = number of result operands (0 or 1). | 283 // R = number of result operands (0 or 1). |
284 template<int R> | 284 template<int R> |
285 class LTemplateResultInstruction : public LInstruction { | 285 class LTemplateResultInstruction : public LInstruction { |
286 public: | 286 public: |
287 // Allow 0 or 1 output operands. | 287 // Allow 0 or 1 output operands. |
288 STATIC_ASSERT(R == 0 || R == 1); | 288 STATIC_ASSERT(R == 0 || R == 1); |
289 bool HasResult() const FINAL { return R != 0 && result() != NULL; } | 289 bool HasResult() const final { return R != 0 && result() != NULL; } |
290 void set_result(LOperand* operand) { results_[0] = operand; } | 290 void set_result(LOperand* operand) { results_[0] = operand; } |
291 LOperand* result() const OVERRIDE { return results_[0]; } | 291 LOperand* result() const override { return results_[0]; } |
292 | 292 |
293 bool MustSignExtendResult(LPlatformChunk* chunk) const FINAL; | 293 bool MustSignExtendResult(LPlatformChunk* chunk) const final; |
294 | 294 |
295 protected: | 295 protected: |
296 EmbeddedContainer<LOperand*, R> results_; | 296 EmbeddedContainer<LOperand*, R> results_; |
297 }; | 297 }; |
298 | 298 |
299 | 299 |
300 // R = number of result operands (0 or 1). | 300 // R = number of result operands (0 or 1). |
301 // I = number of input operands. | 301 // I = number of input operands. |
302 // T = number of temporary operands. | 302 // T = number of temporary operands. |
303 template<int R, int I, int T> | 303 template<int R, int I, int T> |
304 class LTemplateInstruction : public LTemplateResultInstruction<R> { | 304 class LTemplateInstruction : public LTemplateResultInstruction<R> { |
305 protected: | 305 protected: |
306 EmbeddedContainer<LOperand*, I> inputs_; | 306 EmbeddedContainer<LOperand*, I> inputs_; |
307 EmbeddedContainer<LOperand*, T> temps_; | 307 EmbeddedContainer<LOperand*, T> temps_; |
308 | 308 |
309 private: | 309 private: |
310 // Iterator support. | 310 // Iterator support. |
311 int InputCount() FINAL { return I; } | 311 int InputCount() final { return I; } |
312 LOperand* InputAt(int i) FINAL { return inputs_[i]; } | 312 LOperand* InputAt(int i) final { return inputs_[i]; } |
313 | 313 |
314 int TempCount() FINAL { return T; } | 314 int TempCount() final { return T; } |
315 LOperand* TempAt(int i) FINAL { return temps_[i]; } | 315 LOperand* TempAt(int i) final { return temps_[i]; } |
316 }; | 316 }; |
317 | 317 |
318 | 318 |
319 class LGap : public LTemplateInstruction<0, 0, 0> { | 319 class LGap : public LTemplateInstruction<0, 0, 0> { |
320 public: | 320 public: |
321 explicit LGap(HBasicBlock* block) | 321 explicit LGap(HBasicBlock* block) |
322 : block_(block) { | 322 : block_(block) { |
323 parallel_moves_[BEFORE] = NULL; | 323 parallel_moves_[BEFORE] = NULL; |
324 parallel_moves_[START] = NULL; | 324 parallel_moves_[START] = NULL; |
325 parallel_moves_[END] = NULL; | 325 parallel_moves_[END] = NULL; |
326 parallel_moves_[AFTER] = NULL; | 326 parallel_moves_[AFTER] = NULL; |
327 } | 327 } |
328 | 328 |
329 // Can't use the DECLARE-macro here because of sub-classes. | 329 // Can't use the DECLARE-macro here because of sub-classes. |
330 bool IsGap() const FINAL { return true; } | 330 bool IsGap() const final { return true; } |
331 void PrintDataTo(StringStream* stream) OVERRIDE; | 331 void PrintDataTo(StringStream* stream) override; |
332 static LGap* cast(LInstruction* instr) { | 332 static LGap* cast(LInstruction* instr) { |
333 DCHECK(instr->IsGap()); | 333 DCHECK(instr->IsGap()); |
334 return reinterpret_cast<LGap*>(instr); | 334 return reinterpret_cast<LGap*>(instr); |
335 } | 335 } |
336 | 336 |
337 bool IsRedundant() const; | 337 bool IsRedundant() const; |
338 | 338 |
339 HBasicBlock* block() const { return block_; } | 339 HBasicBlock* block() const { return block_; } |
340 | 340 |
341 enum InnerPosition { | 341 enum InnerPosition { |
(...skipping 16 matching lines...) Expand all Loading... |
358 LParallelMove* GetParallelMove(InnerPosition pos) { | 358 LParallelMove* GetParallelMove(InnerPosition pos) { |
359 return parallel_moves_[pos]; | 359 return parallel_moves_[pos]; |
360 } | 360 } |
361 | 361 |
362 private: | 362 private: |
363 LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1]; | 363 LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1]; |
364 HBasicBlock* block_; | 364 HBasicBlock* block_; |
365 }; | 365 }; |
366 | 366 |
367 | 367 |
368 class LInstructionGap FINAL : public LGap { | 368 class LInstructionGap final : public LGap { |
369 public: | 369 public: |
370 explicit LInstructionGap(HBasicBlock* block) : LGap(block) { } | 370 explicit LInstructionGap(HBasicBlock* block) : LGap(block) { } |
371 | 371 |
372 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { | 372 bool HasInterestingComment(LCodeGen* gen) const override { |
373 return !IsRedundant(); | 373 return !IsRedundant(); |
374 } | 374 } |
375 | 375 |
376 DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap") | 376 DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap") |
377 }; | 377 }; |
378 | 378 |
379 | 379 |
380 class LGoto FINAL : public LTemplateInstruction<0, 0, 0> { | 380 class LGoto final : public LTemplateInstruction<0, 0, 0> { |
381 public: | 381 public: |
382 explicit LGoto(HBasicBlock* block) : block_(block) { } | 382 explicit LGoto(HBasicBlock* block) : block_(block) { } |
383 | 383 |
384 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE; | 384 bool HasInterestingComment(LCodeGen* gen) const override; |
385 DECLARE_CONCRETE_INSTRUCTION(Goto, "goto") | 385 DECLARE_CONCRETE_INSTRUCTION(Goto, "goto") |
386 void PrintDataTo(StringStream* stream) OVERRIDE; | 386 void PrintDataTo(StringStream* stream) override; |
387 bool IsControl() const OVERRIDE { return true; } | 387 bool IsControl() const override { return true; } |
388 | 388 |
389 int block_id() const { return block_->block_id(); } | 389 int block_id() const { return block_->block_id(); } |
390 | 390 |
391 private: | 391 private: |
392 HBasicBlock* block_; | 392 HBasicBlock* block_; |
393 }; | 393 }; |
394 | 394 |
395 | 395 |
396 class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> { | 396 class LLazyBailout final : public LTemplateInstruction<0, 0, 0> { |
397 public: | 397 public: |
398 LLazyBailout() : gap_instructions_size_(0) { } | 398 LLazyBailout() : gap_instructions_size_(0) { } |
399 | 399 |
400 DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout") | 400 DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout") |
401 | 401 |
402 void set_gap_instructions_size(int gap_instructions_size) { | 402 void set_gap_instructions_size(int gap_instructions_size) { |
403 gap_instructions_size_ = gap_instructions_size; | 403 gap_instructions_size_ = gap_instructions_size; |
404 } | 404 } |
405 int gap_instructions_size() { return gap_instructions_size_; } | 405 int gap_instructions_size() { return gap_instructions_size_; } |
406 | 406 |
407 private: | 407 private: |
408 int gap_instructions_size_; | 408 int gap_instructions_size_; |
409 }; | 409 }; |
410 | 410 |
411 | 411 |
412 class LDummy FINAL : public LTemplateInstruction<1, 0, 0> { | 412 class LDummy final : public LTemplateInstruction<1, 0, 0> { |
413 public: | 413 public: |
414 LDummy() {} | 414 LDummy() {} |
415 DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy") | 415 DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy") |
416 }; | 416 }; |
417 | 417 |
418 | 418 |
419 class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> { | 419 class LDummyUse final : public LTemplateInstruction<1, 1, 0> { |
420 public: | 420 public: |
421 explicit LDummyUse(LOperand* value) { | 421 explicit LDummyUse(LOperand* value) { |
422 inputs_[0] = value; | 422 inputs_[0] = value; |
423 } | 423 } |
424 DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use") | 424 DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use") |
425 }; | 425 }; |
426 | 426 |
427 | 427 |
428 class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> { | 428 class LDeoptimize final : public LTemplateInstruction<0, 0, 0> { |
429 public: | 429 public: |
430 bool IsControl() const OVERRIDE { return true; } | 430 bool IsControl() const override { return true; } |
431 DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize") | 431 DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize") |
432 DECLARE_HYDROGEN_ACCESSOR(Deoptimize) | 432 DECLARE_HYDROGEN_ACCESSOR(Deoptimize) |
433 }; | 433 }; |
434 | 434 |
435 | 435 |
436 class LLabel FINAL : public LGap { | 436 class LLabel final : public LGap { |
437 public: | 437 public: |
438 explicit LLabel(HBasicBlock* block) | 438 explicit LLabel(HBasicBlock* block) |
439 : LGap(block), replacement_(NULL) { } | 439 : LGap(block), replacement_(NULL) { } |
440 | 440 |
441 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; } | 441 bool HasInterestingComment(LCodeGen* gen) const override { return false; } |
442 DECLARE_CONCRETE_INSTRUCTION(Label, "label") | 442 DECLARE_CONCRETE_INSTRUCTION(Label, "label") |
443 | 443 |
444 void PrintDataTo(StringStream* stream) OVERRIDE; | 444 void PrintDataTo(StringStream* stream) override; |
445 | 445 |
446 int block_id() const { return block()->block_id(); } | 446 int block_id() const { return block()->block_id(); } |
447 bool is_loop_header() const { return block()->IsLoopHeader(); } | 447 bool is_loop_header() const { return block()->IsLoopHeader(); } |
448 bool is_osr_entry() const { return block()->is_osr_entry(); } | 448 bool is_osr_entry() const { return block()->is_osr_entry(); } |
449 Label* label() { return &label_; } | 449 Label* label() { return &label_; } |
450 LLabel* replacement() const { return replacement_; } | 450 LLabel* replacement() const { return replacement_; } |
451 void set_replacement(LLabel* label) { replacement_ = label; } | 451 void set_replacement(LLabel* label) { replacement_ = label; } |
452 bool HasReplacement() const { return replacement_ != NULL; } | 452 bool HasReplacement() const { return replacement_ != NULL; } |
453 | 453 |
454 private: | 454 private: |
455 Label label_; | 455 Label label_; |
456 LLabel* replacement_; | 456 LLabel* replacement_; |
457 }; | 457 }; |
458 | 458 |
459 | 459 |
460 class LParameter FINAL : public LTemplateInstruction<1, 0, 0> { | 460 class LParameter final : public LTemplateInstruction<1, 0, 0> { |
461 public: | 461 public: |
462 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; } | 462 bool HasInterestingComment(LCodeGen* gen) const override { return false; } |
463 DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter") | 463 DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter") |
464 }; | 464 }; |
465 | 465 |
466 | 466 |
467 class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> { | 467 class LCallStub final : public LTemplateInstruction<1, 1, 0> { |
468 public: | 468 public: |
469 explicit LCallStub(LOperand* context) { | 469 explicit LCallStub(LOperand* context) { |
470 inputs_[0] = context; | 470 inputs_[0] = context; |
471 } | 471 } |
472 | 472 |
473 LOperand* context() { return inputs_[0]; } | 473 LOperand* context() { return inputs_[0]; } |
474 | 474 |
475 DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub") | 475 DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub") |
476 DECLARE_HYDROGEN_ACCESSOR(CallStub) | 476 DECLARE_HYDROGEN_ACCESSOR(CallStub) |
477 }; | 477 }; |
478 | 478 |
479 | 479 |
480 class LTailCallThroughMegamorphicCache FINAL | 480 class LTailCallThroughMegamorphicCache final |
481 : public LTemplateInstruction<0, 3, 0> { | 481 : public LTemplateInstruction<0, 3, 0> { |
482 public: | 482 public: |
483 explicit LTailCallThroughMegamorphicCache(LOperand* context, | 483 explicit LTailCallThroughMegamorphicCache(LOperand* context, |
484 LOperand* receiver, | 484 LOperand* receiver, |
485 LOperand* name) { | 485 LOperand* name) { |
486 inputs_[0] = context; | 486 inputs_[0] = context; |
487 inputs_[1] = receiver; | 487 inputs_[1] = receiver; |
488 inputs_[2] = name; | 488 inputs_[2] = name; |
489 } | 489 } |
490 | 490 |
491 LOperand* context() { return inputs_[0]; } | 491 LOperand* context() { return inputs_[0]; } |
492 LOperand* receiver() { return inputs_[1]; } | 492 LOperand* receiver() { return inputs_[1]; } |
493 LOperand* name() { return inputs_[2]; } | 493 LOperand* name() { return inputs_[2]; } |
494 | 494 |
495 DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache, | 495 DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache, |
496 "tail-call-through-megamorphic-cache") | 496 "tail-call-through-megamorphic-cache") |
497 DECLARE_HYDROGEN_ACCESSOR(TailCallThroughMegamorphicCache) | 497 DECLARE_HYDROGEN_ACCESSOR(TailCallThroughMegamorphicCache) |
498 }; | 498 }; |
499 | 499 |
500 | 500 |
501 class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> { | 501 class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> { |
502 public: | 502 public: |
503 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; } | 503 bool HasInterestingComment(LCodeGen* gen) const override { return false; } |
504 DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value") | 504 DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value") |
505 }; | 505 }; |
506 | 506 |
507 | 507 |
508 template<int I, int T> | 508 template<int I, int T> |
509 class LControlInstruction : public LTemplateInstruction<0, I, T> { | 509 class LControlInstruction : public LTemplateInstruction<0, I, T> { |
510 public: | 510 public: |
511 LControlInstruction() : false_label_(NULL), true_label_(NULL) { } | 511 LControlInstruction() : false_label_(NULL), true_label_(NULL) { } |
512 | 512 |
513 bool IsControl() const FINAL { return true; } | 513 bool IsControl() const final { return true; } |
514 | 514 |
515 int SuccessorCount() { return hydrogen()->SuccessorCount(); } | 515 int SuccessorCount() { return hydrogen()->SuccessorCount(); } |
516 HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); } | 516 HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); } |
517 | 517 |
518 int TrueDestination(LChunk* chunk) { | 518 int TrueDestination(LChunk* chunk) { |
519 return chunk->LookupDestination(true_block_id()); | 519 return chunk->LookupDestination(true_block_id()); |
520 } | 520 } |
521 int FalseDestination(LChunk* chunk) { | 521 int FalseDestination(LChunk* chunk) { |
522 return chunk->LookupDestination(false_block_id()); | 522 return chunk->LookupDestination(false_block_id()); |
523 } | 523 } |
(...skipping 18 matching lines...) Expand all Loading... |
542 private: | 542 private: |
543 HControlInstruction* hydrogen() { | 543 HControlInstruction* hydrogen() { |
544 return HControlInstruction::cast(this->hydrogen_value()); | 544 return HControlInstruction::cast(this->hydrogen_value()); |
545 } | 545 } |
546 | 546 |
547 Label* false_label_; | 547 Label* false_label_; |
548 Label* true_label_; | 548 Label* true_label_; |
549 }; | 549 }; |
550 | 550 |
551 | 551 |
552 class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> { | 552 class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> { |
553 public: | 553 public: |
554 LWrapReceiver(LOperand* receiver, LOperand* function) { | 554 LWrapReceiver(LOperand* receiver, LOperand* function) { |
555 inputs_[0] = receiver; | 555 inputs_[0] = receiver; |
556 inputs_[1] = function; | 556 inputs_[1] = function; |
557 } | 557 } |
558 | 558 |
559 LOperand* receiver() { return inputs_[0]; } | 559 LOperand* receiver() { return inputs_[0]; } |
560 LOperand* function() { return inputs_[1]; } | 560 LOperand* function() { return inputs_[1]; } |
561 | 561 |
562 DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver") | 562 DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver") |
563 DECLARE_HYDROGEN_ACCESSOR(WrapReceiver) | 563 DECLARE_HYDROGEN_ACCESSOR(WrapReceiver) |
564 }; | 564 }; |
565 | 565 |
566 | 566 |
567 class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> { | 567 class LApplyArguments final : public LTemplateInstruction<1, 4, 0> { |
568 public: | 568 public: |
569 LApplyArguments(LOperand* function, | 569 LApplyArguments(LOperand* function, |
570 LOperand* receiver, | 570 LOperand* receiver, |
571 LOperand* length, | 571 LOperand* length, |
572 LOperand* elements) { | 572 LOperand* elements) { |
573 inputs_[0] = function; | 573 inputs_[0] = function; |
574 inputs_[1] = receiver; | 574 inputs_[1] = receiver; |
575 inputs_[2] = length; | 575 inputs_[2] = length; |
576 inputs_[3] = elements; | 576 inputs_[3] = elements; |
577 } | 577 } |
578 | 578 |
579 LOperand* function() { return inputs_[0]; } | 579 LOperand* function() { return inputs_[0]; } |
580 LOperand* receiver() { return inputs_[1]; } | 580 LOperand* receiver() { return inputs_[1]; } |
581 LOperand* length() { return inputs_[2]; } | 581 LOperand* length() { return inputs_[2]; } |
582 LOperand* elements() { return inputs_[3]; } | 582 LOperand* elements() { return inputs_[3]; } |
583 | 583 |
584 DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments") | 584 DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments") |
585 }; | 585 }; |
586 | 586 |
587 | 587 |
588 class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> { | 588 class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> { |
589 public: | 589 public: |
590 LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) { | 590 LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) { |
591 inputs_[0] = arguments; | 591 inputs_[0] = arguments; |
592 inputs_[1] = length; | 592 inputs_[1] = length; |
593 inputs_[2] = index; | 593 inputs_[2] = index; |
594 } | 594 } |
595 | 595 |
596 LOperand* arguments() { return inputs_[0]; } | 596 LOperand* arguments() { return inputs_[0]; } |
597 LOperand* length() { return inputs_[1]; } | 597 LOperand* length() { return inputs_[1]; } |
598 LOperand* index() { return inputs_[2]; } | 598 LOperand* index() { return inputs_[2]; } |
599 | 599 |
600 DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at") | 600 DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at") |
601 | 601 |
602 void PrintDataTo(StringStream* stream) OVERRIDE; | 602 void PrintDataTo(StringStream* stream) override; |
603 }; | 603 }; |
604 | 604 |
605 | 605 |
606 class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> { | 606 class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> { |
607 public: | 607 public: |
608 explicit LArgumentsLength(LOperand* elements) { | 608 explicit LArgumentsLength(LOperand* elements) { |
609 inputs_[0] = elements; | 609 inputs_[0] = elements; |
610 } | 610 } |
611 | 611 |
612 LOperand* elements() { return inputs_[0]; } | 612 LOperand* elements() { return inputs_[0]; } |
613 | 613 |
614 DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length") | 614 DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length") |
615 }; | 615 }; |
616 | 616 |
617 | 617 |
618 class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> { | 618 class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> { |
619 public: | 619 public: |
620 DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements") | 620 DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements") |
621 DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements) | 621 DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements) |
622 }; | 622 }; |
623 | 623 |
624 | 624 |
625 class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { | 625 class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> { |
626 public: | 626 public: |
627 LModByPowerOf2I(LOperand* dividend, int32_t divisor) { | 627 LModByPowerOf2I(LOperand* dividend, int32_t divisor) { |
628 inputs_[0] = dividend; | 628 inputs_[0] = dividend; |
629 divisor_ = divisor; | 629 divisor_ = divisor; |
630 } | 630 } |
631 | 631 |
632 LOperand* dividend() { return inputs_[0]; } | 632 LOperand* dividend() { return inputs_[0]; } |
633 int32_t divisor() const { return divisor_; } | 633 int32_t divisor() const { return divisor_; } |
634 | 634 |
635 DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i") | 635 DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i") |
636 DECLARE_HYDROGEN_ACCESSOR(Mod) | 636 DECLARE_HYDROGEN_ACCESSOR(Mod) |
637 | 637 |
638 private: | 638 private: |
639 int32_t divisor_; | 639 int32_t divisor_; |
640 }; | 640 }; |
641 | 641 |
642 | 642 |
643 class LModByConstI FINAL : public LTemplateInstruction<1, 1, 2> { | 643 class LModByConstI final : public LTemplateInstruction<1, 1, 2> { |
644 public: | 644 public: |
645 LModByConstI(LOperand* dividend, | 645 LModByConstI(LOperand* dividend, |
646 int32_t divisor, | 646 int32_t divisor, |
647 LOperand* temp1, | 647 LOperand* temp1, |
648 LOperand* temp2) { | 648 LOperand* temp2) { |
649 inputs_[0] = dividend; | 649 inputs_[0] = dividend; |
650 divisor_ = divisor; | 650 divisor_ = divisor; |
651 temps_[0] = temp1; | 651 temps_[0] = temp1; |
652 temps_[1] = temp2; | 652 temps_[1] = temp2; |
653 } | 653 } |
654 | 654 |
655 LOperand* dividend() { return inputs_[0]; } | 655 LOperand* dividend() { return inputs_[0]; } |
656 int32_t divisor() const { return divisor_; } | 656 int32_t divisor() const { return divisor_; } |
657 LOperand* temp1() { return temps_[0]; } | 657 LOperand* temp1() { return temps_[0]; } |
658 LOperand* temp2() { return temps_[1]; } | 658 LOperand* temp2() { return temps_[1]; } |
659 | 659 |
660 DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i") | 660 DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i") |
661 DECLARE_HYDROGEN_ACCESSOR(Mod) | 661 DECLARE_HYDROGEN_ACCESSOR(Mod) |
662 | 662 |
663 private: | 663 private: |
664 int32_t divisor_; | 664 int32_t divisor_; |
665 }; | 665 }; |
666 | 666 |
667 | 667 |
668 class LModI FINAL : public LTemplateInstruction<1, 2, 1> { | 668 class LModI final : public LTemplateInstruction<1, 2, 1> { |
669 public: | 669 public: |
670 LModI(LOperand* left, LOperand* right, LOperand* temp) { | 670 LModI(LOperand* left, LOperand* right, LOperand* temp) { |
671 inputs_[0] = left; | 671 inputs_[0] = left; |
672 inputs_[1] = right; | 672 inputs_[1] = right; |
673 temps_[0] = temp; | 673 temps_[0] = temp; |
674 } | 674 } |
675 | 675 |
676 LOperand* left() { return inputs_[0]; } | 676 LOperand* left() { return inputs_[0]; } |
677 LOperand* right() { return inputs_[1]; } | 677 LOperand* right() { return inputs_[1]; } |
678 LOperand* temp() { return temps_[0]; } | 678 LOperand* temp() { return temps_[0]; } |
679 | 679 |
680 DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i") | 680 DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i") |
681 DECLARE_HYDROGEN_ACCESSOR(Mod) | 681 DECLARE_HYDROGEN_ACCESSOR(Mod) |
682 }; | 682 }; |
683 | 683 |
684 | 684 |
685 class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { | 685 class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> { |
686 public: | 686 public: |
687 LDivByPowerOf2I(LOperand* dividend, int32_t divisor) { | 687 LDivByPowerOf2I(LOperand* dividend, int32_t divisor) { |
688 inputs_[0] = dividend; | 688 inputs_[0] = dividend; |
689 divisor_ = divisor; | 689 divisor_ = divisor; |
690 } | 690 } |
691 | 691 |
692 LOperand* dividend() { return inputs_[0]; } | 692 LOperand* dividend() { return inputs_[0]; } |
693 int32_t divisor() const { return divisor_; } | 693 int32_t divisor() const { return divisor_; } |
694 | 694 |
695 DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i") | 695 DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i") |
696 DECLARE_HYDROGEN_ACCESSOR(Div) | 696 DECLARE_HYDROGEN_ACCESSOR(Div) |
697 | 697 |
698 private: | 698 private: |
699 int32_t divisor_; | 699 int32_t divisor_; |
700 }; | 700 }; |
701 | 701 |
702 | 702 |
703 class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> { | 703 class LDivByConstI final : public LTemplateInstruction<1, 1, 2> { |
704 public: | 704 public: |
705 LDivByConstI(LOperand* dividend, | 705 LDivByConstI(LOperand* dividend, |
706 int32_t divisor, | 706 int32_t divisor, |
707 LOperand* temp1, | 707 LOperand* temp1, |
708 LOperand* temp2) { | 708 LOperand* temp2) { |
709 inputs_[0] = dividend; | 709 inputs_[0] = dividend; |
710 divisor_ = divisor; | 710 divisor_ = divisor; |
711 temps_[0] = temp1; | 711 temps_[0] = temp1; |
712 temps_[1] = temp2; | 712 temps_[1] = temp2; |
713 } | 713 } |
714 | 714 |
715 LOperand* dividend() { return inputs_[0]; } | 715 LOperand* dividend() { return inputs_[0]; } |
716 int32_t divisor() const { return divisor_; } | 716 int32_t divisor() const { return divisor_; } |
717 LOperand* temp1() { return temps_[0]; } | 717 LOperand* temp1() { return temps_[0]; } |
718 LOperand* temp2() { return temps_[1]; } | 718 LOperand* temp2() { return temps_[1]; } |
719 | 719 |
720 DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i") | 720 DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i") |
721 DECLARE_HYDROGEN_ACCESSOR(Div) | 721 DECLARE_HYDROGEN_ACCESSOR(Div) |
722 | 722 |
723 private: | 723 private: |
724 int32_t divisor_; | 724 int32_t divisor_; |
725 }; | 725 }; |
726 | 726 |
727 | 727 |
728 class LDivI FINAL : public LTemplateInstruction<1, 2, 1> { | 728 class LDivI final : public LTemplateInstruction<1, 2, 1> { |
729 public: | 729 public: |
730 LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { | 730 LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { |
731 inputs_[0] = dividend; | 731 inputs_[0] = dividend; |
732 inputs_[1] = divisor; | 732 inputs_[1] = divisor; |
733 temps_[0] = temp; | 733 temps_[0] = temp; |
734 } | 734 } |
735 | 735 |
736 LOperand* dividend() { return inputs_[0]; } | 736 LOperand* dividend() { return inputs_[0]; } |
737 LOperand* divisor() { return inputs_[1]; } | 737 LOperand* divisor() { return inputs_[1]; } |
738 LOperand* temp() { return temps_[0]; } | 738 LOperand* temp() { return temps_[0]; } |
739 | 739 |
740 DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i") | 740 DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i") |
741 DECLARE_HYDROGEN_ACCESSOR(BinaryOperation) | 741 DECLARE_HYDROGEN_ACCESSOR(BinaryOperation) |
742 }; | 742 }; |
743 | 743 |
744 | 744 |
745 class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { | 745 class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> { |
746 public: | 746 public: |
747 LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) { | 747 LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) { |
748 inputs_[0] = dividend; | 748 inputs_[0] = dividend; |
749 divisor_ = divisor; | 749 divisor_ = divisor; |
750 } | 750 } |
751 | 751 |
752 LOperand* dividend() { return inputs_[0]; } | 752 LOperand* dividend() { return inputs_[0]; } |
753 int32_t divisor() const { return divisor_; } | 753 int32_t divisor() const { return divisor_; } |
754 | 754 |
755 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I, | 755 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I, |
756 "flooring-div-by-power-of-2-i") | 756 "flooring-div-by-power-of-2-i") |
757 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) | 757 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) |
758 | 758 |
759 private: | 759 private: |
760 int32_t divisor_; | 760 int32_t divisor_; |
761 }; | 761 }; |
762 | 762 |
763 | 763 |
764 class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 3> { | 764 class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> { |
765 public: | 765 public: |
766 LFlooringDivByConstI(LOperand* dividend, | 766 LFlooringDivByConstI(LOperand* dividend, |
767 int32_t divisor, | 767 int32_t divisor, |
768 LOperand* temp1, | 768 LOperand* temp1, |
769 LOperand* temp2, | 769 LOperand* temp2, |
770 LOperand* temp3) { | 770 LOperand* temp3) { |
771 inputs_[0] = dividend; | 771 inputs_[0] = dividend; |
772 divisor_ = divisor; | 772 divisor_ = divisor; |
773 temps_[0] = temp1; | 773 temps_[0] = temp1; |
774 temps_[1] = temp2; | 774 temps_[1] = temp2; |
775 temps_[2] = temp3; | 775 temps_[2] = temp3; |
776 } | 776 } |
777 | 777 |
778 LOperand* dividend() { return inputs_[0]; } | 778 LOperand* dividend() { return inputs_[0]; } |
779 int32_t divisor() const { return divisor_; } | 779 int32_t divisor() const { return divisor_; } |
780 LOperand* temp1() { return temps_[0]; } | 780 LOperand* temp1() { return temps_[0]; } |
781 LOperand* temp2() { return temps_[1]; } | 781 LOperand* temp2() { return temps_[1]; } |
782 LOperand* temp3() { return temps_[2]; } | 782 LOperand* temp3() { return temps_[2]; } |
783 | 783 |
784 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i") | 784 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i") |
785 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) | 785 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) |
786 | 786 |
787 private: | 787 private: |
788 int32_t divisor_; | 788 int32_t divisor_; |
789 }; | 789 }; |
790 | 790 |
791 | 791 |
792 class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> { | 792 class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> { |
793 public: | 793 public: |
794 LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { | 794 LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { |
795 inputs_[0] = dividend; | 795 inputs_[0] = dividend; |
796 inputs_[1] = divisor; | 796 inputs_[1] = divisor; |
797 temps_[0] = temp; | 797 temps_[0] = temp; |
798 } | 798 } |
799 | 799 |
800 LOperand* dividend() { return inputs_[0]; } | 800 LOperand* dividend() { return inputs_[0]; } |
801 LOperand* divisor() { return inputs_[1]; } | 801 LOperand* divisor() { return inputs_[1]; } |
802 LOperand* temp() { return temps_[0]; } | 802 LOperand* temp() { return temps_[0]; } |
803 | 803 |
804 DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i") | 804 DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i") |
805 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) | 805 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) |
806 }; | 806 }; |
807 | 807 |
808 | 808 |
809 class LMulI FINAL : public LTemplateInstruction<1, 2, 0> { | 809 class LMulI final : public LTemplateInstruction<1, 2, 0> { |
810 public: | 810 public: |
811 LMulI(LOperand* left, LOperand* right) { | 811 LMulI(LOperand* left, LOperand* right) { |
812 inputs_[0] = left; | 812 inputs_[0] = left; |
813 inputs_[1] = right; | 813 inputs_[1] = right; |
814 } | 814 } |
815 | 815 |
816 LOperand* left() { return inputs_[0]; } | 816 LOperand* left() { return inputs_[0]; } |
817 LOperand* right() { return inputs_[1]; } | 817 LOperand* right() { return inputs_[1]; } |
818 | 818 |
819 DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i") | 819 DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i") |
820 DECLARE_HYDROGEN_ACCESSOR(Mul) | 820 DECLARE_HYDROGEN_ACCESSOR(Mul) |
821 }; | 821 }; |
822 | 822 |
823 | 823 |
824 class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> { | 824 class LCompareNumericAndBranch final : public LControlInstruction<2, 0> { |
825 public: | 825 public: |
826 LCompareNumericAndBranch(LOperand* left, LOperand* right) { | 826 LCompareNumericAndBranch(LOperand* left, LOperand* right) { |
827 inputs_[0] = left; | 827 inputs_[0] = left; |
828 inputs_[1] = right; | 828 inputs_[1] = right; |
829 } | 829 } |
830 | 830 |
831 LOperand* left() { return inputs_[0]; } | 831 LOperand* left() { return inputs_[0]; } |
832 LOperand* right() { return inputs_[1]; } | 832 LOperand* right() { return inputs_[1]; } |
833 | 833 |
834 DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch, | 834 DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch, |
835 "compare-numeric-and-branch") | 835 "compare-numeric-and-branch") |
836 DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch) | 836 DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch) |
837 | 837 |
838 Token::Value op() const { return hydrogen()->token(); } | 838 Token::Value op() const { return hydrogen()->token(); } |
839 bool is_double() const { | 839 bool is_double() const { |
840 return hydrogen()->representation().IsDouble(); | 840 return hydrogen()->representation().IsDouble(); |
841 } | 841 } |
842 | 842 |
843 void PrintDataTo(StringStream* stream) OVERRIDE; | 843 void PrintDataTo(StringStream* stream) override; |
844 }; | 844 }; |
845 | 845 |
846 | 846 |
847 class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> { | 847 class LMathFloor final : public LTemplateInstruction<1, 1, 0> { |
848 public: | 848 public: |
849 explicit LMathFloor(LOperand* value) { | 849 explicit LMathFloor(LOperand* value) { |
850 inputs_[0] = value; | 850 inputs_[0] = value; |
851 } | 851 } |
852 | 852 |
853 LOperand* value() { return inputs_[0]; } | 853 LOperand* value() { return inputs_[0]; } |
854 | 854 |
855 DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor") | 855 DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor") |
856 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) | 856 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) |
857 }; | 857 }; |
858 | 858 |
859 | 859 |
860 class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> { | 860 class LMathRound final : public LTemplateInstruction<1, 1, 1> { |
861 public: | 861 public: |
862 LMathRound(LOperand* value, LOperand* temp) { | 862 LMathRound(LOperand* value, LOperand* temp) { |
863 inputs_[0] = value; | 863 inputs_[0] = value; |
864 temps_[0] = temp; | 864 temps_[0] = temp; |
865 } | 865 } |
866 | 866 |
867 LOperand* value() { return inputs_[0]; } | 867 LOperand* value() { return inputs_[0]; } |
868 LOperand* temp() { return temps_[0]; } | 868 LOperand* temp() { return temps_[0]; } |
869 | 869 |
870 DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round") | 870 DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round") |
871 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) | 871 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) |
872 }; | 872 }; |
873 | 873 |
874 | 874 |
875 class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> { | 875 class LMathFround final : public LTemplateInstruction<1, 1, 0> { |
876 public: | 876 public: |
877 explicit LMathFround(LOperand* value) { inputs_[0] = value; } | 877 explicit LMathFround(LOperand* value) { inputs_[0] = value; } |
878 | 878 |
879 LOperand* value() { return inputs_[0]; } | 879 LOperand* value() { return inputs_[0]; } |
880 | 880 |
881 DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround") | 881 DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround") |
882 }; | 882 }; |
883 | 883 |
884 | 884 |
885 class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> { | 885 class LMathAbs final : public LTemplateInstruction<1, 2, 0> { |
886 public: | 886 public: |
887 explicit LMathAbs(LOperand* context, LOperand* value) { | 887 explicit LMathAbs(LOperand* context, LOperand* value) { |
888 inputs_[1] = context; | 888 inputs_[1] = context; |
889 inputs_[0] = value; | 889 inputs_[0] = value; |
890 } | 890 } |
891 | 891 |
892 LOperand* context() { return inputs_[1]; } | 892 LOperand* context() { return inputs_[1]; } |
893 LOperand* value() { return inputs_[0]; } | 893 LOperand* value() { return inputs_[0]; } |
894 | 894 |
895 DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs") | 895 DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs") |
896 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) | 896 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) |
897 }; | 897 }; |
898 | 898 |
899 | 899 |
900 class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> { | 900 class LMathLog final : public LTemplateInstruction<1, 1, 0> { |
901 public: | 901 public: |
902 explicit LMathLog(LOperand* value) { | 902 explicit LMathLog(LOperand* value) { |
903 inputs_[0] = value; | 903 inputs_[0] = value; |
904 } | 904 } |
905 | 905 |
906 LOperand* value() { return inputs_[0]; } | 906 LOperand* value() { return inputs_[0]; } |
907 | 907 |
908 DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log") | 908 DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log") |
909 }; | 909 }; |
910 | 910 |
911 | 911 |
912 class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> { | 912 class LMathClz32 final : public LTemplateInstruction<1, 1, 0> { |
913 public: | 913 public: |
914 explicit LMathClz32(LOperand* value) { | 914 explicit LMathClz32(LOperand* value) { |
915 inputs_[0] = value; | 915 inputs_[0] = value; |
916 } | 916 } |
917 | 917 |
918 LOperand* value() { return inputs_[0]; } | 918 LOperand* value() { return inputs_[0]; } |
919 | 919 |
920 DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32") | 920 DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32") |
921 }; | 921 }; |
922 | 922 |
923 | 923 |
924 class LMathExp FINAL : public LTemplateInstruction<1, 1, 2> { | 924 class LMathExp final : public LTemplateInstruction<1, 1, 2> { |
925 public: | 925 public: |
926 LMathExp(LOperand* value, LOperand* temp1, LOperand* temp2) { | 926 LMathExp(LOperand* value, LOperand* temp1, LOperand* temp2) { |
927 inputs_[0] = value; | 927 inputs_[0] = value; |
928 temps_[0] = temp1; | 928 temps_[0] = temp1; |
929 temps_[1] = temp2; | 929 temps_[1] = temp2; |
930 ExternalReference::InitializeMathExpData(); | 930 ExternalReference::InitializeMathExpData(); |
931 } | 931 } |
932 | 932 |
933 LOperand* value() { return inputs_[0]; } | 933 LOperand* value() { return inputs_[0]; } |
934 LOperand* temp1() { return temps_[0]; } | 934 LOperand* temp1() { return temps_[0]; } |
935 LOperand* temp2() { return temps_[1]; } | 935 LOperand* temp2() { return temps_[1]; } |
936 | 936 |
937 DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp") | 937 DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp") |
938 }; | 938 }; |
939 | 939 |
940 | 940 |
941 class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> { | 941 class LMathSqrt final : public LTemplateInstruction<1, 1, 0> { |
942 public: | 942 public: |
943 explicit LMathSqrt(LOperand* value) { | 943 explicit LMathSqrt(LOperand* value) { |
944 inputs_[0] = value; | 944 inputs_[0] = value; |
945 } | 945 } |
946 | 946 |
947 LOperand* value() { return inputs_[0]; } | 947 LOperand* value() { return inputs_[0]; } |
948 | 948 |
949 DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt") | 949 DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt") |
950 }; | 950 }; |
951 | 951 |
952 | 952 |
953 class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> { | 953 class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> { |
954 public: | 954 public: |
955 explicit LMathPowHalf(LOperand* value) { | 955 explicit LMathPowHalf(LOperand* value) { |
956 inputs_[0] = value; | 956 inputs_[0] = value; |
957 } | 957 } |
958 | 958 |
959 LOperand* value() { return inputs_[0]; } | 959 LOperand* value() { return inputs_[0]; } |
960 | 960 |
961 DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half") | 961 DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half") |
962 }; | 962 }; |
963 | 963 |
964 | 964 |
965 class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> { | 965 class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> { |
966 public: | 966 public: |
967 LCmpObjectEqAndBranch(LOperand* left, LOperand* right) { | 967 LCmpObjectEqAndBranch(LOperand* left, LOperand* right) { |
968 inputs_[0] = left; | 968 inputs_[0] = left; |
969 inputs_[1] = right; | 969 inputs_[1] = right; |
970 } | 970 } |
971 | 971 |
972 LOperand* left() { return inputs_[0]; } | 972 LOperand* left() { return inputs_[0]; } |
973 LOperand* right() { return inputs_[1]; } | 973 LOperand* right() { return inputs_[1]; } |
974 | 974 |
975 DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch") | 975 DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch") |
976 }; | 976 }; |
977 | 977 |
978 | 978 |
979 class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> { | 979 class LCmpHoleAndBranch final : public LControlInstruction<1, 0> { |
980 public: | 980 public: |
981 explicit LCmpHoleAndBranch(LOperand* object) { | 981 explicit LCmpHoleAndBranch(LOperand* object) { |
982 inputs_[0] = object; | 982 inputs_[0] = object; |
983 } | 983 } |
984 | 984 |
985 LOperand* object() { return inputs_[0]; } | 985 LOperand* object() { return inputs_[0]; } |
986 | 986 |
987 DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch") | 987 DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch") |
988 DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch) | 988 DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch) |
989 }; | 989 }; |
990 | 990 |
991 | 991 |
992 class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 0> { | 992 class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 0> { |
993 public: | 993 public: |
994 explicit LCompareMinusZeroAndBranch(LOperand* value) { | 994 explicit LCompareMinusZeroAndBranch(LOperand* value) { |
995 inputs_[0] = value; | 995 inputs_[0] = value; |
996 } | 996 } |
997 | 997 |
998 LOperand* value() { return inputs_[0]; } | 998 LOperand* value() { return inputs_[0]; } |
999 | 999 |
1000 DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch, | 1000 DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch, |
1001 "cmp-minus-zero-and-branch") | 1001 "cmp-minus-zero-and-branch") |
1002 DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch) | 1002 DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch) |
1003 }; | 1003 }; |
1004 | 1004 |
1005 | 1005 |
1006 | 1006 class LIsObjectAndBranch final : public LControlInstruction<1, 0> { |
1007 class LIsObjectAndBranch FINAL : public LControlInstruction<1, 0> { | |
1008 public: | 1007 public: |
1009 explicit LIsObjectAndBranch(LOperand* value) { | 1008 explicit LIsObjectAndBranch(LOperand* value) { |
1010 inputs_[0] = value; | 1009 inputs_[0] = value; |
1011 } | 1010 } |
1012 | 1011 |
1013 LOperand* value() { return inputs_[0]; } | 1012 LOperand* value() { return inputs_[0]; } |
1014 | 1013 |
1015 DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch") | 1014 DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch") |
1016 DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch) | 1015 DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch) |
1017 | 1016 |
1018 void PrintDataTo(StringStream* stream) OVERRIDE; | 1017 void PrintDataTo(StringStream* stream) override; |
1019 }; | 1018 }; |
1020 | 1019 |
1021 | 1020 |
1022 class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> { | 1021 class LIsStringAndBranch final : public LControlInstruction<1, 1> { |
1023 public: | 1022 public: |
1024 explicit LIsStringAndBranch(LOperand* value, LOperand* temp) { | 1023 explicit LIsStringAndBranch(LOperand* value, LOperand* temp) { |
1025 inputs_[0] = value; | 1024 inputs_[0] = value; |
1026 temps_[0] = temp; | 1025 temps_[0] = temp; |
1027 } | 1026 } |
1028 | 1027 |
1029 LOperand* value() { return inputs_[0]; } | 1028 LOperand* value() { return inputs_[0]; } |
1030 LOperand* temp() { return temps_[0]; } | 1029 LOperand* temp() { return temps_[0]; } |
1031 | 1030 |
1032 DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch") | 1031 DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch") |
1033 DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch) | 1032 DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch) |
1034 | 1033 |
1035 void PrintDataTo(StringStream* stream) OVERRIDE; | 1034 void PrintDataTo(StringStream* stream) override; |
1036 }; | 1035 }; |
1037 | 1036 |
1038 | 1037 |
1039 class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> { | 1038 class LIsSmiAndBranch final : public LControlInstruction<1, 0> { |
1040 public: | 1039 public: |
1041 explicit LIsSmiAndBranch(LOperand* value) { | 1040 explicit LIsSmiAndBranch(LOperand* value) { |
1042 inputs_[0] = value; | 1041 inputs_[0] = value; |
1043 } | 1042 } |
1044 | 1043 |
1045 LOperand* value() { return inputs_[0]; } | 1044 LOperand* value() { return inputs_[0]; } |
1046 | 1045 |
1047 DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch") | 1046 DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch") |
1048 DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch) | 1047 DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch) |
1049 | 1048 |
1050 void PrintDataTo(StringStream* stream) OVERRIDE; | 1049 void PrintDataTo(StringStream* stream) override; |
1051 }; | 1050 }; |
1052 | 1051 |
1053 | 1052 |
1054 class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> { | 1053 class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> { |
1055 public: | 1054 public: |
1056 explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) { | 1055 explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) { |
1057 inputs_[0] = value; | 1056 inputs_[0] = value; |
1058 temps_[0] = temp; | 1057 temps_[0] = temp; |
1059 } | 1058 } |
1060 | 1059 |
1061 LOperand* value() { return inputs_[0]; } | 1060 LOperand* value() { return inputs_[0]; } |
1062 LOperand* temp() { return temps_[0]; } | 1061 LOperand* temp() { return temps_[0]; } |
1063 | 1062 |
1064 DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch, | 1063 DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch, |
1065 "is-undetectable-and-branch") | 1064 "is-undetectable-and-branch") |
1066 DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch) | 1065 DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch) |
1067 | 1066 |
1068 void PrintDataTo(StringStream* stream) OVERRIDE; | 1067 void PrintDataTo(StringStream* stream) override; |
1069 }; | 1068 }; |
1070 | 1069 |
1071 | 1070 |
1072 class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> { | 1071 class LStringCompareAndBranch final : public LControlInstruction<3, 0> { |
1073 public: | 1072 public: |
1074 explicit LStringCompareAndBranch(LOperand* context, | 1073 explicit LStringCompareAndBranch(LOperand* context, |
1075 LOperand* left, | 1074 LOperand* left, |
1076 LOperand* right) { | 1075 LOperand* right) { |
1077 inputs_[0] = context; | 1076 inputs_[0] = context; |
1078 inputs_[1] = left; | 1077 inputs_[1] = left; |
1079 inputs_[2] = right; | 1078 inputs_[2] = right; |
1080 } | 1079 } |
1081 | 1080 |
1082 LOperand* context() { return inputs_[0]; } | 1081 LOperand* context() { return inputs_[0]; } |
1083 LOperand* left() { return inputs_[1]; } | 1082 LOperand* left() { return inputs_[1]; } |
1084 LOperand* right() { return inputs_[2]; } | 1083 LOperand* right() { return inputs_[2]; } |
1085 | 1084 |
1086 DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch, | 1085 DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch, |
1087 "string-compare-and-branch") | 1086 "string-compare-and-branch") |
1088 DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch) | 1087 DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch) |
1089 | 1088 |
1090 void PrintDataTo(StringStream* stream) OVERRIDE; | 1089 void PrintDataTo(StringStream* stream) override; |
1091 | 1090 |
1092 Token::Value op() const { return hydrogen()->token(); } | 1091 Token::Value op() const { return hydrogen()->token(); } |
1093 }; | 1092 }; |
1094 | 1093 |
1095 | 1094 |
1096 class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> { | 1095 class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> { |
1097 public: | 1096 public: |
1098 explicit LHasInstanceTypeAndBranch(LOperand* value) { | 1097 explicit LHasInstanceTypeAndBranch(LOperand* value) { |
1099 inputs_[0] = value; | 1098 inputs_[0] = value; |
1100 } | 1099 } |
1101 | 1100 |
1102 LOperand* value() { return inputs_[0]; } | 1101 LOperand* value() { return inputs_[0]; } |
1103 | 1102 |
1104 DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch, | 1103 DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch, |
1105 "has-instance-type-and-branch") | 1104 "has-instance-type-and-branch") |
1106 DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch) | 1105 DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch) |
1107 | 1106 |
1108 void PrintDataTo(StringStream* stream) OVERRIDE; | 1107 void PrintDataTo(StringStream* stream) override; |
1109 }; | 1108 }; |
1110 | 1109 |
1111 | 1110 |
1112 class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> { | 1111 class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> { |
1113 public: | 1112 public: |
1114 explicit LGetCachedArrayIndex(LOperand* value) { | 1113 explicit LGetCachedArrayIndex(LOperand* value) { |
1115 inputs_[0] = value; | 1114 inputs_[0] = value; |
1116 } | 1115 } |
1117 | 1116 |
1118 LOperand* value() { return inputs_[0]; } | 1117 LOperand* value() { return inputs_[0]; } |
1119 | 1118 |
1120 DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") | 1119 DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") |
1121 DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) | 1120 DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) |
1122 }; | 1121 }; |
1123 | 1122 |
1124 | 1123 |
1125 class LHasCachedArrayIndexAndBranch FINAL | 1124 class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> { |
1126 : public LControlInstruction<1, 0> { | |
1127 public: | 1125 public: |
1128 explicit LHasCachedArrayIndexAndBranch(LOperand* value) { | 1126 explicit LHasCachedArrayIndexAndBranch(LOperand* value) { |
1129 inputs_[0] = value; | 1127 inputs_[0] = value; |
1130 } | 1128 } |
1131 | 1129 |
1132 LOperand* value() { return inputs_[0]; } | 1130 LOperand* value() { return inputs_[0]; } |
1133 | 1131 |
1134 DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch, | 1132 DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch, |
1135 "has-cached-array-index-and-branch") | 1133 "has-cached-array-index-and-branch") |
1136 DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch) | 1134 DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch) |
1137 | 1135 |
1138 void PrintDataTo(StringStream* stream) OVERRIDE; | 1136 void PrintDataTo(StringStream* stream) override; |
1139 }; | 1137 }; |
1140 | 1138 |
1141 | 1139 |
1142 class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> { | 1140 class LClassOfTestAndBranch final : public LControlInstruction<1, 2> { |
1143 public: | 1141 public: |
1144 LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) { | 1142 LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) { |
1145 inputs_[0] = value; | 1143 inputs_[0] = value; |
1146 temps_[0] = temp; | 1144 temps_[0] = temp; |
1147 temps_[1] = temp2; | 1145 temps_[1] = temp2; |
1148 } | 1146 } |
1149 | 1147 |
1150 LOperand* value() { return inputs_[0]; } | 1148 LOperand* value() { return inputs_[0]; } |
1151 LOperand* temp() { return temps_[0]; } | 1149 LOperand* temp() { return temps_[0]; } |
1152 LOperand* temp2() { return temps_[1]; } | 1150 LOperand* temp2() { return temps_[1]; } |
1153 | 1151 |
1154 DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, | 1152 DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, |
1155 "class-of-test-and-branch") | 1153 "class-of-test-and-branch") |
1156 DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch) | 1154 DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch) |
1157 | 1155 |
1158 void PrintDataTo(StringStream* stream) OVERRIDE; | 1156 void PrintDataTo(StringStream* stream) override; |
1159 }; | 1157 }; |
1160 | 1158 |
1161 | 1159 |
1162 class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> { | 1160 class LCmpT final : public LTemplateInstruction<1, 3, 0> { |
1163 public: | 1161 public: |
1164 LCmpT(LOperand* context, LOperand* left, LOperand* right) { | 1162 LCmpT(LOperand* context, LOperand* left, LOperand* right) { |
1165 inputs_[0] = context; | 1163 inputs_[0] = context; |
1166 inputs_[1] = left; | 1164 inputs_[1] = left; |
1167 inputs_[2] = right; | 1165 inputs_[2] = right; |
1168 } | 1166 } |
1169 | 1167 |
1170 LOperand* context() { return inputs_[0]; } | 1168 LOperand* context() { return inputs_[0]; } |
1171 LOperand* left() { return inputs_[1]; } | 1169 LOperand* left() { return inputs_[1]; } |
1172 LOperand* right() { return inputs_[2]; } | 1170 LOperand* right() { return inputs_[2]; } |
1173 | 1171 |
1174 DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t") | 1172 DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t") |
1175 DECLARE_HYDROGEN_ACCESSOR(CompareGeneric) | 1173 DECLARE_HYDROGEN_ACCESSOR(CompareGeneric) |
1176 | 1174 |
1177 Token::Value op() const { return hydrogen()->token(); } | 1175 Token::Value op() const { return hydrogen()->token(); } |
1178 }; | 1176 }; |
1179 | 1177 |
1180 | 1178 |
1181 class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> { | 1179 class LInstanceOf final : public LTemplateInstruction<1, 3, 0> { |
1182 public: | 1180 public: |
1183 LInstanceOf(LOperand* context, LOperand* left, LOperand* right) { | 1181 LInstanceOf(LOperand* context, LOperand* left, LOperand* right) { |
1184 inputs_[0] = context; | 1182 inputs_[0] = context; |
1185 inputs_[1] = left; | 1183 inputs_[1] = left; |
1186 inputs_[2] = right; | 1184 inputs_[2] = right; |
1187 } | 1185 } |
1188 | 1186 |
1189 LOperand* context() { return inputs_[0]; } | 1187 LOperand* context() { return inputs_[0]; } |
1190 LOperand* left() { return inputs_[1]; } | 1188 LOperand* left() { return inputs_[1]; } |
1191 LOperand* right() { return inputs_[2]; } | 1189 LOperand* right() { return inputs_[2]; } |
1192 | 1190 |
1193 DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of") | 1191 DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of") |
1194 }; | 1192 }; |
1195 | 1193 |
1196 | 1194 |
1197 class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> { | 1195 class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> { |
1198 public: | 1196 public: |
1199 LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) { | 1197 LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) { |
1200 inputs_[0] = context; | 1198 inputs_[0] = context; |
1201 inputs_[1] = value; | 1199 inputs_[1] = value; |
1202 temps_[0] = temp; | 1200 temps_[0] = temp; |
1203 } | 1201 } |
1204 | 1202 |
1205 LOperand* context() { return inputs_[0]; } | 1203 LOperand* context() { return inputs_[0]; } |
1206 LOperand* value() { return inputs_[1]; } | 1204 LOperand* value() { return inputs_[1]; } |
1207 LOperand* temp() { return temps_[0]; } | 1205 LOperand* temp() { return temps_[0]; } |
1208 | 1206 |
1209 DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal, | 1207 DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal, |
1210 "instance-of-known-global") | 1208 "instance-of-known-global") |
1211 DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal) | 1209 DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal) |
1212 | 1210 |
1213 Handle<JSFunction> function() const { return hydrogen()->function(); } | 1211 Handle<JSFunction> function() const { return hydrogen()->function(); } |
1214 LEnvironment* GetDeferredLazyDeoptimizationEnvironment() { | 1212 LEnvironment* GetDeferredLazyDeoptimizationEnvironment() { |
1215 return lazy_deopt_env_; | 1213 return lazy_deopt_env_; |
1216 } | 1214 } |
1217 virtual void SetDeferredLazyDeoptimizationEnvironment( | 1215 virtual void SetDeferredLazyDeoptimizationEnvironment( |
1218 LEnvironment* env) OVERRIDE { | 1216 LEnvironment* env) override { |
1219 lazy_deopt_env_ = env; | 1217 lazy_deopt_env_ = env; |
1220 } | 1218 } |
1221 | 1219 |
1222 private: | 1220 private: |
1223 LEnvironment* lazy_deopt_env_; | 1221 LEnvironment* lazy_deopt_env_; |
1224 }; | 1222 }; |
1225 | 1223 |
1226 | 1224 |
1227 class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> { | 1225 class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> { |
1228 public: | 1226 public: |
1229 LBoundsCheck(LOperand* index, LOperand* length) { | 1227 LBoundsCheck(LOperand* index, LOperand* length) { |
1230 inputs_[0] = index; | 1228 inputs_[0] = index; |
1231 inputs_[1] = length; | 1229 inputs_[1] = length; |
1232 } | 1230 } |
1233 | 1231 |
1234 LOperand* index() { return inputs_[0]; } | 1232 LOperand* index() { return inputs_[0]; } |
1235 LOperand* length() { return inputs_[1]; } | 1233 LOperand* length() { return inputs_[1]; } |
1236 | 1234 |
1237 DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check") | 1235 DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check") |
1238 DECLARE_HYDROGEN_ACCESSOR(BoundsCheck) | 1236 DECLARE_HYDROGEN_ACCESSOR(BoundsCheck) |
1239 }; | 1237 }; |
1240 | 1238 |
1241 | 1239 |
1242 class LBitI FINAL : public LTemplateInstruction<1, 2, 0> { | 1240 class LBitI final : public LTemplateInstruction<1, 2, 0> { |
1243 public: | 1241 public: |
1244 LBitI(LOperand* left, LOperand* right) { | 1242 LBitI(LOperand* left, LOperand* right) { |
1245 inputs_[0] = left; | 1243 inputs_[0] = left; |
1246 inputs_[1] = right; | 1244 inputs_[1] = right; |
1247 } | 1245 } |
1248 | 1246 |
1249 LOperand* left() { return inputs_[0]; } | 1247 LOperand* left() { return inputs_[0]; } |
1250 LOperand* right() { return inputs_[1]; } | 1248 LOperand* right() { return inputs_[1]; } |
1251 | 1249 |
1252 Token::Value op() const { return hydrogen()->op(); } | 1250 Token::Value op() const { return hydrogen()->op(); } |
1253 bool IsInteger32() const { | 1251 bool IsInteger32() const { |
1254 return hydrogen()->representation().IsInteger32(); | 1252 return hydrogen()->representation().IsInteger32(); |
1255 } | 1253 } |
1256 | 1254 |
1257 DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i") | 1255 DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i") |
1258 DECLARE_HYDROGEN_ACCESSOR(Bitwise) | 1256 DECLARE_HYDROGEN_ACCESSOR(Bitwise) |
1259 }; | 1257 }; |
1260 | 1258 |
1261 | 1259 |
1262 class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> { | 1260 class LShiftI final : public LTemplateInstruction<1, 2, 0> { |
1263 public: | 1261 public: |
1264 LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt) | 1262 LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt) |
1265 : op_(op), can_deopt_(can_deopt) { | 1263 : op_(op), can_deopt_(can_deopt) { |
1266 inputs_[0] = left; | 1264 inputs_[0] = left; |
1267 inputs_[1] = right; | 1265 inputs_[1] = right; |
1268 } | 1266 } |
1269 | 1267 |
1270 Token::Value op() const { return op_; } | 1268 Token::Value op() const { return op_; } |
1271 LOperand* left() { return inputs_[0]; } | 1269 LOperand* left() { return inputs_[0]; } |
1272 LOperand* right() { return inputs_[1]; } | 1270 LOperand* right() { return inputs_[1]; } |
1273 bool can_deopt() const { return can_deopt_; } | 1271 bool can_deopt() const { return can_deopt_; } |
1274 | 1272 |
1275 DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i") | 1273 DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i") |
1276 | 1274 |
1277 private: | 1275 private: |
1278 Token::Value op_; | 1276 Token::Value op_; |
1279 bool can_deopt_; | 1277 bool can_deopt_; |
1280 }; | 1278 }; |
1281 | 1279 |
1282 | 1280 |
1283 class LSubI FINAL : public LTemplateInstruction<1, 2, 0> { | 1281 class LSubI final : public LTemplateInstruction<1, 2, 0> { |
1284 public: | 1282 public: |
1285 LSubI(LOperand* left, LOperand* right) { | 1283 LSubI(LOperand* left, LOperand* right) { |
1286 inputs_[0] = left; | 1284 inputs_[0] = left; |
1287 inputs_[1] = right; | 1285 inputs_[1] = right; |
1288 } | 1286 } |
1289 | 1287 |
1290 LOperand* left() { return inputs_[0]; } | 1288 LOperand* left() { return inputs_[0]; } |
1291 LOperand* right() { return inputs_[1]; } | 1289 LOperand* right() { return inputs_[1]; } |
1292 | 1290 |
1293 DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i") | 1291 DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i") |
1294 DECLARE_HYDROGEN_ACCESSOR(Sub) | 1292 DECLARE_HYDROGEN_ACCESSOR(Sub) |
1295 }; | 1293 }; |
1296 | 1294 |
1297 | 1295 |
1298 class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> { | 1296 class LConstantI final : public LTemplateInstruction<1, 0, 0> { |
1299 public: | 1297 public: |
1300 DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i") | 1298 DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i") |
1301 DECLARE_HYDROGEN_ACCESSOR(Constant) | 1299 DECLARE_HYDROGEN_ACCESSOR(Constant) |
1302 | 1300 |
1303 int32_t value() const { return hydrogen()->Integer32Value(); } | 1301 int32_t value() const { return hydrogen()->Integer32Value(); } |
1304 }; | 1302 }; |
1305 | 1303 |
1306 | 1304 |
1307 class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> { | 1305 class LConstantS final : public LTemplateInstruction<1, 0, 0> { |
1308 public: | 1306 public: |
1309 DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s") | 1307 DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s") |
1310 DECLARE_HYDROGEN_ACCESSOR(Constant) | 1308 DECLARE_HYDROGEN_ACCESSOR(Constant) |
1311 | 1309 |
1312 Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); } | 1310 Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); } |
1313 }; | 1311 }; |
1314 | 1312 |
1315 | 1313 |
1316 class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> { | 1314 class LConstantD final : public LTemplateInstruction<1, 0, 0> { |
1317 public: | 1315 public: |
1318 DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d") | 1316 DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d") |
1319 DECLARE_HYDROGEN_ACCESSOR(Constant) | 1317 DECLARE_HYDROGEN_ACCESSOR(Constant) |
1320 | 1318 |
1321 uint64_t bits() const { return hydrogen()->DoubleValueAsBits(); } | 1319 uint64_t bits() const { return hydrogen()->DoubleValueAsBits(); } |
1322 }; | 1320 }; |
1323 | 1321 |
1324 | 1322 |
1325 class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> { | 1323 class LConstantE final : public LTemplateInstruction<1, 0, 0> { |
1326 public: | 1324 public: |
1327 DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e") | 1325 DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e") |
1328 DECLARE_HYDROGEN_ACCESSOR(Constant) | 1326 DECLARE_HYDROGEN_ACCESSOR(Constant) |
1329 | 1327 |
1330 ExternalReference value() const { | 1328 ExternalReference value() const { |
1331 return hydrogen()->ExternalReferenceValue(); | 1329 return hydrogen()->ExternalReferenceValue(); |
1332 } | 1330 } |
1333 }; | 1331 }; |
1334 | 1332 |
1335 | 1333 |
1336 class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> { | 1334 class LConstantT final : public LTemplateInstruction<1, 0, 0> { |
1337 public: | 1335 public: |
1338 DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t") | 1336 DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t") |
1339 DECLARE_HYDROGEN_ACCESSOR(Constant) | 1337 DECLARE_HYDROGEN_ACCESSOR(Constant) |
1340 | 1338 |
1341 Handle<Object> value(Isolate* isolate) const { | 1339 Handle<Object> value(Isolate* isolate) const { |
1342 return hydrogen()->handle(isolate); | 1340 return hydrogen()->handle(isolate); |
1343 } | 1341 } |
1344 }; | 1342 }; |
1345 | 1343 |
1346 | 1344 |
1347 class LBranch FINAL : public LControlInstruction<1, 0> { | 1345 class LBranch final : public LControlInstruction<1, 0> { |
1348 public: | 1346 public: |
1349 explicit LBranch(LOperand* value) { | 1347 explicit LBranch(LOperand* value) { |
1350 inputs_[0] = value; | 1348 inputs_[0] = value; |
1351 } | 1349 } |
1352 | 1350 |
1353 LOperand* value() { return inputs_[0]; } | 1351 LOperand* value() { return inputs_[0]; } |
1354 | 1352 |
1355 DECLARE_CONCRETE_INSTRUCTION(Branch, "branch") | 1353 DECLARE_CONCRETE_INSTRUCTION(Branch, "branch") |
1356 DECLARE_HYDROGEN_ACCESSOR(Branch) | 1354 DECLARE_HYDROGEN_ACCESSOR(Branch) |
1357 | 1355 |
1358 void PrintDataTo(StringStream* stream) OVERRIDE; | 1356 void PrintDataTo(StringStream* stream) override; |
1359 }; | 1357 }; |
1360 | 1358 |
1361 | 1359 |
1362 class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> { | 1360 class LDebugBreak final : public LTemplateInstruction<0, 0, 0> { |
1363 public: | 1361 public: |
1364 DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break") | 1362 DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break") |
1365 }; | 1363 }; |
1366 | 1364 |
1367 | 1365 |
1368 class LCmpMapAndBranch FINAL : public LControlInstruction<1, 0> { | 1366 class LCmpMapAndBranch final : public LControlInstruction<1, 0> { |
1369 public: | 1367 public: |
1370 explicit LCmpMapAndBranch(LOperand* value) { | 1368 explicit LCmpMapAndBranch(LOperand* value) { |
1371 inputs_[0] = value; | 1369 inputs_[0] = value; |
1372 } | 1370 } |
1373 | 1371 |
1374 LOperand* value() { return inputs_[0]; } | 1372 LOperand* value() { return inputs_[0]; } |
1375 | 1373 |
1376 DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch") | 1374 DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch") |
1377 DECLARE_HYDROGEN_ACCESSOR(CompareMap) | 1375 DECLARE_HYDROGEN_ACCESSOR(CompareMap) |
1378 | 1376 |
1379 Handle<Map> map() const { return hydrogen()->map().handle(); } | 1377 Handle<Map> map() const { return hydrogen()->map().handle(); } |
1380 }; | 1378 }; |
1381 | 1379 |
1382 | 1380 |
1383 class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> { | 1381 class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> { |
1384 public: | 1382 public: |
1385 explicit LMapEnumLength(LOperand* value) { | 1383 explicit LMapEnumLength(LOperand* value) { |
1386 inputs_[0] = value; | 1384 inputs_[0] = value; |
1387 } | 1385 } |
1388 | 1386 |
1389 LOperand* value() { return inputs_[0]; } | 1387 LOperand* value() { return inputs_[0]; } |
1390 | 1388 |
1391 DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length") | 1389 DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length") |
1392 }; | 1390 }; |
1393 | 1391 |
1394 | 1392 |
1395 class LDateField FINAL : public LTemplateInstruction<1, 1, 0> { | 1393 class LDateField final : public LTemplateInstruction<1, 1, 0> { |
1396 public: | 1394 public: |
1397 LDateField(LOperand* date, Smi* index) : index_(index) { | 1395 LDateField(LOperand* date, Smi* index) : index_(index) { |
1398 inputs_[0] = date; | 1396 inputs_[0] = date; |
1399 } | 1397 } |
1400 | 1398 |
1401 LOperand* date() { return inputs_[0]; } | 1399 LOperand* date() { return inputs_[0]; } |
1402 Smi* index() const { return index_; } | 1400 Smi* index() const { return index_; } |
1403 | 1401 |
1404 DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field") | 1402 DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field") |
1405 DECLARE_HYDROGEN_ACCESSOR(DateField) | 1403 DECLARE_HYDROGEN_ACCESSOR(DateField) |
1406 | 1404 |
1407 private: | 1405 private: |
1408 Smi* index_; | 1406 Smi* index_; |
1409 }; | 1407 }; |
1410 | 1408 |
1411 | 1409 |
1412 class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> { | 1410 class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> { |
1413 public: | 1411 public: |
1414 LSeqStringGetChar(LOperand* string, LOperand* index) { | 1412 LSeqStringGetChar(LOperand* string, LOperand* index) { |
1415 inputs_[0] = string; | 1413 inputs_[0] = string; |
1416 inputs_[1] = index; | 1414 inputs_[1] = index; |
1417 } | 1415 } |
1418 | 1416 |
1419 LOperand* string() const { return inputs_[0]; } | 1417 LOperand* string() const { return inputs_[0]; } |
1420 LOperand* index() const { return inputs_[1]; } | 1418 LOperand* index() const { return inputs_[1]; } |
1421 | 1419 |
1422 DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char") | 1420 DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char") |
1423 DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar) | 1421 DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar) |
1424 }; | 1422 }; |
1425 | 1423 |
1426 | 1424 |
1427 class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> { | 1425 class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> { |
1428 public: | 1426 public: |
1429 LSeqStringSetChar(LOperand* context, | 1427 LSeqStringSetChar(LOperand* context, |
1430 LOperand* string, | 1428 LOperand* string, |
1431 LOperand* index, | 1429 LOperand* index, |
1432 LOperand* value) { | 1430 LOperand* value) { |
1433 inputs_[0] = context; | 1431 inputs_[0] = context; |
1434 inputs_[1] = string; | 1432 inputs_[1] = string; |
1435 inputs_[2] = index; | 1433 inputs_[2] = index; |
1436 inputs_[3] = value; | 1434 inputs_[3] = value; |
1437 } | 1435 } |
1438 | 1436 |
1439 LOperand* string() { return inputs_[1]; } | 1437 LOperand* string() { return inputs_[1]; } |
1440 LOperand* index() { return inputs_[2]; } | 1438 LOperand* index() { return inputs_[2]; } |
1441 LOperand* value() { return inputs_[3]; } | 1439 LOperand* value() { return inputs_[3]; } |
1442 | 1440 |
1443 DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char") | 1441 DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char") |
1444 DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar) | 1442 DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar) |
1445 }; | 1443 }; |
1446 | 1444 |
1447 | 1445 |
1448 class LAddI FINAL : public LTemplateInstruction<1, 2, 0> { | 1446 class LAddI final : public LTemplateInstruction<1, 2, 0> { |
1449 public: | 1447 public: |
1450 LAddI(LOperand* left, LOperand* right) { | 1448 LAddI(LOperand* left, LOperand* right) { |
1451 inputs_[0] = left; | 1449 inputs_[0] = left; |
1452 inputs_[1] = right; | 1450 inputs_[1] = right; |
1453 } | 1451 } |
1454 | 1452 |
1455 LOperand* left() { return inputs_[0]; } | 1453 LOperand* left() { return inputs_[0]; } |
1456 LOperand* right() { return inputs_[1]; } | 1454 LOperand* right() { return inputs_[1]; } |
1457 | 1455 |
1458 static bool UseLea(HAdd* add) { | 1456 static bool UseLea(HAdd* add) { |
1459 return !add->CheckFlag(HValue::kCanOverflow) && | 1457 return !add->CheckFlag(HValue::kCanOverflow) && |
1460 add->BetterLeftOperand()->UseCount() > 1; | 1458 add->BetterLeftOperand()->UseCount() > 1; |
1461 } | 1459 } |
1462 | 1460 |
1463 DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i") | 1461 DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i") |
1464 DECLARE_HYDROGEN_ACCESSOR(Add) | 1462 DECLARE_HYDROGEN_ACCESSOR(Add) |
1465 }; | 1463 }; |
1466 | 1464 |
1467 | 1465 |
1468 class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> { | 1466 class LMathMinMax final : public LTemplateInstruction<1, 2, 0> { |
1469 public: | 1467 public: |
1470 LMathMinMax(LOperand* left, LOperand* right) { | 1468 LMathMinMax(LOperand* left, LOperand* right) { |
1471 inputs_[0] = left; | 1469 inputs_[0] = left; |
1472 inputs_[1] = right; | 1470 inputs_[1] = right; |
1473 } | 1471 } |
1474 | 1472 |
1475 LOperand* left() { return inputs_[0]; } | 1473 LOperand* left() { return inputs_[0]; } |
1476 LOperand* right() { return inputs_[1]; } | 1474 LOperand* right() { return inputs_[1]; } |
1477 | 1475 |
1478 DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max") | 1476 DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max") |
1479 DECLARE_HYDROGEN_ACCESSOR(MathMinMax) | 1477 DECLARE_HYDROGEN_ACCESSOR(MathMinMax) |
1480 }; | 1478 }; |
1481 | 1479 |
1482 | 1480 |
1483 class LPower FINAL : public LTemplateInstruction<1, 2, 0> { | 1481 class LPower final : public LTemplateInstruction<1, 2, 0> { |
1484 public: | 1482 public: |
1485 LPower(LOperand* left, LOperand* right) { | 1483 LPower(LOperand* left, LOperand* right) { |
1486 inputs_[0] = left; | 1484 inputs_[0] = left; |
1487 inputs_[1] = right; | 1485 inputs_[1] = right; |
1488 } | 1486 } |
1489 | 1487 |
1490 LOperand* left() { return inputs_[0]; } | 1488 LOperand* left() { return inputs_[0]; } |
1491 LOperand* right() { return inputs_[1]; } | 1489 LOperand* right() { return inputs_[1]; } |
1492 | 1490 |
1493 DECLARE_CONCRETE_INSTRUCTION(Power, "power") | 1491 DECLARE_CONCRETE_INSTRUCTION(Power, "power") |
1494 DECLARE_HYDROGEN_ACCESSOR(Power) | 1492 DECLARE_HYDROGEN_ACCESSOR(Power) |
1495 }; | 1493 }; |
1496 | 1494 |
1497 | 1495 |
1498 class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> { | 1496 class LArithmeticD final : public LTemplateInstruction<1, 2, 0> { |
1499 public: | 1497 public: |
1500 LArithmeticD(Token::Value op, LOperand* left, LOperand* right) | 1498 LArithmeticD(Token::Value op, LOperand* left, LOperand* right) |
1501 : op_(op) { | 1499 : op_(op) { |
1502 inputs_[0] = left; | 1500 inputs_[0] = left; |
1503 inputs_[1] = right; | 1501 inputs_[1] = right; |
1504 } | 1502 } |
1505 | 1503 |
1506 Token::Value op() const { return op_; } | 1504 Token::Value op() const { return op_; } |
1507 LOperand* left() { return inputs_[0]; } | 1505 LOperand* left() { return inputs_[0]; } |
1508 LOperand* right() { return inputs_[1]; } | 1506 LOperand* right() { return inputs_[1]; } |
1509 | 1507 |
1510 Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; } | 1508 Opcode opcode() const override { return LInstruction::kArithmeticD; } |
1511 void CompileToNative(LCodeGen* generator) OVERRIDE; | 1509 void CompileToNative(LCodeGen* generator) override; |
1512 const char* Mnemonic() const OVERRIDE; | 1510 const char* Mnemonic() const override; |
1513 | 1511 |
1514 private: | 1512 private: |
1515 Token::Value op_; | 1513 Token::Value op_; |
1516 }; | 1514 }; |
1517 | 1515 |
1518 | 1516 |
1519 class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> { | 1517 class LArithmeticT final : public LTemplateInstruction<1, 3, 0> { |
1520 public: | 1518 public: |
1521 LArithmeticT(Token::Value op, | 1519 LArithmeticT(Token::Value op, |
1522 LOperand* context, | 1520 LOperand* context, |
1523 LOperand* left, | 1521 LOperand* left, |
1524 LOperand* right) | 1522 LOperand* right) |
1525 : op_(op) { | 1523 : op_(op) { |
1526 inputs_[0] = context; | 1524 inputs_[0] = context; |
1527 inputs_[1] = left; | 1525 inputs_[1] = left; |
1528 inputs_[2] = right; | 1526 inputs_[2] = right; |
1529 } | 1527 } |
1530 | 1528 |
1531 Token::Value op() const { return op_; } | 1529 Token::Value op() const { return op_; } |
1532 LOperand* context() { return inputs_[0]; } | 1530 LOperand* context() { return inputs_[0]; } |
1533 LOperand* left() { return inputs_[1]; } | 1531 LOperand* left() { return inputs_[1]; } |
1534 LOperand* right() { return inputs_[2]; } | 1532 LOperand* right() { return inputs_[2]; } |
1535 | 1533 |
1536 Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; } | 1534 Opcode opcode() const override { return LInstruction::kArithmeticT; } |
1537 void CompileToNative(LCodeGen* generator) OVERRIDE; | 1535 void CompileToNative(LCodeGen* generator) override; |
1538 const char* Mnemonic() const OVERRIDE; | 1536 const char* Mnemonic() const override; |
1539 | 1537 |
1540 private: | 1538 private: |
1541 Token::Value op_; | 1539 Token::Value op_; |
1542 }; | 1540 }; |
1543 | 1541 |
1544 | 1542 |
1545 class LReturn FINAL : public LTemplateInstruction<0, 3, 0> { | 1543 class LReturn final : public LTemplateInstruction<0, 3, 0> { |
1546 public: | 1544 public: |
1547 explicit LReturn(LOperand* value, | 1545 explicit LReturn(LOperand* value, |
1548 LOperand* context, | 1546 LOperand* context, |
1549 LOperand* parameter_count) { | 1547 LOperand* parameter_count) { |
1550 inputs_[0] = value; | 1548 inputs_[0] = value; |
1551 inputs_[1] = context; | 1549 inputs_[1] = context; |
1552 inputs_[2] = parameter_count; | 1550 inputs_[2] = parameter_count; |
1553 } | 1551 } |
1554 | 1552 |
1555 LOperand* value() { return inputs_[0]; } | 1553 LOperand* value() { return inputs_[0]; } |
1556 LOperand* context() { return inputs_[1]; } | 1554 LOperand* context() { return inputs_[1]; } |
1557 | 1555 |
1558 bool has_constant_parameter_count() { | 1556 bool has_constant_parameter_count() { |
1559 return parameter_count()->IsConstantOperand(); | 1557 return parameter_count()->IsConstantOperand(); |
1560 } | 1558 } |
1561 LConstantOperand* constant_parameter_count() { | 1559 LConstantOperand* constant_parameter_count() { |
1562 DCHECK(has_constant_parameter_count()); | 1560 DCHECK(has_constant_parameter_count()); |
1563 return LConstantOperand::cast(parameter_count()); | 1561 return LConstantOperand::cast(parameter_count()); |
1564 } | 1562 } |
1565 LOperand* parameter_count() { return inputs_[2]; } | 1563 LOperand* parameter_count() { return inputs_[2]; } |
1566 | 1564 |
1567 DECLARE_CONCRETE_INSTRUCTION(Return, "return") | 1565 DECLARE_CONCRETE_INSTRUCTION(Return, "return") |
1568 DECLARE_HYDROGEN_ACCESSOR(Return) | 1566 DECLARE_HYDROGEN_ACCESSOR(Return) |
1569 }; | 1567 }; |
1570 | 1568 |
1571 | 1569 |
1572 class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> { | 1570 class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> { |
1573 public: | 1571 public: |
1574 explicit LLoadNamedField(LOperand* object) { | 1572 explicit LLoadNamedField(LOperand* object) { |
1575 inputs_[0] = object; | 1573 inputs_[0] = object; |
1576 } | 1574 } |
1577 | 1575 |
1578 LOperand* object() { return inputs_[0]; } | 1576 LOperand* object() { return inputs_[0]; } |
1579 | 1577 |
1580 DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field") | 1578 DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field") |
1581 DECLARE_HYDROGEN_ACCESSOR(LoadNamedField) | 1579 DECLARE_HYDROGEN_ACCESSOR(LoadNamedField) |
1582 }; | 1580 }; |
1583 | 1581 |
1584 | 1582 |
1585 class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> { | 1583 class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> { |
1586 public: | 1584 public: |
1587 explicit LLoadNamedGeneric(LOperand* context, LOperand* object, | 1585 explicit LLoadNamedGeneric(LOperand* context, LOperand* object, |
1588 LOperand* vector) { | 1586 LOperand* vector) { |
1589 inputs_[0] = context; | 1587 inputs_[0] = context; |
1590 inputs_[1] = object; | 1588 inputs_[1] = object; |
1591 temps_[0] = vector; | 1589 temps_[0] = vector; |
1592 } | 1590 } |
1593 | 1591 |
1594 DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic") | 1592 DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic") |
1595 DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric) | 1593 DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric) |
1596 | 1594 |
1597 LOperand* context() { return inputs_[0]; } | 1595 LOperand* context() { return inputs_[0]; } |
1598 LOperand* object() { return inputs_[1]; } | 1596 LOperand* object() { return inputs_[1]; } |
1599 LOperand* temp_vector() { return temps_[0]; } | 1597 LOperand* temp_vector() { return temps_[0]; } |
1600 | 1598 |
1601 Handle<Object> name() const { return hydrogen()->name(); } | 1599 Handle<Object> name() const { return hydrogen()->name(); } |
1602 }; | 1600 }; |
1603 | 1601 |
1604 | 1602 |
1605 class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> { | 1603 class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> { |
1606 public: | 1604 public: |
1607 explicit LLoadFunctionPrototype(LOperand* function) { | 1605 explicit LLoadFunctionPrototype(LOperand* function) { |
1608 inputs_[0] = function; | 1606 inputs_[0] = function; |
1609 } | 1607 } |
1610 | 1608 |
1611 DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype") | 1609 DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype") |
1612 DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype) | 1610 DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype) |
1613 | 1611 |
1614 LOperand* function() { return inputs_[0]; } | 1612 LOperand* function() { return inputs_[0]; } |
1615 }; | 1613 }; |
1616 | 1614 |
1617 | 1615 |
1618 class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> { | 1616 class LLoadRoot final : public LTemplateInstruction<1, 0, 0> { |
1619 public: | 1617 public: |
1620 DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root") | 1618 DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root") |
1621 DECLARE_HYDROGEN_ACCESSOR(LoadRoot) | 1619 DECLARE_HYDROGEN_ACCESSOR(LoadRoot) |
1622 | 1620 |
1623 Heap::RootListIndex index() const { return hydrogen()->index(); } | 1621 Heap::RootListIndex index() const { return hydrogen()->index(); } |
1624 }; | 1622 }; |
1625 | 1623 |
1626 | 1624 |
1627 inline static bool ExternalArrayOpRequiresTemp( | 1625 inline static bool ExternalArrayOpRequiresTemp( |
1628 Representation key_representation, | 1626 Representation key_representation, |
1629 ElementsKind elements_kind) { | 1627 ElementsKind elements_kind) { |
1630 // Operations that require the key to be divided by two to be converted into | 1628 // Operations that require the key to be divided by two to be converted into |
1631 // an index cannot fold the scale operation into a load and need an extra | 1629 // an index cannot fold the scale operation into a load and need an extra |
1632 // temp register to do the work. | 1630 // temp register to do the work. |
1633 return SmiValuesAre31Bits() && key_representation.IsSmi() && | 1631 return SmiValuesAre31Bits() && key_representation.IsSmi() && |
1634 (elements_kind == EXTERNAL_INT8_ELEMENTS || | 1632 (elements_kind == EXTERNAL_INT8_ELEMENTS || |
1635 elements_kind == EXTERNAL_UINT8_ELEMENTS || | 1633 elements_kind == EXTERNAL_UINT8_ELEMENTS || |
1636 elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS || | 1634 elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS || |
1637 elements_kind == UINT8_ELEMENTS || | 1635 elements_kind == UINT8_ELEMENTS || |
1638 elements_kind == INT8_ELEMENTS || | 1636 elements_kind == INT8_ELEMENTS || |
1639 elements_kind == UINT8_CLAMPED_ELEMENTS); | 1637 elements_kind == UINT8_CLAMPED_ELEMENTS); |
1640 } | 1638 } |
1641 | 1639 |
1642 | 1640 |
1643 class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> { | 1641 class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> { |
1644 public: | 1642 public: |
1645 LLoadKeyed(LOperand* elements, LOperand* key) { | 1643 LLoadKeyed(LOperand* elements, LOperand* key) { |
1646 inputs_[0] = elements; | 1644 inputs_[0] = elements; |
1647 inputs_[1] = key; | 1645 inputs_[1] = key; |
1648 } | 1646 } |
1649 | 1647 |
1650 DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed") | 1648 DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed") |
1651 DECLARE_HYDROGEN_ACCESSOR(LoadKeyed) | 1649 DECLARE_HYDROGEN_ACCESSOR(LoadKeyed) |
1652 | 1650 |
1653 bool is_external() const { | 1651 bool is_external() const { |
1654 return hydrogen()->is_external(); | 1652 return hydrogen()->is_external(); |
1655 } | 1653 } |
1656 bool is_fixed_typed_array() const { | 1654 bool is_fixed_typed_array() const { |
1657 return hydrogen()->is_fixed_typed_array(); | 1655 return hydrogen()->is_fixed_typed_array(); |
1658 } | 1656 } |
1659 bool is_typed_elements() const { | 1657 bool is_typed_elements() const { |
1660 return is_external() || is_fixed_typed_array(); | 1658 return is_external() || is_fixed_typed_array(); |
1661 } | 1659 } |
1662 LOperand* elements() { return inputs_[0]; } | 1660 LOperand* elements() { return inputs_[0]; } |
1663 LOperand* key() { return inputs_[1]; } | 1661 LOperand* key() { return inputs_[1]; } |
1664 void PrintDataTo(StringStream* stream) OVERRIDE; | 1662 void PrintDataTo(StringStream* stream) override; |
1665 uint32_t base_offset() const { return hydrogen()->base_offset(); } | 1663 uint32_t base_offset() const { return hydrogen()->base_offset(); } |
1666 ElementsKind elements_kind() const { | 1664 ElementsKind elements_kind() const { |
1667 return hydrogen()->elements_kind(); | 1665 return hydrogen()->elements_kind(); |
1668 } | 1666 } |
1669 }; | 1667 }; |
1670 | 1668 |
1671 | 1669 |
1672 class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> { | 1670 class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> { |
1673 public: | 1671 public: |
1674 LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key, | 1672 LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key, |
1675 LOperand* vector) { | 1673 LOperand* vector) { |
1676 inputs_[0] = context; | 1674 inputs_[0] = context; |
1677 inputs_[1] = obj; | 1675 inputs_[1] = obj; |
1678 inputs_[2] = key; | 1676 inputs_[2] = key; |
1679 temps_[0] = vector; | 1677 temps_[0] = vector; |
1680 } | 1678 } |
1681 | 1679 |
1682 DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic") | 1680 DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic") |
1683 DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric) | 1681 DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric) |
1684 | 1682 |
1685 LOperand* context() { return inputs_[0]; } | 1683 LOperand* context() { return inputs_[0]; } |
1686 LOperand* object() { return inputs_[1]; } | 1684 LOperand* object() { return inputs_[1]; } |
1687 LOperand* key() { return inputs_[2]; } | 1685 LOperand* key() { return inputs_[2]; } |
1688 LOperand* temp_vector() { return temps_[0]; } | 1686 LOperand* temp_vector() { return temps_[0]; } |
1689 }; | 1687 }; |
1690 | 1688 |
1691 | 1689 |
1692 class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> { | 1690 class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> { |
1693 public: | 1691 public: |
1694 explicit LLoadGlobalGeneric(LOperand* context, LOperand* global_object, | 1692 explicit LLoadGlobalGeneric(LOperand* context, LOperand* global_object, |
1695 LOperand* vector) { | 1693 LOperand* vector) { |
1696 inputs_[0] = context; | 1694 inputs_[0] = context; |
1697 inputs_[1] = global_object; | 1695 inputs_[1] = global_object; |
1698 temps_[0] = vector; | 1696 temps_[0] = vector; |
1699 } | 1697 } |
1700 | 1698 |
1701 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic") | 1699 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic") |
1702 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric) | 1700 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric) |
1703 | 1701 |
1704 LOperand* context() { return inputs_[0]; } | 1702 LOperand* context() { return inputs_[0]; } |
1705 LOperand* global_object() { return inputs_[1]; } | 1703 LOperand* global_object() { return inputs_[1]; } |
1706 LOperand* temp_vector() { return temps_[0]; } | 1704 LOperand* temp_vector() { return temps_[0]; } |
1707 | 1705 |
1708 Handle<Object> name() const { return hydrogen()->name(); } | 1706 Handle<Object> name() const { return hydrogen()->name(); } |
1709 bool for_typeof() const { return hydrogen()->for_typeof(); } | 1707 bool for_typeof() const { return hydrogen()->for_typeof(); } |
1710 }; | 1708 }; |
1711 | 1709 |
1712 | 1710 |
1713 class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> { | 1711 class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> { |
1714 public: | 1712 public: |
1715 explicit LLoadContextSlot(LOperand* context) { | 1713 explicit LLoadContextSlot(LOperand* context) { |
1716 inputs_[0] = context; | 1714 inputs_[0] = context; |
1717 } | 1715 } |
1718 | 1716 |
1719 LOperand* context() { return inputs_[0]; } | 1717 LOperand* context() { return inputs_[0]; } |
1720 | 1718 |
1721 DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot") | 1719 DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot") |
1722 DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot) | 1720 DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot) |
1723 | 1721 |
1724 int slot_index() { return hydrogen()->slot_index(); } | 1722 int slot_index() { return hydrogen()->slot_index(); } |
1725 | 1723 |
1726 void PrintDataTo(StringStream* stream) OVERRIDE; | 1724 void PrintDataTo(StringStream* stream) override; |
1727 }; | 1725 }; |
1728 | 1726 |
1729 | 1727 |
1730 class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> { | 1728 class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> { |
1731 public: | 1729 public: |
1732 LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) { | 1730 LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) { |
1733 inputs_[0] = context; | 1731 inputs_[0] = context; |
1734 inputs_[1] = value; | 1732 inputs_[1] = value; |
1735 temps_[0] = temp; | 1733 temps_[0] = temp; |
1736 } | 1734 } |
1737 | 1735 |
1738 LOperand* context() { return inputs_[0]; } | 1736 LOperand* context() { return inputs_[0]; } |
1739 LOperand* value() { return inputs_[1]; } | 1737 LOperand* value() { return inputs_[1]; } |
1740 LOperand* temp() { return temps_[0]; } | 1738 LOperand* temp() { return temps_[0]; } |
1741 | 1739 |
1742 DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot") | 1740 DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot") |
1743 DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot) | 1741 DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot) |
1744 | 1742 |
1745 int slot_index() { return hydrogen()->slot_index(); } | 1743 int slot_index() { return hydrogen()->slot_index(); } |
1746 | 1744 |
1747 void PrintDataTo(StringStream* stream) OVERRIDE; | 1745 void PrintDataTo(StringStream* stream) override; |
1748 }; | 1746 }; |
1749 | 1747 |
1750 | 1748 |
1751 class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> { | 1749 class LPushArgument final : public LTemplateInstruction<0, 1, 0> { |
1752 public: | 1750 public: |
1753 explicit LPushArgument(LOperand* value) { | 1751 explicit LPushArgument(LOperand* value) { |
1754 inputs_[0] = value; | 1752 inputs_[0] = value; |
1755 } | 1753 } |
1756 | 1754 |
1757 LOperand* value() { return inputs_[0]; } | 1755 LOperand* value() { return inputs_[0]; } |
1758 | 1756 |
1759 DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument") | 1757 DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument") |
1760 }; | 1758 }; |
1761 | 1759 |
1762 | 1760 |
1763 class LDrop FINAL : public LTemplateInstruction<0, 0, 0> { | 1761 class LDrop final : public LTemplateInstruction<0, 0, 0> { |
1764 public: | 1762 public: |
1765 explicit LDrop(int count) : count_(count) { } | 1763 explicit LDrop(int count) : count_(count) { } |
1766 | 1764 |
1767 int count() const { return count_; } | 1765 int count() const { return count_; } |
1768 | 1766 |
1769 DECLARE_CONCRETE_INSTRUCTION(Drop, "drop") | 1767 DECLARE_CONCRETE_INSTRUCTION(Drop, "drop") |
1770 | 1768 |
1771 private: | 1769 private: |
1772 int count_; | 1770 int count_; |
1773 }; | 1771 }; |
1774 | 1772 |
1775 | 1773 |
1776 class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> { | 1774 class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> { |
1777 public: | 1775 public: |
1778 LStoreCodeEntry(LOperand* function, LOperand* code_object) { | 1776 LStoreCodeEntry(LOperand* function, LOperand* code_object) { |
1779 inputs_[0] = function; | 1777 inputs_[0] = function; |
1780 inputs_[1] = code_object; | 1778 inputs_[1] = code_object; |
1781 } | 1779 } |
1782 | 1780 |
1783 LOperand* function() { return inputs_[0]; } | 1781 LOperand* function() { return inputs_[0]; } |
1784 LOperand* code_object() { return inputs_[1]; } | 1782 LOperand* code_object() { return inputs_[1]; } |
1785 | 1783 |
1786 void PrintDataTo(StringStream* stream) OVERRIDE; | 1784 void PrintDataTo(StringStream* stream) override; |
1787 | 1785 |
1788 DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry") | 1786 DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry") |
1789 DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry) | 1787 DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry) |
1790 }; | 1788 }; |
1791 | 1789 |
1792 | 1790 |
1793 class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> { | 1791 class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> { |
1794 public: | 1792 public: |
1795 LInnerAllocatedObject(LOperand* base_object, LOperand* offset) { | 1793 LInnerAllocatedObject(LOperand* base_object, LOperand* offset) { |
1796 inputs_[0] = base_object; | 1794 inputs_[0] = base_object; |
1797 inputs_[1] = offset; | 1795 inputs_[1] = offset; |
1798 } | 1796 } |
1799 | 1797 |
1800 LOperand* base_object() const { return inputs_[0]; } | 1798 LOperand* base_object() const { return inputs_[0]; } |
1801 LOperand* offset() const { return inputs_[1]; } | 1799 LOperand* offset() const { return inputs_[1]; } |
1802 | 1800 |
1803 void PrintDataTo(StringStream* stream) OVERRIDE; | 1801 void PrintDataTo(StringStream* stream) override; |
1804 | 1802 |
1805 DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object") | 1803 DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object") |
1806 }; | 1804 }; |
1807 | 1805 |
1808 | 1806 |
1809 class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> { | 1807 class LThisFunction final : public LTemplateInstruction<1, 0, 0> { |
1810 public: | 1808 public: |
1811 DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function") | 1809 DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function") |
1812 DECLARE_HYDROGEN_ACCESSOR(ThisFunction) | 1810 DECLARE_HYDROGEN_ACCESSOR(ThisFunction) |
1813 }; | 1811 }; |
1814 | 1812 |
1815 | 1813 |
1816 class LContext FINAL : public LTemplateInstruction<1, 0, 0> { | 1814 class LContext final : public LTemplateInstruction<1, 0, 0> { |
1817 public: | 1815 public: |
1818 DECLARE_CONCRETE_INSTRUCTION(Context, "context") | 1816 DECLARE_CONCRETE_INSTRUCTION(Context, "context") |
1819 DECLARE_HYDROGEN_ACCESSOR(Context) | 1817 DECLARE_HYDROGEN_ACCESSOR(Context) |
1820 }; | 1818 }; |
1821 | 1819 |
1822 | 1820 |
1823 class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> { | 1821 class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> { |
1824 public: | 1822 public: |
1825 explicit LDeclareGlobals(LOperand* context) { | 1823 explicit LDeclareGlobals(LOperand* context) { |
1826 inputs_[0] = context; | 1824 inputs_[0] = context; |
1827 } | 1825 } |
1828 | 1826 |
1829 LOperand* context() { return inputs_[0]; } | 1827 LOperand* context() { return inputs_[0]; } |
1830 | 1828 |
1831 DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals") | 1829 DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals") |
1832 DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals) | 1830 DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals) |
1833 }; | 1831 }; |
1834 | 1832 |
1835 | 1833 |
1836 class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> { | 1834 class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> { |
1837 public: | 1835 public: |
1838 explicit LCallJSFunction(LOperand* function) { | 1836 explicit LCallJSFunction(LOperand* function) { |
1839 inputs_[0] = function; | 1837 inputs_[0] = function; |
1840 } | 1838 } |
1841 | 1839 |
1842 LOperand* function() { return inputs_[0]; } | 1840 LOperand* function() { return inputs_[0]; } |
1843 | 1841 |
1844 DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function") | 1842 DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function") |
1845 DECLARE_HYDROGEN_ACCESSOR(CallJSFunction) | 1843 DECLARE_HYDROGEN_ACCESSOR(CallJSFunction) |
1846 | 1844 |
1847 void PrintDataTo(StringStream* stream) OVERRIDE; | 1845 void PrintDataTo(StringStream* stream) override; |
1848 | 1846 |
1849 int arity() const { return hydrogen()->argument_count() - 1; } | 1847 int arity() const { return hydrogen()->argument_count() - 1; } |
1850 }; | 1848 }; |
1851 | 1849 |
1852 | 1850 |
1853 class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> { | 1851 class LCallWithDescriptor final : public LTemplateResultInstruction<1> { |
1854 public: | 1852 public: |
1855 LCallWithDescriptor(CallInterfaceDescriptor descriptor, | 1853 LCallWithDescriptor(CallInterfaceDescriptor descriptor, |
1856 const ZoneList<LOperand*>& operands, Zone* zone) | 1854 const ZoneList<LOperand*>& operands, Zone* zone) |
1857 : inputs_(descriptor.GetRegisterParameterCount() + 1, zone) { | 1855 : inputs_(descriptor.GetRegisterParameterCount() + 1, zone) { |
1858 DCHECK(descriptor.GetRegisterParameterCount() + 1 == operands.length()); | 1856 DCHECK(descriptor.GetRegisterParameterCount() + 1 == operands.length()); |
1859 inputs_.AddAll(operands, zone); | 1857 inputs_.AddAll(operands, zone); |
1860 } | 1858 } |
1861 | 1859 |
1862 LOperand* target() const { return inputs_[0]; } | 1860 LOperand* target() const { return inputs_[0]; } |
1863 | 1861 |
1864 DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor) | 1862 DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor) |
1865 | 1863 |
1866 private: | 1864 private: |
1867 DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor") | 1865 DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor") |
1868 | 1866 |
1869 void PrintDataTo(StringStream* stream) OVERRIDE; | 1867 void PrintDataTo(StringStream* stream) override; |
1870 | 1868 |
1871 int arity() const { return hydrogen()->argument_count() - 1; } | 1869 int arity() const { return hydrogen()->argument_count() - 1; } |
1872 | 1870 |
1873 ZoneList<LOperand*> inputs_; | 1871 ZoneList<LOperand*> inputs_; |
1874 | 1872 |
1875 // Iterator support. | 1873 // Iterator support. |
1876 int InputCount() FINAL { return inputs_.length(); } | 1874 int InputCount() final { return inputs_.length(); } |
1877 LOperand* InputAt(int i) FINAL { return inputs_[i]; } | 1875 LOperand* InputAt(int i) final { return inputs_[i]; } |
1878 | 1876 |
1879 int TempCount() FINAL { return 0; } | 1877 int TempCount() final { return 0; } |
1880 LOperand* TempAt(int i) FINAL { return NULL; } | 1878 LOperand* TempAt(int i) final { return NULL; } |
1881 }; | 1879 }; |
1882 | 1880 |
1883 | 1881 |
1884 class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> { | 1882 class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> { |
1885 public: | 1883 public: |
1886 LInvokeFunction(LOperand* context, LOperand* function) { | 1884 LInvokeFunction(LOperand* context, LOperand* function) { |
1887 inputs_[0] = context; | 1885 inputs_[0] = context; |
1888 inputs_[1] = function; | 1886 inputs_[1] = function; |
1889 } | 1887 } |
1890 | 1888 |
1891 LOperand* context() { return inputs_[0]; } | 1889 LOperand* context() { return inputs_[0]; } |
1892 LOperand* function() { return inputs_[1]; } | 1890 LOperand* function() { return inputs_[1]; } |
1893 | 1891 |
1894 DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function") | 1892 DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function") |
1895 DECLARE_HYDROGEN_ACCESSOR(InvokeFunction) | 1893 DECLARE_HYDROGEN_ACCESSOR(InvokeFunction) |
1896 | 1894 |
1897 void PrintDataTo(StringStream* stream) OVERRIDE; | 1895 void PrintDataTo(StringStream* stream) override; |
1898 | 1896 |
1899 int arity() const { return hydrogen()->argument_count() - 1; } | 1897 int arity() const { return hydrogen()->argument_count() - 1; } |
1900 }; | 1898 }; |
1901 | 1899 |
1902 | 1900 |
1903 class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> { | 1901 class LCallFunction final : public LTemplateInstruction<1, 2, 2> { |
1904 public: | 1902 public: |
1905 LCallFunction(LOperand* context, LOperand* function, LOperand* slot, | 1903 LCallFunction(LOperand* context, LOperand* function, LOperand* slot, |
1906 LOperand* vector) { | 1904 LOperand* vector) { |
1907 inputs_[0] = context; | 1905 inputs_[0] = context; |
1908 inputs_[1] = function; | 1906 inputs_[1] = function; |
1909 temps_[0] = slot; | 1907 temps_[0] = slot; |
1910 temps_[1] = vector; | 1908 temps_[1] = vector; |
1911 } | 1909 } |
1912 | 1910 |
1913 DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function") | 1911 DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function") |
1914 DECLARE_HYDROGEN_ACCESSOR(CallFunction) | 1912 DECLARE_HYDROGEN_ACCESSOR(CallFunction) |
1915 | 1913 |
1916 LOperand* context() { return inputs_[0]; } | 1914 LOperand* context() { return inputs_[0]; } |
1917 LOperand* function() { return inputs_[1]; } | 1915 LOperand* function() { return inputs_[1]; } |
1918 LOperand* temp_slot() { return temps_[0]; } | 1916 LOperand* temp_slot() { return temps_[0]; } |
1919 LOperand* temp_vector() { return temps_[1]; } | 1917 LOperand* temp_vector() { return temps_[1]; } |
1920 int arity() const { return hydrogen()->argument_count() - 1; } | 1918 int arity() const { return hydrogen()->argument_count() - 1; } |
1921 | 1919 |
1922 void PrintDataTo(StringStream* stream) OVERRIDE; | 1920 void PrintDataTo(StringStream* stream) override; |
1923 }; | 1921 }; |
1924 | 1922 |
1925 | 1923 |
1926 class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> { | 1924 class LCallNew final : public LTemplateInstruction<1, 2, 0> { |
1927 public: | 1925 public: |
1928 LCallNew(LOperand* context, LOperand* constructor) { | 1926 LCallNew(LOperand* context, LOperand* constructor) { |
1929 inputs_[0] = context; | 1927 inputs_[0] = context; |
1930 inputs_[1] = constructor; | 1928 inputs_[1] = constructor; |
1931 } | 1929 } |
1932 | 1930 |
1933 LOperand* context() { return inputs_[0]; } | 1931 LOperand* context() { return inputs_[0]; } |
1934 LOperand* constructor() { return inputs_[1]; } | 1932 LOperand* constructor() { return inputs_[1]; } |
1935 | 1933 |
1936 DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new") | 1934 DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new") |
1937 DECLARE_HYDROGEN_ACCESSOR(CallNew) | 1935 DECLARE_HYDROGEN_ACCESSOR(CallNew) |
1938 | 1936 |
1939 void PrintDataTo(StringStream* stream) OVERRIDE; | 1937 void PrintDataTo(StringStream* stream) override; |
1940 | 1938 |
1941 int arity() const { return hydrogen()->argument_count() - 1; } | 1939 int arity() const { return hydrogen()->argument_count() - 1; } |
1942 }; | 1940 }; |
1943 | 1941 |
1944 | 1942 |
1945 class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> { | 1943 class LCallNewArray final : public LTemplateInstruction<1, 2, 0> { |
1946 public: | 1944 public: |
1947 LCallNewArray(LOperand* context, LOperand* constructor) { | 1945 LCallNewArray(LOperand* context, LOperand* constructor) { |
1948 inputs_[0] = context; | 1946 inputs_[0] = context; |
1949 inputs_[1] = constructor; | 1947 inputs_[1] = constructor; |
1950 } | 1948 } |
1951 | 1949 |
1952 LOperand* context() { return inputs_[0]; } | 1950 LOperand* context() { return inputs_[0]; } |
1953 LOperand* constructor() { return inputs_[1]; } | 1951 LOperand* constructor() { return inputs_[1]; } |
1954 | 1952 |
1955 DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array") | 1953 DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array") |
1956 DECLARE_HYDROGEN_ACCESSOR(CallNewArray) | 1954 DECLARE_HYDROGEN_ACCESSOR(CallNewArray) |
1957 | 1955 |
1958 void PrintDataTo(StringStream* stream) OVERRIDE; | 1956 void PrintDataTo(StringStream* stream) override; |
1959 | 1957 |
1960 int arity() const { return hydrogen()->argument_count() - 1; } | 1958 int arity() const { return hydrogen()->argument_count() - 1; } |
1961 }; | 1959 }; |
1962 | 1960 |
1963 | 1961 |
1964 class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> { | 1962 class LCallRuntime final : public LTemplateInstruction<1, 1, 0> { |
1965 public: | 1963 public: |
1966 explicit LCallRuntime(LOperand* context) { | 1964 explicit LCallRuntime(LOperand* context) { |
1967 inputs_[0] = context; | 1965 inputs_[0] = context; |
1968 } | 1966 } |
1969 | 1967 |
1970 LOperand* context() { return inputs_[0]; } | 1968 LOperand* context() { return inputs_[0]; } |
1971 | 1969 |
1972 DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime") | 1970 DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime") |
1973 DECLARE_HYDROGEN_ACCESSOR(CallRuntime) | 1971 DECLARE_HYDROGEN_ACCESSOR(CallRuntime) |
1974 | 1972 |
1975 bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE { | 1973 bool ClobbersDoubleRegisters(Isolate* isolate) const override { |
1976 return save_doubles() == kDontSaveFPRegs; | 1974 return save_doubles() == kDontSaveFPRegs; |
1977 } | 1975 } |
1978 | 1976 |
1979 const Runtime::Function* function() const { return hydrogen()->function(); } | 1977 const Runtime::Function* function() const { return hydrogen()->function(); } |
1980 int arity() const { return hydrogen()->argument_count(); } | 1978 int arity() const { return hydrogen()->argument_count(); } |
1981 SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); } | 1979 SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); } |
1982 }; | 1980 }; |
1983 | 1981 |
1984 | 1982 |
1985 class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> { | 1983 class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> { |
1986 public: | 1984 public: |
1987 explicit LInteger32ToDouble(LOperand* value) { | 1985 explicit LInteger32ToDouble(LOperand* value) { |
1988 inputs_[0] = value; | 1986 inputs_[0] = value; |
1989 } | 1987 } |
1990 | 1988 |
1991 LOperand* value() { return inputs_[0]; } | 1989 LOperand* value() { return inputs_[0]; } |
1992 | 1990 |
1993 DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double") | 1991 DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double") |
1994 }; | 1992 }; |
1995 | 1993 |
1996 | 1994 |
1997 class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> { | 1995 class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> { |
1998 public: | 1996 public: |
1999 explicit LUint32ToDouble(LOperand* value) { | 1997 explicit LUint32ToDouble(LOperand* value) { |
2000 inputs_[0] = value; | 1998 inputs_[0] = value; |
2001 } | 1999 } |
2002 | 2000 |
2003 LOperand* value() { return inputs_[0]; } | 2001 LOperand* value() { return inputs_[0]; } |
2004 | 2002 |
2005 DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double") | 2003 DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double") |
2006 }; | 2004 }; |
2007 | 2005 |
2008 | 2006 |
2009 class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> { | 2007 class LNumberTagI final : public LTemplateInstruction<1, 1, 2> { |
2010 public: | 2008 public: |
2011 LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) { | 2009 LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) { |
2012 inputs_[0] = value; | 2010 inputs_[0] = value; |
2013 temps_[0] = temp1; | 2011 temps_[0] = temp1; |
2014 temps_[1] = temp2; | 2012 temps_[1] = temp2; |
2015 } | 2013 } |
2016 | 2014 |
2017 LOperand* value() { return inputs_[0]; } | 2015 LOperand* value() { return inputs_[0]; } |
2018 LOperand* temp1() { return temps_[0]; } | 2016 LOperand* temp1() { return temps_[0]; } |
2019 LOperand* temp2() { return temps_[1]; } | 2017 LOperand* temp2() { return temps_[1]; } |
2020 | 2018 |
2021 DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i") | 2019 DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i") |
2022 }; | 2020 }; |
2023 | 2021 |
2024 | 2022 |
2025 class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> { | 2023 class LNumberTagU final : public LTemplateInstruction<1, 1, 2> { |
2026 public: | 2024 public: |
2027 LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) { | 2025 LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) { |
2028 inputs_[0] = value; | 2026 inputs_[0] = value; |
2029 temps_[0] = temp1; | 2027 temps_[0] = temp1; |
2030 temps_[1] = temp2; | 2028 temps_[1] = temp2; |
2031 } | 2029 } |
2032 | 2030 |
2033 LOperand* value() { return inputs_[0]; } | 2031 LOperand* value() { return inputs_[0]; } |
2034 LOperand* temp1() { return temps_[0]; } | 2032 LOperand* temp1() { return temps_[0]; } |
2035 LOperand* temp2() { return temps_[1]; } | 2033 LOperand* temp2() { return temps_[1]; } |
2036 | 2034 |
2037 DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u") | 2035 DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u") |
2038 }; | 2036 }; |
2039 | 2037 |
2040 | 2038 |
2041 class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 1> { | 2039 class LNumberTagD final : public LTemplateInstruction<1, 1, 1> { |
2042 public: | 2040 public: |
2043 explicit LNumberTagD(LOperand* value, LOperand* temp) { | 2041 explicit LNumberTagD(LOperand* value, LOperand* temp) { |
2044 inputs_[0] = value; | 2042 inputs_[0] = value; |
2045 temps_[0] = temp; | 2043 temps_[0] = temp; |
2046 } | 2044 } |
2047 | 2045 |
2048 LOperand* value() { return inputs_[0]; } | 2046 LOperand* value() { return inputs_[0]; } |
2049 LOperand* temp() { return temps_[0]; } | 2047 LOperand* temp() { return temps_[0]; } |
2050 | 2048 |
2051 DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d") | 2049 DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d") |
2052 DECLARE_HYDROGEN_ACCESSOR(Change) | 2050 DECLARE_HYDROGEN_ACCESSOR(Change) |
2053 }; | 2051 }; |
2054 | 2052 |
2055 | 2053 |
2056 // Sometimes truncating conversion from a tagged value to an int32. | 2054 // Sometimes truncating conversion from a tagged value to an int32. |
2057 class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> { | 2055 class LDoubleToI final : public LTemplateInstruction<1, 1, 0> { |
2058 public: | 2056 public: |
2059 explicit LDoubleToI(LOperand* value) { | 2057 explicit LDoubleToI(LOperand* value) { |
2060 inputs_[0] = value; | 2058 inputs_[0] = value; |
2061 } | 2059 } |
2062 | 2060 |
2063 LOperand* value() { return inputs_[0]; } | 2061 LOperand* value() { return inputs_[0]; } |
2064 | 2062 |
2065 DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") | 2063 DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") |
2066 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) | 2064 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) |
2067 | 2065 |
2068 bool truncating() { return hydrogen()->CanTruncateToInt32(); } | 2066 bool truncating() { return hydrogen()->CanTruncateToInt32(); } |
2069 }; | 2067 }; |
2070 | 2068 |
2071 | 2069 |
2072 class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> { | 2070 class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> { |
2073 public: | 2071 public: |
2074 explicit LDoubleToSmi(LOperand* value) { | 2072 explicit LDoubleToSmi(LOperand* value) { |
2075 inputs_[0] = value; | 2073 inputs_[0] = value; |
2076 } | 2074 } |
2077 | 2075 |
2078 LOperand* value() { return inputs_[0]; } | 2076 LOperand* value() { return inputs_[0]; } |
2079 | 2077 |
2080 DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi") | 2078 DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi") |
2081 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) | 2079 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) |
2082 }; | 2080 }; |
2083 | 2081 |
2084 | 2082 |
2085 // Truncating conversion from a tagged value to an int32. | 2083 // Truncating conversion from a tagged value to an int32. |
2086 class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 1> { | 2084 class LTaggedToI final : public LTemplateInstruction<1, 1, 1> { |
2087 public: | 2085 public: |
2088 LTaggedToI(LOperand* value, LOperand* temp) { | 2086 LTaggedToI(LOperand* value, LOperand* temp) { |
2089 inputs_[0] = value; | 2087 inputs_[0] = value; |
2090 temps_[0] = temp; | 2088 temps_[0] = temp; |
2091 } | 2089 } |
2092 | 2090 |
2093 LOperand* value() { return inputs_[0]; } | 2091 LOperand* value() { return inputs_[0]; } |
2094 LOperand* temp() { return temps_[0]; } | 2092 LOperand* temp() { return temps_[0]; } |
2095 | 2093 |
2096 DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") | 2094 DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") |
2097 DECLARE_HYDROGEN_ACCESSOR(Change) | 2095 DECLARE_HYDROGEN_ACCESSOR(Change) |
2098 | 2096 |
2099 bool truncating() { return hydrogen()->CanTruncateToInt32(); } | 2097 bool truncating() { return hydrogen()->CanTruncateToInt32(); } |
2100 }; | 2098 }; |
2101 | 2099 |
2102 | 2100 |
2103 class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> { | 2101 class LSmiTag final : public LTemplateInstruction<1, 1, 0> { |
2104 public: | 2102 public: |
2105 explicit LSmiTag(LOperand* value) { | 2103 explicit LSmiTag(LOperand* value) { |
2106 inputs_[0] = value; | 2104 inputs_[0] = value; |
2107 } | 2105 } |
2108 | 2106 |
2109 LOperand* value() { return inputs_[0]; } | 2107 LOperand* value() { return inputs_[0]; } |
2110 | 2108 |
2111 DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag") | 2109 DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag") |
2112 DECLARE_HYDROGEN_ACCESSOR(Change) | 2110 DECLARE_HYDROGEN_ACCESSOR(Change) |
2113 }; | 2111 }; |
2114 | 2112 |
2115 | 2113 |
2116 class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> { | 2114 class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> { |
2117 public: | 2115 public: |
2118 explicit LNumberUntagD(LOperand* value) { | 2116 explicit LNumberUntagD(LOperand* value) { |
2119 inputs_[0] = value; | 2117 inputs_[0] = value; |
2120 } | 2118 } |
2121 | 2119 |
2122 LOperand* value() { return inputs_[0]; } | 2120 LOperand* value() { return inputs_[0]; } |
2123 | 2121 |
2124 DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") | 2122 DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") |
2125 DECLARE_HYDROGEN_ACCESSOR(Change); | 2123 DECLARE_HYDROGEN_ACCESSOR(Change); |
2126 }; | 2124 }; |
2127 | 2125 |
2128 | 2126 |
2129 class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> { | 2127 class LSmiUntag final : public LTemplateInstruction<1, 1, 0> { |
2130 public: | 2128 public: |
2131 LSmiUntag(LOperand* value, bool needs_check) | 2129 LSmiUntag(LOperand* value, bool needs_check) |
2132 : needs_check_(needs_check) { | 2130 : needs_check_(needs_check) { |
2133 inputs_[0] = value; | 2131 inputs_[0] = value; |
2134 } | 2132 } |
2135 | 2133 |
2136 LOperand* value() { return inputs_[0]; } | 2134 LOperand* value() { return inputs_[0]; } |
2137 bool needs_check() const { return needs_check_; } | 2135 bool needs_check() const { return needs_check_; } |
2138 | 2136 |
2139 DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag") | 2137 DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag") |
2140 | 2138 |
2141 private: | 2139 private: |
2142 bool needs_check_; | 2140 bool needs_check_; |
2143 }; | 2141 }; |
2144 | 2142 |
2145 | 2143 |
2146 class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> { | 2144 class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> { |
2147 public: | 2145 public: |
2148 LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) { | 2146 LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) { |
2149 inputs_[0] = object; | 2147 inputs_[0] = object; |
2150 inputs_[1] = value; | 2148 inputs_[1] = value; |
2151 temps_[0] = temp; | 2149 temps_[0] = temp; |
2152 } | 2150 } |
2153 | 2151 |
2154 LOperand* object() { return inputs_[0]; } | 2152 LOperand* object() { return inputs_[0]; } |
2155 LOperand* value() { return inputs_[1]; } | 2153 LOperand* value() { return inputs_[1]; } |
2156 LOperand* temp() { return temps_[0]; } | 2154 LOperand* temp() { return temps_[0]; } |
2157 | 2155 |
2158 DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field") | 2156 DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field") |
2159 DECLARE_HYDROGEN_ACCESSOR(StoreNamedField) | 2157 DECLARE_HYDROGEN_ACCESSOR(StoreNamedField) |
2160 | 2158 |
2161 void PrintDataTo(StringStream* stream) OVERRIDE; | 2159 void PrintDataTo(StringStream* stream) override; |
2162 | 2160 |
2163 Representation representation() const { | 2161 Representation representation() const { |
2164 return hydrogen()->field_representation(); | 2162 return hydrogen()->field_representation(); |
2165 } | 2163 } |
2166 }; | 2164 }; |
2167 | 2165 |
2168 | 2166 |
2169 class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> { | 2167 class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> { |
2170 public: | 2168 public: |
2171 LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) { | 2169 LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) { |
2172 inputs_[0] = context; | 2170 inputs_[0] = context; |
2173 inputs_[1] = object; | 2171 inputs_[1] = object; |
2174 inputs_[2] = value; | 2172 inputs_[2] = value; |
2175 } | 2173 } |
2176 | 2174 |
2177 LOperand* context() { return inputs_[0]; } | 2175 LOperand* context() { return inputs_[0]; } |
2178 LOperand* object() { return inputs_[1]; } | 2176 LOperand* object() { return inputs_[1]; } |
2179 LOperand* value() { return inputs_[2]; } | 2177 LOperand* value() { return inputs_[2]; } |
2180 | 2178 |
2181 DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic") | 2179 DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic") |
2182 DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric) | 2180 DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric) |
2183 | 2181 |
2184 void PrintDataTo(StringStream* stream) OVERRIDE; | 2182 void PrintDataTo(StringStream* stream) override; |
2185 | 2183 |
2186 Handle<Object> name() const { return hydrogen()->name(); } | 2184 Handle<Object> name() const { return hydrogen()->name(); } |
2187 LanguageMode language_mode() { return hydrogen()->language_mode(); } | 2185 LanguageMode language_mode() { return hydrogen()->language_mode(); } |
2188 }; | 2186 }; |
2189 | 2187 |
2190 | 2188 |
2191 class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> { | 2189 class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> { |
2192 public: | 2190 public: |
2193 LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) { | 2191 LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) { |
2194 inputs_[0] = object; | 2192 inputs_[0] = object; |
2195 inputs_[1] = key; | 2193 inputs_[1] = key; |
2196 inputs_[2] = value; | 2194 inputs_[2] = value; |
2197 } | 2195 } |
2198 | 2196 |
2199 bool is_external() const { return hydrogen()->is_external(); } | 2197 bool is_external() const { return hydrogen()->is_external(); } |
2200 bool is_fixed_typed_array() const { | 2198 bool is_fixed_typed_array() const { |
2201 return hydrogen()->is_fixed_typed_array(); | 2199 return hydrogen()->is_fixed_typed_array(); |
2202 } | 2200 } |
2203 bool is_typed_elements() const { | 2201 bool is_typed_elements() const { |
2204 return is_external() || is_fixed_typed_array(); | 2202 return is_external() || is_fixed_typed_array(); |
2205 } | 2203 } |
2206 LOperand* elements() { return inputs_[0]; } | 2204 LOperand* elements() { return inputs_[0]; } |
2207 LOperand* key() { return inputs_[1]; } | 2205 LOperand* key() { return inputs_[1]; } |
2208 LOperand* value() { return inputs_[2]; } | 2206 LOperand* value() { return inputs_[2]; } |
2209 ElementsKind elements_kind() const { return hydrogen()->elements_kind(); } | 2207 ElementsKind elements_kind() const { return hydrogen()->elements_kind(); } |
2210 | 2208 |
2211 DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed") | 2209 DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed") |
2212 DECLARE_HYDROGEN_ACCESSOR(StoreKeyed) | 2210 DECLARE_HYDROGEN_ACCESSOR(StoreKeyed) |
2213 | 2211 |
2214 void PrintDataTo(StringStream* stream) OVERRIDE; | 2212 void PrintDataTo(StringStream* stream) override; |
2215 bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); } | 2213 bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); } |
2216 uint32_t base_offset() const { return hydrogen()->base_offset(); } | 2214 uint32_t base_offset() const { return hydrogen()->base_offset(); } |
2217 }; | 2215 }; |
2218 | 2216 |
2219 | 2217 |
2220 class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> { | 2218 class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> { |
2221 public: | 2219 public: |
2222 LStoreKeyedGeneric(LOperand* context, | 2220 LStoreKeyedGeneric(LOperand* context, |
2223 LOperand* object, | 2221 LOperand* object, |
2224 LOperand* key, | 2222 LOperand* key, |
2225 LOperand* value) { | 2223 LOperand* value) { |
2226 inputs_[0] = context; | 2224 inputs_[0] = context; |
2227 inputs_[1] = object; | 2225 inputs_[1] = object; |
2228 inputs_[2] = key; | 2226 inputs_[2] = key; |
2229 inputs_[3] = value; | 2227 inputs_[3] = value; |
2230 } | 2228 } |
2231 | 2229 |
2232 LOperand* context() { return inputs_[0]; } | 2230 LOperand* context() { return inputs_[0]; } |
2233 LOperand* object() { return inputs_[1]; } | 2231 LOperand* object() { return inputs_[1]; } |
2234 LOperand* key() { return inputs_[2]; } | 2232 LOperand* key() { return inputs_[2]; } |
2235 LOperand* value() { return inputs_[3]; } | 2233 LOperand* value() { return inputs_[3]; } |
2236 | 2234 |
2237 DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic") | 2235 DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic") |
2238 DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric) | 2236 DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric) |
2239 | 2237 |
2240 void PrintDataTo(StringStream* stream) OVERRIDE; | 2238 void PrintDataTo(StringStream* stream) override; |
2241 | 2239 |
2242 LanguageMode language_mode() { return hydrogen()->language_mode(); } | 2240 LanguageMode language_mode() { return hydrogen()->language_mode(); } |
2243 }; | 2241 }; |
2244 | 2242 |
2245 | 2243 |
2246 class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> { | 2244 class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> { |
2247 public: | 2245 public: |
2248 LTransitionElementsKind(LOperand* object, | 2246 LTransitionElementsKind(LOperand* object, |
2249 LOperand* context, | 2247 LOperand* context, |
2250 LOperand* new_map_temp, | 2248 LOperand* new_map_temp, |
2251 LOperand* temp) { | 2249 LOperand* temp) { |
2252 inputs_[0] = object; | 2250 inputs_[0] = object; |
2253 inputs_[1] = context; | 2251 inputs_[1] = context; |
2254 temps_[0] = new_map_temp; | 2252 temps_[0] = new_map_temp; |
2255 temps_[1] = temp; | 2253 temps_[1] = temp; |
2256 } | 2254 } |
2257 | 2255 |
2258 LOperand* object() { return inputs_[0]; } | 2256 LOperand* object() { return inputs_[0]; } |
2259 LOperand* context() { return inputs_[1]; } | 2257 LOperand* context() { return inputs_[1]; } |
2260 LOperand* new_map_temp() { return temps_[0]; } | 2258 LOperand* new_map_temp() { return temps_[0]; } |
2261 LOperand* temp() { return temps_[1]; } | 2259 LOperand* temp() { return temps_[1]; } |
2262 | 2260 |
2263 DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind, | 2261 DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind, |
2264 "transition-elements-kind") | 2262 "transition-elements-kind") |
2265 DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind) | 2263 DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind) |
2266 | 2264 |
2267 void PrintDataTo(StringStream* stream) OVERRIDE; | 2265 void PrintDataTo(StringStream* stream) override; |
2268 | 2266 |
2269 Handle<Map> original_map() { return hydrogen()->original_map().handle(); } | 2267 Handle<Map> original_map() { return hydrogen()->original_map().handle(); } |
2270 Handle<Map> transitioned_map() { | 2268 Handle<Map> transitioned_map() { |
2271 return hydrogen()->transitioned_map().handle(); | 2269 return hydrogen()->transitioned_map().handle(); |
2272 } | 2270 } |
2273 ElementsKind from_kind() { return hydrogen()->from_kind(); } | 2271 ElementsKind from_kind() { return hydrogen()->from_kind(); } |
2274 ElementsKind to_kind() { return hydrogen()->to_kind(); } | 2272 ElementsKind to_kind() { return hydrogen()->to_kind(); } |
2275 }; | 2273 }; |
2276 | 2274 |
2277 | 2275 |
2278 class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> { | 2276 class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> { |
2279 public: | 2277 public: |
2280 LTrapAllocationMemento(LOperand* object, | 2278 LTrapAllocationMemento(LOperand* object, |
2281 LOperand* temp) { | 2279 LOperand* temp) { |
2282 inputs_[0] = object; | 2280 inputs_[0] = object; |
2283 temps_[0] = temp; | 2281 temps_[0] = temp; |
2284 } | 2282 } |
2285 | 2283 |
2286 LOperand* object() { return inputs_[0]; } | 2284 LOperand* object() { return inputs_[0]; } |
2287 LOperand* temp() { return temps_[0]; } | 2285 LOperand* temp() { return temps_[0]; } |
2288 | 2286 |
2289 DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento, | 2287 DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento, |
2290 "trap-allocation-memento") | 2288 "trap-allocation-memento") |
2291 }; | 2289 }; |
2292 | 2290 |
2293 | 2291 |
2294 class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> { | 2292 class LStringAdd final : public LTemplateInstruction<1, 3, 0> { |
2295 public: | 2293 public: |
2296 LStringAdd(LOperand* context, LOperand* left, LOperand* right) { | 2294 LStringAdd(LOperand* context, LOperand* left, LOperand* right) { |
2297 inputs_[0] = context; | 2295 inputs_[0] = context; |
2298 inputs_[1] = left; | 2296 inputs_[1] = left; |
2299 inputs_[2] = right; | 2297 inputs_[2] = right; |
2300 } | 2298 } |
2301 | 2299 |
2302 LOperand* context() { return inputs_[0]; } | 2300 LOperand* context() { return inputs_[0]; } |
2303 LOperand* left() { return inputs_[1]; } | 2301 LOperand* left() { return inputs_[1]; } |
2304 LOperand* right() { return inputs_[2]; } | 2302 LOperand* right() { return inputs_[2]; } |
2305 | 2303 |
2306 DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add") | 2304 DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add") |
2307 DECLARE_HYDROGEN_ACCESSOR(StringAdd) | 2305 DECLARE_HYDROGEN_ACCESSOR(StringAdd) |
2308 }; | 2306 }; |
2309 | 2307 |
2310 | 2308 |
2311 class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> { | 2309 class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> { |
2312 public: | 2310 public: |
2313 LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) { | 2311 LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) { |
2314 inputs_[0] = context; | 2312 inputs_[0] = context; |
2315 inputs_[1] = string; | 2313 inputs_[1] = string; |
2316 inputs_[2] = index; | 2314 inputs_[2] = index; |
2317 } | 2315 } |
2318 | 2316 |
2319 LOperand* context() { return inputs_[0]; } | 2317 LOperand* context() { return inputs_[0]; } |
2320 LOperand* string() { return inputs_[1]; } | 2318 LOperand* string() { return inputs_[1]; } |
2321 LOperand* index() { return inputs_[2]; } | 2319 LOperand* index() { return inputs_[2]; } |
2322 | 2320 |
2323 DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at") | 2321 DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at") |
2324 DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt) | 2322 DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt) |
2325 }; | 2323 }; |
2326 | 2324 |
2327 | 2325 |
2328 class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> { | 2326 class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> { |
2329 public: | 2327 public: |
2330 explicit LStringCharFromCode(LOperand* context, LOperand* char_code) { | 2328 explicit LStringCharFromCode(LOperand* context, LOperand* char_code) { |
2331 inputs_[0] = context; | 2329 inputs_[0] = context; |
2332 inputs_[1] = char_code; | 2330 inputs_[1] = char_code; |
2333 } | 2331 } |
2334 | 2332 |
2335 LOperand* context() { return inputs_[0]; } | 2333 LOperand* context() { return inputs_[0]; } |
2336 LOperand* char_code() { return inputs_[1]; } | 2334 LOperand* char_code() { return inputs_[1]; } |
2337 | 2335 |
2338 DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code") | 2336 DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code") |
2339 DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode) | 2337 DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode) |
2340 }; | 2338 }; |
2341 | 2339 |
2342 | 2340 |
2343 class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> { | 2341 class LCheckValue final : public LTemplateInstruction<0, 1, 0> { |
2344 public: | 2342 public: |
2345 explicit LCheckValue(LOperand* value) { | 2343 explicit LCheckValue(LOperand* value) { |
2346 inputs_[0] = value; | 2344 inputs_[0] = value; |
2347 } | 2345 } |
2348 | 2346 |
2349 LOperand* value() { return inputs_[0]; } | 2347 LOperand* value() { return inputs_[0]; } |
2350 | 2348 |
2351 DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value") | 2349 DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value") |
2352 DECLARE_HYDROGEN_ACCESSOR(CheckValue) | 2350 DECLARE_HYDROGEN_ACCESSOR(CheckValue) |
2353 }; | 2351 }; |
2354 | 2352 |
2355 | 2353 |
2356 class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> { | 2354 class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> { |
2357 public: | 2355 public: |
2358 explicit LCheckInstanceType(LOperand* value) { | 2356 explicit LCheckInstanceType(LOperand* value) { |
2359 inputs_[0] = value; | 2357 inputs_[0] = value; |
2360 } | 2358 } |
2361 | 2359 |
2362 LOperand* value() { return inputs_[0]; } | 2360 LOperand* value() { return inputs_[0]; } |
2363 | 2361 |
2364 DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type") | 2362 DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type") |
2365 DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType) | 2363 DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType) |
2366 }; | 2364 }; |
2367 | 2365 |
2368 | 2366 |
2369 class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> { | 2367 class LCheckMaps final : public LTemplateInstruction<0, 1, 0> { |
2370 public: | 2368 public: |
2371 explicit LCheckMaps(LOperand* value = NULL) { | 2369 explicit LCheckMaps(LOperand* value = NULL) { |
2372 inputs_[0] = value; | 2370 inputs_[0] = value; |
2373 } | 2371 } |
2374 | 2372 |
2375 LOperand* value() { return inputs_[0]; } | 2373 LOperand* value() { return inputs_[0]; } |
2376 | 2374 |
2377 DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps") | 2375 DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps") |
2378 DECLARE_HYDROGEN_ACCESSOR(CheckMaps) | 2376 DECLARE_HYDROGEN_ACCESSOR(CheckMaps) |
2379 }; | 2377 }; |
2380 | 2378 |
2381 | 2379 |
2382 class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> { | 2380 class LCheckSmi final : public LTemplateInstruction<1, 1, 0> { |
2383 public: | 2381 public: |
2384 explicit LCheckSmi(LOperand* value) { | 2382 explicit LCheckSmi(LOperand* value) { |
2385 inputs_[0] = value; | 2383 inputs_[0] = value; |
2386 } | 2384 } |
2387 | 2385 |
2388 LOperand* value() { return inputs_[0]; } | 2386 LOperand* value() { return inputs_[0]; } |
2389 | 2387 |
2390 DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi") | 2388 DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi") |
2391 }; | 2389 }; |
2392 | 2390 |
2393 | 2391 |
2394 class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> { | 2392 class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> { |
2395 public: | 2393 public: |
2396 explicit LClampDToUint8(LOperand* unclamped) { | 2394 explicit LClampDToUint8(LOperand* unclamped) { |
2397 inputs_[0] = unclamped; | 2395 inputs_[0] = unclamped; |
2398 } | 2396 } |
2399 | 2397 |
2400 LOperand* unclamped() { return inputs_[0]; } | 2398 LOperand* unclamped() { return inputs_[0]; } |
2401 | 2399 |
2402 DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8") | 2400 DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8") |
2403 }; | 2401 }; |
2404 | 2402 |
2405 | 2403 |
2406 class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> { | 2404 class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> { |
2407 public: | 2405 public: |
2408 explicit LClampIToUint8(LOperand* unclamped) { | 2406 explicit LClampIToUint8(LOperand* unclamped) { |
2409 inputs_[0] = unclamped; | 2407 inputs_[0] = unclamped; |
2410 } | 2408 } |
2411 | 2409 |
2412 LOperand* unclamped() { return inputs_[0]; } | 2410 LOperand* unclamped() { return inputs_[0]; } |
2413 | 2411 |
2414 DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8") | 2412 DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8") |
2415 }; | 2413 }; |
2416 | 2414 |
2417 | 2415 |
2418 class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> { | 2416 class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> { |
2419 public: | 2417 public: |
2420 LClampTToUint8(LOperand* unclamped, | 2418 LClampTToUint8(LOperand* unclamped, |
2421 LOperand* temp_xmm) { | 2419 LOperand* temp_xmm) { |
2422 inputs_[0] = unclamped; | 2420 inputs_[0] = unclamped; |
2423 temps_[0] = temp_xmm; | 2421 temps_[0] = temp_xmm; |
2424 } | 2422 } |
2425 | 2423 |
2426 LOperand* unclamped() { return inputs_[0]; } | 2424 LOperand* unclamped() { return inputs_[0]; } |
2427 LOperand* temp_xmm() { return temps_[0]; } | 2425 LOperand* temp_xmm() { return temps_[0]; } |
2428 | 2426 |
2429 DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") | 2427 DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") |
2430 }; | 2428 }; |
2431 | 2429 |
2432 | 2430 |
2433 class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> { | 2431 class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> { |
2434 public: | 2432 public: |
2435 explicit LCheckNonSmi(LOperand* value) { | 2433 explicit LCheckNonSmi(LOperand* value) { |
2436 inputs_[0] = value; | 2434 inputs_[0] = value; |
2437 } | 2435 } |
2438 | 2436 |
2439 LOperand* value() { return inputs_[0]; } | 2437 LOperand* value() { return inputs_[0]; } |
2440 | 2438 |
2441 DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") | 2439 DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") |
2442 DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject) | 2440 DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject) |
2443 }; | 2441 }; |
2444 | 2442 |
2445 | 2443 |
2446 class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> { | 2444 class LDoubleBits final : public LTemplateInstruction<1, 1, 0> { |
2447 public: | 2445 public: |
2448 explicit LDoubleBits(LOperand* value) { | 2446 explicit LDoubleBits(LOperand* value) { |
2449 inputs_[0] = value; | 2447 inputs_[0] = value; |
2450 } | 2448 } |
2451 | 2449 |
2452 LOperand* value() { return inputs_[0]; } | 2450 LOperand* value() { return inputs_[0]; } |
2453 | 2451 |
2454 DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits") | 2452 DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits") |
2455 DECLARE_HYDROGEN_ACCESSOR(DoubleBits) | 2453 DECLARE_HYDROGEN_ACCESSOR(DoubleBits) |
2456 }; | 2454 }; |
2457 | 2455 |
2458 | 2456 |
2459 class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> { | 2457 class LConstructDouble final : public LTemplateInstruction<1, 2, 0> { |
2460 public: | 2458 public: |
2461 LConstructDouble(LOperand* hi, LOperand* lo) { | 2459 LConstructDouble(LOperand* hi, LOperand* lo) { |
2462 inputs_[0] = hi; | 2460 inputs_[0] = hi; |
2463 inputs_[1] = lo; | 2461 inputs_[1] = lo; |
2464 } | 2462 } |
2465 | 2463 |
2466 LOperand* hi() { return inputs_[0]; } | 2464 LOperand* hi() { return inputs_[0]; } |
2467 LOperand* lo() { return inputs_[1]; } | 2465 LOperand* lo() { return inputs_[1]; } |
2468 | 2466 |
2469 DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double") | 2467 DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double") |
2470 }; | 2468 }; |
2471 | 2469 |
2472 | 2470 |
2473 class LAllocate FINAL : public LTemplateInstruction<1, 2, 1> { | 2471 class LAllocate final : public LTemplateInstruction<1, 2, 1> { |
2474 public: | 2472 public: |
2475 LAllocate(LOperand* context, LOperand* size, LOperand* temp) { | 2473 LAllocate(LOperand* context, LOperand* size, LOperand* temp) { |
2476 inputs_[0] = context; | 2474 inputs_[0] = context; |
2477 inputs_[1] = size; | 2475 inputs_[1] = size; |
2478 temps_[0] = temp; | 2476 temps_[0] = temp; |
2479 } | 2477 } |
2480 | 2478 |
2481 LOperand* context() { return inputs_[0]; } | 2479 LOperand* context() { return inputs_[0]; } |
2482 LOperand* size() { return inputs_[1]; } | 2480 LOperand* size() { return inputs_[1]; } |
2483 LOperand* temp() { return temps_[0]; } | 2481 LOperand* temp() { return temps_[0]; } |
2484 | 2482 |
2485 DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate") | 2483 DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate") |
2486 DECLARE_HYDROGEN_ACCESSOR(Allocate) | 2484 DECLARE_HYDROGEN_ACCESSOR(Allocate) |
2487 }; | 2485 }; |
2488 | 2486 |
2489 | 2487 |
2490 class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> { | 2488 class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> { |
2491 public: | 2489 public: |
2492 explicit LRegExpLiteral(LOperand* context) { | 2490 explicit LRegExpLiteral(LOperand* context) { |
2493 inputs_[0] = context; | 2491 inputs_[0] = context; |
2494 } | 2492 } |
2495 | 2493 |
2496 LOperand* context() { return inputs_[0]; } | 2494 LOperand* context() { return inputs_[0]; } |
2497 | 2495 |
2498 DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal") | 2496 DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal") |
2499 DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral) | 2497 DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral) |
2500 }; | 2498 }; |
2501 | 2499 |
2502 | 2500 |
2503 class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> { | 2501 class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> { |
2504 public: | 2502 public: |
2505 explicit LFunctionLiteral(LOperand* context) { | 2503 explicit LFunctionLiteral(LOperand* context) { |
2506 inputs_[0] = context; | 2504 inputs_[0] = context; |
2507 } | 2505 } |
2508 | 2506 |
2509 LOperand* context() { return inputs_[0]; } | 2507 LOperand* context() { return inputs_[0]; } |
2510 | 2508 |
2511 DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal") | 2509 DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal") |
2512 DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral) | 2510 DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral) |
2513 }; | 2511 }; |
2514 | 2512 |
2515 | 2513 |
2516 class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> { | 2514 class LToFastProperties final : public LTemplateInstruction<1, 1, 0> { |
2517 public: | 2515 public: |
2518 explicit LToFastProperties(LOperand* value) { | 2516 explicit LToFastProperties(LOperand* value) { |
2519 inputs_[0] = value; | 2517 inputs_[0] = value; |
2520 } | 2518 } |
2521 | 2519 |
2522 LOperand* value() { return inputs_[0]; } | 2520 LOperand* value() { return inputs_[0]; } |
2523 | 2521 |
2524 DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties") | 2522 DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties") |
2525 DECLARE_HYDROGEN_ACCESSOR(ToFastProperties) | 2523 DECLARE_HYDROGEN_ACCESSOR(ToFastProperties) |
2526 }; | 2524 }; |
2527 | 2525 |
2528 | 2526 |
2529 class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> { | 2527 class LTypeof final : public LTemplateInstruction<1, 2, 0> { |
2530 public: | 2528 public: |
2531 LTypeof(LOperand* context, LOperand* value) { | 2529 LTypeof(LOperand* context, LOperand* value) { |
2532 inputs_[0] = context; | 2530 inputs_[0] = context; |
2533 inputs_[1] = value; | 2531 inputs_[1] = value; |
2534 } | 2532 } |
2535 | 2533 |
2536 LOperand* context() { return inputs_[0]; } | 2534 LOperand* context() { return inputs_[0]; } |
2537 LOperand* value() { return inputs_[1]; } | 2535 LOperand* value() { return inputs_[1]; } |
2538 | 2536 |
2539 DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof") | 2537 DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof") |
2540 }; | 2538 }; |
2541 | 2539 |
2542 | 2540 |
2543 class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> { | 2541 class LTypeofIsAndBranch final : public LControlInstruction<1, 0> { |
2544 public: | 2542 public: |
2545 explicit LTypeofIsAndBranch(LOperand* value) { | 2543 explicit LTypeofIsAndBranch(LOperand* value) { |
2546 inputs_[0] = value; | 2544 inputs_[0] = value; |
2547 } | 2545 } |
2548 | 2546 |
2549 LOperand* value() { return inputs_[0]; } | 2547 LOperand* value() { return inputs_[0]; } |
2550 | 2548 |
2551 DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch") | 2549 DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch") |
2552 DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch) | 2550 DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch) |
2553 | 2551 |
2554 Handle<String> type_literal() { return hydrogen()->type_literal(); } | 2552 Handle<String> type_literal() { return hydrogen()->type_literal(); } |
2555 | 2553 |
2556 void PrintDataTo(StringStream* stream) OVERRIDE; | 2554 void PrintDataTo(StringStream* stream) override; |
2557 }; | 2555 }; |
2558 | 2556 |
2559 | 2557 |
2560 class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> { | 2558 class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> { |
2561 public: | 2559 public: |
2562 explicit LIsConstructCallAndBranch(LOperand* temp) { | 2560 explicit LIsConstructCallAndBranch(LOperand* temp) { |
2563 temps_[0] = temp; | 2561 temps_[0] = temp; |
2564 } | 2562 } |
2565 | 2563 |
2566 LOperand* temp() { return temps_[0]; } | 2564 LOperand* temp() { return temps_[0]; } |
2567 | 2565 |
2568 DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch, | 2566 DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch, |
2569 "is-construct-call-and-branch") | 2567 "is-construct-call-and-branch") |
2570 DECLARE_HYDROGEN_ACCESSOR(IsConstructCallAndBranch) | 2568 DECLARE_HYDROGEN_ACCESSOR(IsConstructCallAndBranch) |
2571 }; | 2569 }; |
2572 | 2570 |
2573 | 2571 |
2574 class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> { | 2572 class LOsrEntry final : public LTemplateInstruction<0, 0, 0> { |
2575 public: | 2573 public: |
2576 LOsrEntry() {} | 2574 LOsrEntry() {} |
2577 | 2575 |
2578 bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; } | 2576 bool HasInterestingComment(LCodeGen* gen) const override { return false; } |
2579 DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry") | 2577 DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry") |
2580 }; | 2578 }; |
2581 | 2579 |
2582 | 2580 |
2583 class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> { | 2581 class LStackCheck final : public LTemplateInstruction<0, 1, 0> { |
2584 public: | 2582 public: |
2585 explicit LStackCheck(LOperand* context) { | 2583 explicit LStackCheck(LOperand* context) { |
2586 inputs_[0] = context; | 2584 inputs_[0] = context; |
2587 } | 2585 } |
2588 | 2586 |
2589 LOperand* context() { return inputs_[0]; } | 2587 LOperand* context() { return inputs_[0]; } |
2590 | 2588 |
2591 DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check") | 2589 DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check") |
2592 DECLARE_HYDROGEN_ACCESSOR(StackCheck) | 2590 DECLARE_HYDROGEN_ACCESSOR(StackCheck) |
2593 | 2591 |
2594 Label* done_label() { return &done_label_; } | 2592 Label* done_label() { return &done_label_; } |
2595 | 2593 |
2596 private: | 2594 private: |
2597 Label done_label_; | 2595 Label done_label_; |
2598 }; | 2596 }; |
2599 | 2597 |
2600 | 2598 |
2601 class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> { | 2599 class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> { |
2602 public: | 2600 public: |
2603 LForInPrepareMap(LOperand* context, LOperand* object) { | 2601 LForInPrepareMap(LOperand* context, LOperand* object) { |
2604 inputs_[0] = context; | 2602 inputs_[0] = context; |
2605 inputs_[1] = object; | 2603 inputs_[1] = object; |
2606 } | 2604 } |
2607 | 2605 |
2608 LOperand* context() { return inputs_[0]; } | 2606 LOperand* context() { return inputs_[0]; } |
2609 LOperand* object() { return inputs_[1]; } | 2607 LOperand* object() { return inputs_[1]; } |
2610 | 2608 |
2611 DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map") | 2609 DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map") |
2612 }; | 2610 }; |
2613 | 2611 |
2614 | 2612 |
2615 class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> { | 2613 class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> { |
2616 public: | 2614 public: |
2617 explicit LForInCacheArray(LOperand* map) { | 2615 explicit LForInCacheArray(LOperand* map) { |
2618 inputs_[0] = map; | 2616 inputs_[0] = map; |
2619 } | 2617 } |
2620 | 2618 |
2621 LOperand* map() { return inputs_[0]; } | 2619 LOperand* map() { return inputs_[0]; } |
2622 | 2620 |
2623 DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array") | 2621 DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array") |
2624 | 2622 |
2625 int idx() { | 2623 int idx() { |
2626 return HForInCacheArray::cast(this->hydrogen_value())->idx(); | 2624 return HForInCacheArray::cast(this->hydrogen_value())->idx(); |
2627 } | 2625 } |
2628 }; | 2626 }; |
2629 | 2627 |
2630 | 2628 |
2631 class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> { | 2629 class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> { |
2632 public: | 2630 public: |
2633 LCheckMapValue(LOperand* value, LOperand* map) { | 2631 LCheckMapValue(LOperand* value, LOperand* map) { |
2634 inputs_[0] = value; | 2632 inputs_[0] = value; |
2635 inputs_[1] = map; | 2633 inputs_[1] = map; |
2636 } | 2634 } |
2637 | 2635 |
2638 LOperand* value() { return inputs_[0]; } | 2636 LOperand* value() { return inputs_[0]; } |
2639 LOperand* map() { return inputs_[1]; } | 2637 LOperand* map() { return inputs_[1]; } |
2640 | 2638 |
2641 DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value") | 2639 DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value") |
2642 }; | 2640 }; |
2643 | 2641 |
2644 | 2642 |
2645 class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> { | 2643 class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> { |
2646 public: | 2644 public: |
2647 LLoadFieldByIndex(LOperand* object, LOperand* index) { | 2645 LLoadFieldByIndex(LOperand* object, LOperand* index) { |
2648 inputs_[0] = object; | 2646 inputs_[0] = object; |
2649 inputs_[1] = index; | 2647 inputs_[1] = index; |
2650 } | 2648 } |
2651 | 2649 |
2652 LOperand* object() { return inputs_[0]; } | 2650 LOperand* object() { return inputs_[0]; } |
2653 LOperand* index() { return inputs_[1]; } | 2651 LOperand* index() { return inputs_[1]; } |
2654 | 2652 |
2655 DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index") | 2653 DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index") |
(...skipping 23 matching lines...) Expand all Loading... |
2679 LOperand* function() { return inputs_[1]; } | 2677 LOperand* function() { return inputs_[1]; } |
2680 | 2678 |
2681 Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); } | 2679 Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); } |
2682 | 2680 |
2683 DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context") | 2681 DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context") |
2684 DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext) | 2682 DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext) |
2685 }; | 2683 }; |
2686 | 2684 |
2687 | 2685 |
2688 class LChunkBuilder; | 2686 class LChunkBuilder; |
2689 class LPlatformChunk FINAL : public LChunk { | 2687 class LPlatformChunk final : public LChunk { |
2690 public: | 2688 public: |
2691 LPlatformChunk(CompilationInfo* info, HGraph* graph) | 2689 LPlatformChunk(CompilationInfo* info, HGraph* graph) |
2692 : LChunk(info, graph), | 2690 : LChunk(info, graph), |
2693 dehoisted_key_ids_(graph->GetMaximumValueID(), graph->zone()) { } | 2691 dehoisted_key_ids_(graph->GetMaximumValueID(), graph->zone()) { } |
2694 | 2692 |
2695 int GetNextSpillIndex(RegisterKind kind); | 2693 int GetNextSpillIndex(RegisterKind kind); |
2696 LOperand* GetNextSpillSlot(RegisterKind kind); | 2694 LOperand* GetNextSpillSlot(RegisterKind kind); |
2697 BitVector* GetDehoistedKeyIds() { return &dehoisted_key_ids_; } | 2695 BitVector* GetDehoistedKeyIds() { return &dehoisted_key_ids_; } |
2698 bool IsDehoistedKey(HValue* value) { | 2696 bool IsDehoistedKey(HValue* value) { |
2699 return dehoisted_key_ids_.Contains(value->id()); | 2697 return dehoisted_key_ids_.Contains(value->id()); |
2700 } | 2698 } |
2701 | 2699 |
2702 private: | 2700 private: |
2703 BitVector dehoisted_key_ids_; | 2701 BitVector dehoisted_key_ids_; |
2704 }; | 2702 }; |
2705 | 2703 |
2706 | 2704 |
2707 class LChunkBuilder FINAL : public LChunkBuilderBase { | 2705 class LChunkBuilder final : public LChunkBuilderBase { |
2708 public: | 2706 public: |
2709 LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator) | 2707 LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator) |
2710 : LChunkBuilderBase(info, graph), | 2708 : LChunkBuilderBase(info, graph), |
2711 current_instruction_(NULL), | 2709 current_instruction_(NULL), |
2712 current_block_(NULL), | 2710 current_block_(NULL), |
2713 next_block_(NULL), | 2711 next_block_(NULL), |
2714 allocator_(allocator) {} | 2712 allocator_(allocator) {} |
2715 | 2713 |
2716 // Build the sequence for the graph. | 2714 // Build the sequence for the graph. |
2717 LPlatformChunk* Build(); | 2715 LPlatformChunk* Build(); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2778 | 2776 |
2779 // An input operand in a register or a constant operand. | 2777 // An input operand in a register or a constant operand. |
2780 MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value); | 2778 MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value); |
2781 MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value); | 2779 MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value); |
2782 | 2780 |
2783 // An input operand in a constant operand. | 2781 // An input operand in a constant operand. |
2784 MUST_USE_RESULT LOperand* UseConstant(HValue* value); | 2782 MUST_USE_RESULT LOperand* UseConstant(HValue* value); |
2785 | 2783 |
2786 // An input operand in register, stack slot or a constant operand. | 2784 // An input operand in register, stack slot or a constant operand. |
2787 // Will not be moved to a register even if one is freely available. | 2785 // Will not be moved to a register even if one is freely available. |
2788 MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE; | 2786 MUST_USE_RESULT LOperand* UseAny(HValue* value) override; |
2789 | 2787 |
2790 // Temporary operand that must be in a register. | 2788 // Temporary operand that must be in a register. |
2791 MUST_USE_RESULT LUnallocated* TempRegister(); | 2789 MUST_USE_RESULT LUnallocated* TempRegister(); |
2792 MUST_USE_RESULT LOperand* FixedTemp(Register reg); | 2790 MUST_USE_RESULT LOperand* FixedTemp(Register reg); |
2793 MUST_USE_RESULT LOperand* FixedTemp(XMMRegister reg); | 2791 MUST_USE_RESULT LOperand* FixedTemp(XMMRegister reg); |
2794 | 2792 |
2795 // Methods for setting up define-use relationships. | 2793 // Methods for setting up define-use relationships. |
2796 // Return the same instruction that they are passed. | 2794 // Return the same instruction that they are passed. |
2797 LInstruction* Define(LTemplateResultInstruction<1>* instr, | 2795 LInstruction* Define(LTemplateResultInstruction<1>* instr, |
2798 LUnallocated* result); | 2796 LUnallocated* result); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2839 | 2837 |
2840 DISALLOW_COPY_AND_ASSIGN(LChunkBuilder); | 2838 DISALLOW_COPY_AND_ASSIGN(LChunkBuilder); |
2841 }; | 2839 }; |
2842 | 2840 |
2843 #undef DECLARE_HYDROGEN_ACCESSOR | 2841 #undef DECLARE_HYDROGEN_ACCESSOR |
2844 #undef DECLARE_CONCRETE_INSTRUCTION | 2842 #undef DECLARE_CONCRETE_INSTRUCTION |
2845 | 2843 |
2846 } } // namespace v8::int | 2844 } } // namespace v8::int |
2847 | 2845 |
2848 #endif // V8_X64_LITHIUM_X64_H_ | 2846 #endif // V8_X64_LITHIUM_X64_H_ |
OLD | NEW |