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