OLD | NEW |
1 // Copyright 2010 the V8 project authors. All rights reserved. | 1 // Copyright 2010 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 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 class LArgument; | 48 class LArgument; |
49 class LChunk; | 49 class LChunk; |
50 class LConstantOperand; | 50 class LConstantOperand; |
51 class LGap; | 51 class LGap; |
52 class LInstruction; | 52 class LInstruction; |
53 class LParallelMove; | 53 class LParallelMove; |
54 class LPointerMap; | 54 class LPointerMap; |
55 class LStackSlot; | 55 class LStackSlot; |
56 class LRegister; | 56 class LRegister; |
57 | 57 |
| 58 |
58 // This class represents a single point of a LOperand's lifetime. | 59 // This class represents a single point of a LOperand's lifetime. |
59 // For each lithium instruction there are exactly two lifetime positions: | 60 // For each lithium instruction there are exactly two lifetime positions: |
60 // the beginning and the end of the instruction. Lifetime positions for | 61 // the beginning and the end of the instruction. Lifetime positions for |
61 // different lithium instructions are disjoint. | 62 // different lithium instructions are disjoint. |
62 class LifetimePosition { | 63 class LifetimePosition { |
63 public: | 64 public: |
64 // Return the lifetime position that corresponds to the beginning of | 65 // Return the lifetime position that corresponds to the beginning of |
65 // the instruction with the given index. | 66 // the instruction with the given index. |
66 static LifetimePosition FromInstructionIndex(int index) { | 67 static LifetimePosition FromInstructionIndex(int index) { |
67 return LifetimePosition(index * kStep); | 68 return LifetimePosition(index * kStep); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
114 } | 115 } |
115 | 116 |
116 // Constructs the lifetime position which does not correspond to any | 117 // Constructs the lifetime position which does not correspond to any |
117 // instruction. | 118 // instruction. |
118 LifetimePosition() : value_(-1) {} | 119 LifetimePosition() : value_(-1) {} |
119 | 120 |
120 // Returns true if this lifetime positions corrensponds to some | 121 // Returns true if this lifetime positions corrensponds to some |
121 // instruction. | 122 // instruction. |
122 bool IsValid() const { return value_ != -1; } | 123 bool IsValid() const { return value_ != -1; } |
123 | 124 |
124 static LifetimePosition Invalid() { return LifetimePosition(); } | 125 static inline LifetimePosition Invalid() { return LifetimePosition(); } |
| 126 |
| 127 static inline LifetimePosition MaxPosition() { |
| 128 // We have to use this kind of getter instead of static member due to |
| 129 // crash bug in GDB. |
| 130 return LifetimePosition(kMaxInt); |
| 131 } |
125 | 132 |
126 private: | 133 private: |
127 static const int kStep = 2; | 134 static const int kStep = 2; |
128 | 135 |
129 // Code relies on kStep being a power of two. | 136 // Code relies on kStep being a power of two. |
130 STATIC_ASSERT(IS_POWER_OF_TWO(kStep)); | 137 STATIC_ASSERT(IS_POWER_OF_TWO(kStep)); |
131 | 138 |
132 explicit LifetimePosition(int value) : value_(value) { } | 139 explicit LifetimePosition(int value) : value_(value) { } |
133 | 140 |
134 int value_; | 141 int value_; |
135 }; | 142 }; |
136 | 143 |
137 | 144 |
| 145 enum RegisterKind { |
| 146 NONE, |
| 147 GENERAL_REGISTERS, |
| 148 DOUBLE_REGISTERS |
| 149 }; |
| 150 |
| 151 |
138 class LOperand: public ZoneObject { | 152 class LOperand: public ZoneObject { |
139 public: | 153 public: |
140 enum Kind { | 154 enum Kind { |
141 INVALID, | 155 INVALID, |
142 UNALLOCATED, | 156 UNALLOCATED, |
143 CONSTANT_OPERAND, | 157 CONSTANT_OPERAND, |
144 STACK_SLOT, | 158 STACK_SLOT, |
145 DOUBLE_STACK_SLOT, | 159 DOUBLE_STACK_SLOT, |
146 REGISTER, | 160 REGISTER, |
147 DOUBLE_REGISTER, | 161 DOUBLE_REGISTER, |
(...skipping 439 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
587 | 601 |
588 // Representation of SSA values' live ranges as a collection of (continuous) | 602 // Representation of SSA values' live ranges as a collection of (continuous) |
589 // intervals over the instruction ordering. | 603 // intervals over the instruction ordering. |
590 class LiveRange: public ZoneObject { | 604 class LiveRange: public ZoneObject { |
591 public: | 605 public: |
592 static const int kInvalidAssignment = 0x7fffffff; | 606 static const int kInvalidAssignment = 0x7fffffff; |
593 | 607 |
594 explicit LiveRange(int id) | 608 explicit LiveRange(int id) |
595 : id_(id), | 609 : id_(id), |
596 spilled_(false), | 610 spilled_(false), |
597 assigned_double_(false), | |
598 assigned_register_(kInvalidAssignment), | 611 assigned_register_(kInvalidAssignment), |
| 612 assigned_register_kind_(NONE), |
599 last_interval_(NULL), | 613 last_interval_(NULL), |
600 first_interval_(NULL), | 614 first_interval_(NULL), |
601 first_pos_(NULL), | 615 first_pos_(NULL), |
602 parent_(NULL), | 616 parent_(NULL), |
603 next_(NULL), | 617 next_(NULL), |
604 current_interval_(NULL), | 618 current_interval_(NULL), |
605 last_processed_use_(NULL), | 619 last_processed_use_(NULL), |
606 spill_start_index_(kMaxInt) { | 620 spill_start_index_(kMaxInt) { |
607 spill_operand_ = new LUnallocated(LUnallocated::IGNORE); | 621 spill_operand_ = new LUnallocated(LUnallocated::IGNORE); |
608 } | 622 } |
609 | 623 |
610 UseInterval* first_interval() const { return first_interval_; } | 624 UseInterval* first_interval() const { return first_interval_; } |
611 UsePosition* first_pos() const { return first_pos_; } | 625 UsePosition* first_pos() const { return first_pos_; } |
612 LiveRange* parent() const { return parent_; } | 626 LiveRange* parent() const { return parent_; } |
613 LiveRange* TopLevel() { return (parent_ == NULL) ? this : parent_; } | 627 LiveRange* TopLevel() { return (parent_ == NULL) ? this : parent_; } |
614 LiveRange* next() const { return next_; } | 628 LiveRange* next() const { return next_; } |
615 bool IsChild() const { return parent() != NULL; } | 629 bool IsChild() const { return parent() != NULL; } |
616 bool IsParent() const { return parent() == NULL; } | 630 bool IsParent() const { return parent() == NULL; } |
617 int id() const { return id_; } | 631 int id() const { return id_; } |
618 bool IsFixed() const { return id_ < 0; } | 632 bool IsFixed() const { return id_ < 0; } |
619 bool IsEmpty() const { return first_interval() == NULL; } | 633 bool IsEmpty() const { return first_interval() == NULL; } |
620 LOperand* CreateAssignedOperand(); | 634 LOperand* CreateAssignedOperand(); |
621 int assigned_register() const { return assigned_register_; } | 635 int assigned_register() const { return assigned_register_; } |
622 int spill_start_index() const { return spill_start_index_; } | 636 int spill_start_index() const { return spill_start_index_; } |
623 void set_assigned_register(int reg, bool double_reg) { | 637 void set_assigned_register(int reg, RegisterKind register_kind) { |
624 ASSERT(!HasRegisterAssigned() && !IsSpilled()); | 638 ASSERT(!HasRegisterAssigned() && !IsSpilled()); |
625 assigned_register_ = reg; | 639 assigned_register_ = reg; |
626 assigned_double_ = double_reg; | 640 assigned_register_kind_ = register_kind; |
627 ConvertOperands(); | 641 ConvertOperands(); |
628 } | 642 } |
629 void MakeSpilled() { | 643 void MakeSpilled() { |
630 ASSERT(!IsSpilled()); | 644 ASSERT(!IsSpilled()); |
631 ASSERT(TopLevel()->HasAllocatedSpillOperand()); | 645 ASSERT(TopLevel()->HasAllocatedSpillOperand()); |
632 spilled_ = true; | 646 spilled_ = true; |
633 assigned_register_ = kInvalidAssignment; | 647 assigned_register_ = kInvalidAssignment; |
634 ConvertOperands(); | 648 ConvertOperands(); |
635 } | 649 } |
636 | 650 |
637 // Returns use position in this live range that follows both start | 651 // Returns use position in this live range that follows both start |
638 // and last processed use position. | 652 // and last processed use position. |
639 // Modifies internal state of live range! | 653 // Modifies internal state of live range! |
640 UsePosition* NextUsePosition(LifetimePosition start); | 654 UsePosition* NextUsePosition(LifetimePosition start); |
641 | 655 |
642 // Returns use position for which register is required in this live | 656 // Returns use position for which register is required in this live |
643 // range and which follows both start and last processed use position | 657 // range and which follows both start and last processed use position |
644 // Modifies internal state of live range! | 658 // Modifies internal state of live range! |
645 UsePosition* NextRegisterPosition(LifetimePosition start); | 659 UsePosition* NextRegisterPosition(LifetimePosition start); |
646 | 660 |
647 // Returns use position for which register is beneficial in this live | 661 // Returns use position for which register is beneficial in this live |
648 // range and which follows both start and last processed use position | 662 // range and which follows both start and last processed use position |
649 // Modifies internal state of live range! | 663 // Modifies internal state of live range! |
650 UsePosition* NextUsePositionRegisterIsBeneficial(LifetimePosition start); | 664 UsePosition* NextUsePositionRegisterIsBeneficial(LifetimePosition start); |
651 | 665 |
652 // Can this live range be spilled at this position. | 666 // Can this live range be spilled at this position. |
653 bool CanBeSpilled(LifetimePosition pos); | 667 bool CanBeSpilled(LifetimePosition pos); |
654 | 668 |
| 669 // Split this live range at the given position which must follow the start of |
| 670 // the range. |
| 671 // All uses following the given position will be moved from this |
| 672 // live range to the result live range. |
655 void SplitAt(LifetimePosition position, LiveRange* result); | 673 void SplitAt(LifetimePosition position, LiveRange* result); |
656 | 674 |
657 bool IsDouble() const { return assigned_double_; } | 675 bool IsDouble() const { return assigned_register_kind_ == DOUBLE_REGISTERS; } |
658 bool HasRegisterAssigned() const { | 676 bool HasRegisterAssigned() const { |
659 return assigned_register_ != kInvalidAssignment; | 677 return assigned_register_ != kInvalidAssignment; |
660 } | 678 } |
661 bool IsSpilled() const { return spilled_; } | 679 bool IsSpilled() const { return spilled_; } |
662 UsePosition* FirstPosWithHint() const; | 680 UsePosition* FirstPosWithHint() const; |
663 | 681 |
664 LOperand* FirstHint() const { | 682 LOperand* FirstHint() const { |
665 UsePosition* pos = FirstPosWithHint(); | 683 UsePosition* pos = FirstPosWithHint(); |
666 if (pos != NULL) return pos->hint(); | 684 if (pos != NULL) return pos->hint(); |
667 return NULL; | 685 return NULL; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
714 #endif | 732 #endif |
715 | 733 |
716 private: | 734 private: |
717 void ConvertOperands(); | 735 void ConvertOperands(); |
718 UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const; | 736 UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const; |
719 void AdvanceLastProcessedMarker(UseInterval* to_start_of, | 737 void AdvanceLastProcessedMarker(UseInterval* to_start_of, |
720 LifetimePosition but_not_past) const; | 738 LifetimePosition but_not_past) const; |
721 | 739 |
722 int id_; | 740 int id_; |
723 bool spilled_; | 741 bool spilled_; |
724 bool assigned_double_; | |
725 int assigned_register_; | 742 int assigned_register_; |
| 743 RegisterKind assigned_register_kind_; |
726 UseInterval* last_interval_; | 744 UseInterval* last_interval_; |
727 UseInterval* first_interval_; | 745 UseInterval* first_interval_; |
728 UsePosition* first_pos_; | 746 UsePosition* first_pos_; |
729 LiveRange* parent_; | 747 LiveRange* parent_; |
730 LiveRange* next_; | 748 LiveRange* next_; |
731 // This is used as a cache, it doesn't affect correctness. | 749 // This is used as a cache, it doesn't affect correctness. |
732 mutable UseInterval* current_interval_; | 750 mutable UseInterval* current_interval_; |
733 UsePosition* last_processed_use_; | 751 UsePosition* last_processed_use_; |
734 LOperand* spill_operand_; | 752 LOperand* spill_operand_; |
735 int spill_start_index_; | 753 int spill_start_index_; |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
767 void RecordDefinition(HInstruction* instr, LUnallocated* operand); | 785 void RecordDefinition(HInstruction* instr, LUnallocated* operand); |
768 // Record a temporary operand. | 786 // Record a temporary operand. |
769 void RecordTemporary(LUnallocated* operand); | 787 void RecordTemporary(LUnallocated* operand); |
770 | 788 |
771 // Marks the current instruction as a call. | 789 // Marks the current instruction as a call. |
772 void MarkAsCall(); | 790 void MarkAsCall(); |
773 | 791 |
774 // Checks whether the value of a given virtual register is tagged. | 792 // Checks whether the value of a given virtual register is tagged. |
775 bool HasTaggedValue(int virtual_register) const; | 793 bool HasTaggedValue(int virtual_register) const; |
776 | 794 |
777 // Checks whether the value of a given virtual register is a double. | 795 // Returns the register kind required by the given virtual register. |
778 bool HasDoubleValue(int virtual_register) const; | 796 RegisterKind RequiredRegisterKind(int virtual_register) const; |
779 | 797 |
780 // Begin a new instruction. | 798 // Begin a new instruction. |
781 void BeginInstruction(); | 799 void BeginInstruction(); |
782 | 800 |
783 // Summarize the current instruction. | 801 // Summarize the current instruction. |
784 void SummarizeInstruction(int index); | 802 void SummarizeInstruction(int index); |
785 | 803 |
786 // Summarize the current instruction. | 804 // Summarize the current instruction. |
787 void OmitInstruction(); | 805 void OmitInstruction(); |
788 | 806 |
(...skipping 18 matching lines...) Expand all Loading... |
807 ASSERT(!has_osr_entry_); | 825 ASSERT(!has_osr_entry_); |
808 // Simply set a flag to find and process instruction later. | 826 // Simply set a flag to find and process instruction later. |
809 has_osr_entry_ = true; | 827 has_osr_entry_ = true; |
810 } | 828 } |
811 | 829 |
812 #ifdef DEBUG | 830 #ifdef DEBUG |
813 void Verify() const; | 831 void Verify() const; |
814 #endif | 832 #endif |
815 | 833 |
816 private: | 834 private: |
817 enum OperationMode { | |
818 NONE, | |
819 CPU_REGISTERS, | |
820 XMM_REGISTERS | |
821 }; | |
822 | |
823 void MeetRegisterConstraints(); | 835 void MeetRegisterConstraints(); |
824 void ResolvePhis(); | 836 void ResolvePhis(); |
825 void BuildLiveRanges(); | 837 void BuildLiveRanges(); |
826 void AllocateGeneralRegisters(); | 838 void AllocateGeneralRegisters(); |
827 void AllocateDoubleRegisters(); | 839 void AllocateDoubleRegisters(); |
828 void ConnectRanges(); | 840 void ConnectRanges(); |
829 void ResolveControlFlow(); | 841 void ResolveControlFlow(); |
830 void PopulatePointerMaps(); | 842 void PopulatePointerMaps(); |
831 void ProcessOsrEntry(); | 843 void ProcessOsrEntry(); |
832 void AllocateRegisters(); | 844 void AllocateRegisters(); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
864 void ActiveToHandled(LiveRange* range); | 876 void ActiveToHandled(LiveRange* range); |
865 void ActiveToInactive(LiveRange* range); | 877 void ActiveToInactive(LiveRange* range); |
866 void InactiveToHandled(LiveRange* range); | 878 void InactiveToHandled(LiveRange* range); |
867 void InactiveToActive(LiveRange* range); | 879 void InactiveToActive(LiveRange* range); |
868 void FreeSpillSlot(LiveRange* range); | 880 void FreeSpillSlot(LiveRange* range); |
869 LOperand* TryReuseSpillSlot(LiveRange* range); | 881 LOperand* TryReuseSpillSlot(LiveRange* range); |
870 | 882 |
871 // Helper methods for allocating registers. | 883 // Helper methods for allocating registers. |
872 bool TryAllocateFreeReg(LiveRange* range); | 884 bool TryAllocateFreeReg(LiveRange* range); |
873 void AllocateBlockedReg(LiveRange* range); | 885 void AllocateBlockedReg(LiveRange* range); |
874 void SplitAndSpillIntersecting(LiveRange* range); | 886 |
| 887 // Live range splitting helpers. |
| 888 |
| 889 // Split the given range at the given position. |
| 890 // If range starts at or after the given position then the |
| 891 // original range is returned. |
| 892 // Otherwise returns the live range that starts at pos and contains |
| 893 // all uses from the original range that follow pos. Uses at pos will |
| 894 // still be owned by the original range after splitting. |
| 895 LiveRange* SplitAt(LiveRange* range, LifetimePosition pos); |
| 896 |
| 897 // Split the given range in a position from the interval [start, end]. |
| 898 LiveRange* SplitBetween(LiveRange* range, |
| 899 LifetimePosition start, |
| 900 LifetimePosition end); |
| 901 |
| 902 // Find a lifetime position in the interval [start, end] which |
| 903 // is optimal for splitting: it is either header of the outermost |
| 904 // loop covered by this interval or the latest possible position. |
875 LifetimePosition FindOptimalSplitPos(LifetimePosition start, | 905 LifetimePosition FindOptimalSplitPos(LifetimePosition start, |
876 LifetimePosition end); | 906 LifetimePosition end); |
877 LiveRange* Split(LiveRange* range, | 907 |
878 LifetimePosition start, | 908 // Spill the given life range after position pos. |
879 LifetimePosition end); | 909 void SpillAfter(LiveRange* range, LifetimePosition pos); |
880 LiveRange* Split(LiveRange* range, LifetimePosition split_pos); | 910 |
881 void SplitAndSpill(LiveRange* range, | 911 // Spill the given life range after position start and up to position end. |
882 LifetimePosition start, | 912 void SpillBetween(LiveRange* range, |
883 LifetimePosition end); | 913 LifetimePosition start, |
884 void SplitAndSpill(LiveRange* range, LifetimePosition at); | 914 LifetimePosition end); |
| 915 |
| 916 void SplitAndSpillIntersecting(LiveRange* range); |
| 917 |
885 void Spill(LiveRange* range); | 918 void Spill(LiveRange* range); |
886 bool IsBlockBoundary(LifetimePosition pos); | 919 bool IsBlockBoundary(LifetimePosition pos); |
887 void AddGapMove(int pos, LiveRange* prev, LiveRange* next); | 920 void AddGapMove(int pos, LiveRange* prev, LiveRange* next); |
888 | 921 |
889 // Helper methods for resolving control flow. | 922 // Helper methods for resolving control flow. |
890 void ResolveControlFlow(LiveRange* range, | 923 void ResolveControlFlow(LiveRange* range, |
891 HBasicBlock* block, | 924 HBasicBlock* block, |
892 HBasicBlock* pred); | 925 HBasicBlock* pred); |
893 | 926 |
894 // Return parallel move that should be used to connect ranges split at the | 927 // Return parallel move that should be used to connect ranges split at the |
(...skipping 12 matching lines...) Expand all Loading... |
907 // Helper methods for the fixed registers. | 940 // Helper methods for the fixed registers. |
908 int RegisterCount() const; | 941 int RegisterCount() const; |
909 static int FixedLiveRangeID(int index) { return -index - 1; } | 942 static int FixedLiveRangeID(int index) { return -index - 1; } |
910 static int FixedDoubleLiveRangeID(int index); | 943 static int FixedDoubleLiveRangeID(int index); |
911 LiveRange* FixedLiveRangeFor(int index); | 944 LiveRange* FixedLiveRangeFor(int index); |
912 LiveRange* FixedDoubleLiveRangeFor(int index); | 945 LiveRange* FixedDoubleLiveRangeFor(int index); |
913 LiveRange* LiveRangeFor(int index); | 946 LiveRange* LiveRangeFor(int index); |
914 HPhi* LookupPhi(LOperand* operand) const; | 947 HPhi* LookupPhi(LOperand* operand) const; |
915 LGap* GetLastGap(HBasicBlock* block) const; | 948 LGap* GetLastGap(HBasicBlock* block) const; |
916 | 949 |
| 950 const char* RegisterName(int allocation_index); |
| 951 |
917 LChunk* chunk_; | 952 LChunk* chunk_; |
918 ZoneList<InstructionSummary*> summaries_; | 953 ZoneList<InstructionSummary*> summaries_; |
919 InstructionSummary* next_summary_; | 954 InstructionSummary* next_summary_; |
920 | 955 |
921 ZoneList<InstructionSummary*> summary_stack_; | 956 ZoneList<InstructionSummary*> summary_stack_; |
922 | 957 |
923 // During liveness analysis keep a mapping from block id to live_in sets | 958 // During liveness analysis keep a mapping from block id to live_in sets |
924 // for blocks already analyzed. | 959 // for blocks already analyzed. |
925 ZoneList<BitVector*> live_in_sets_; | 960 ZoneList<BitVector*> live_in_sets_; |
926 | 961 |
927 // Liveness analysis results. | 962 // Liveness analysis results. |
928 ZoneList<LiveRange*> live_ranges_; | 963 ZoneList<LiveRange*> live_ranges_; |
929 | 964 |
930 // Lists of live ranges | 965 // Lists of live ranges |
931 ZoneList<LiveRange*> fixed_live_ranges_; | 966 ZoneList<LiveRange*> fixed_live_ranges_; |
932 ZoneList<LiveRange*> fixed_double_live_ranges_; | 967 ZoneList<LiveRange*> fixed_double_live_ranges_; |
933 ZoneList<LiveRange*> unhandled_live_ranges_; | 968 ZoneList<LiveRange*> unhandled_live_ranges_; |
934 ZoneList<LiveRange*> active_live_ranges_; | 969 ZoneList<LiveRange*> active_live_ranges_; |
935 ZoneList<LiveRange*> inactive_live_ranges_; | 970 ZoneList<LiveRange*> inactive_live_ranges_; |
936 ZoneList<LiveRange*> reusable_slots_; | 971 ZoneList<LiveRange*> reusable_slots_; |
937 | 972 |
938 // Next virtual register number to be assigned to temporaries. | 973 // Next virtual register number to be assigned to temporaries. |
939 int next_virtual_register_; | 974 int next_virtual_register_; |
940 | 975 |
941 OperationMode mode_; | 976 RegisterKind mode_; |
942 int num_registers_; | 977 int num_registers_; |
943 | 978 |
944 HGraph* graph_; | 979 HGraph* graph_; |
945 | 980 |
946 bool has_osr_entry_; | 981 bool has_osr_entry_; |
947 | 982 |
948 DISALLOW_COPY_AND_ASSIGN(LAllocator); | 983 DISALLOW_COPY_AND_ASSIGN(LAllocator); |
949 }; | 984 }; |
950 | 985 |
951 | 986 |
952 } } // namespace v8::internal | 987 } } // namespace v8::internal |
953 | 988 |
954 #endif // V8_LITHIUM_ALLOCATOR_H_ | 989 #endif // V8_LITHIUM_ALLOCATOR_H_ |
OLD | NEW |