1 // Copyright 2011 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_LITHIUM_ALLOCATOR_INL_H_ 6 #define V8_LITHIUM_ALLOCATOR_INL_H_ 7 8 #include "src/lithium-allocator.h" 9 10 #if V8_TARGET_ARCH_IA32 11 #include "src/ia32/lithium-ia32.h" 12 #elif V8_TARGET_ARCH_X64 13 #include "src/x64/lithium-x64.h" 14 #elif V8_TARGET_ARCH_ARM64 15 #include "src/arm64/lithium-arm64.h" 16 #elif V8_TARGET_ARCH_ARM 17 #include "src/arm/lithium-arm.h" 18 #elif V8_TARGET_ARCH_MIPS 19 #include "src/mips/lithium-mips.h" 20 #elif V8_TARGET_ARCH_X87 21 #include "src/x87/lithium-x87.h" 22 #else 23 #error "Unknown architecture." 24 #endif 25 26 namespace v8 { 27 namespace internal { 28 29 bool LAllocator::IsGapAt(int index) { return chunk_->IsGapAt(index); } 30 31 32 LInstruction* LAllocator::InstructionAt(int index) { 33 return chunk_->instructions()->at(index); 34 } 35 36 37 LGap* LAllocator::GapAt(int index) { 38 return chunk_->GetGapAt(index); 39 } 40 41 42 TempIterator::TempIterator(LInstruction* instr) 43 : instr_(instr), 44 limit_(instr->TempCount()), 45 current_(0) { 46 SkipUninteresting(); 47 } 48 49 50 bool TempIterator::Done() { return current_ >= limit_; } 51 52 53 LOperand* TempIterator::Current() { 54 ASSERT(!Done()); 55 return instr_->TempAt(current_); 56 } 57 58 59 void TempIterator::SkipUninteresting() { 60 while (current_ < limit_ && instr_->TempAt(current_) == NULL) ++current_; 61 } 62 63 64 void TempIterator::Advance() { 65 ++current_; 66 SkipUninteresting(); 67 } 68 69 70 InputIterator::InputIterator(LInstruction* instr) 71 : instr_(instr), 72 limit_(instr->InputCount()), 73 current_(0) { 74 SkipUninteresting(); 75 } 76 77 78 bool InputIterator::Done() { return current_ >= limit_; } 79 80 81 LOperand* InputIterator::Current() { 82 ASSERT(!Done()); 83 ASSERT(instr_->InputAt(current_) != NULL); 84 return instr_->InputAt(current_); 85 } 86 87 88 void InputIterator::Advance() { 89 ++current_; 90 SkipUninteresting(); 91 } 92 93 94 void InputIterator::SkipUninteresting() { 95 while (current_ < limit_) { 96 LOperand* current = instr_->InputAt(current_); 97 if (current != NULL && !current->IsConstantOperand()) break; 98 ++current_; 99 } 100 } 101 102 103 UseIterator::UseIterator(LInstruction* instr) 104 : input_iterator_(instr), env_iterator_(instr->environment()) { } 105 106 107 bool UseIterator::Done() { 108 return input_iterator_.Done() && env_iterator_.Done(); 109 } 110 111 112 LOperand* UseIterator::Current() { 113 ASSERT(!Done()); 114 LOperand* result = input_iterator_.Done() 115 ? env_iterator_.Current() 116 : input_iterator_.Current(); 117 ASSERT(result != NULL); 118 return result; 119 } 120 121 122 void UseIterator::Advance() { 123 input_iterator_.Done() 124 ? env_iterator_.Advance() 125 : input_iterator_.Advance(); 126 } 127 128 129 void LAllocator::SetLiveRangeAssignedRegister(LiveRange* range, int reg) { 130 if (range->Kind() == DOUBLE_REGISTERS) { 131 assigned_double_registers_->Add(reg); 132 } else { 133 ASSERT(range->Kind() == GENERAL_REGISTERS); 134 assigned_registers_->Add(reg); 135 } 136 range->set_assigned_register(reg, chunk()->zone()); 137 } 138 139 140 } } // namespace v8::internal 141 142 #endif // V8_LITHIUM_ALLOCATOR_INL_H_ 143