Lines Matching full:current
222 // at the current or the immediate next position.
289 UseInterval* current = FirstSearchIntervalForPosition(position);
295 if (current->start().Value() == position.Value()) {
297 current = first_interval_;
300 while (current != NULL) {
301 if (current->Contains(position)) {
302 current->SplitAt(position, zone);
305 UseInterval* next = current->next();
310 current = next;
314 UseInterval* before = current;
461 UsePosition* current = first_pos_;
462 while (current != NULL && current->pos().Value() < pos.Value()) {
463 prev_hint = current->HasHint() ? current : prev_hint;
464 prev = current;
465 current = current->next();
583 HBasicBlock* successor = it.Current();
613 int operand_index = iterator.Current();
808 LUnallocated* temp = LUnallocated::cast(it.Current());
853 LUnallocated* cur_input = LUnallocated::cast(it.Current());
1000 LOperand* input = it.Current();
1017 LOperand* temp = it.Current();
1273 int operand_index = iterator.Current();
1347 int operand_index = iterator.Current();
1364 int operand_index = iterator.Current();
1460 // Advance to the next active range that covers the current
1527 LiveRange* current = fixed_double_live_ranges_.at(i);
1528 if (current != NULL) {
1529 AddToInactive(current);
1535 LiveRange* current = fixed_live_ranges_.at(i);
1536 if (current != NULL) {
1537 AddToInactive(current);
1544 LiveRange* current = unhandled_live_ranges_.RemoveLast();
1546 LifetimePosition position = current->Start();
1551 current->id(),
1554 if (current->HasAllocatedSpillOperand()) {
1555 TraceAlloc("Live range %d already has a spill operand\n", current->id());
1560 UsePosition* pos = current->NextUsePositionRegisterIsBeneficial(next_pos);
1564 Spill(current);
1567 current->Start().NextInstruction().Value()) {
1570 SpillBetween(current, current->Start(), pos->pos());
1599 ASSERT(!current->HasRegisterAssigned() && !current->IsSpilled());
1601 bool result = TryAllocateFreeReg(current);
1604 if (!result) AllocateBlockedReg(current);
1607 if (current->HasRegisterAssigned()) {
1608 AddToActive(current);
1790 bool LAllocator::TryAllocateFreeReg(LiveRange* current) {
1805 ASSERT(cur_inactive->End().Value() > current->Start().Value());
1807 cur_inactive->FirstIntersection(current);
1813 LOperand* hint = current->FirstHint();
1820 current->id(),
1821 current->End().Value());
1823 // The desired register is free until the end of the current live range.
1824 if (free_until_pos[register_index].Value() >= current->End().Value()) {
1827 current->id());
1828 SetLiveRangeAssignedRegister(current, register_index);
1843 if (pos.Value() <= current->Start().Value()) {
1848 if (pos.Value() < current->End().Value()) {
1850 // the range end. Split current at position where it becomes blocked.
1851 LiveRange* tail = SplitRangeAt(current, pos);
1859 ASSERT(pos.Value() >= current->End().Value());
1862 current->id());
1863 SetLiveRangeAssignedRegister(current, reg);
1869 void LAllocator::AllocateBlockedReg(LiveRange* current) {
1870 UsePosition* register_use = current->NextRegisterPosition(current->Start());
1872 // There is no use in the current live range that requires a register.
1874 Spill(current);
1889 if (range->IsFixed() || !range->CanBeSpilled(current->Start())) {
1894 current->Start());
1905 ASSERT(range->End().Value() > current->Start().Value());
1906 LifetimePosition next_intersection = range->FirstIntersection(current);
1929 SpillBetween(current, current->Start(), register_use->pos());
1933 if (block_pos[reg].Value() < current->End().Value()) {
1934 // Register becomes blocked before the current range end. Split before that
1936 LiveRange* tail = SplitBetween(current,
1937 current->Start(),
1944 ASSERT(block_pos[reg].Value() >= current->End().Value());
1947 current->id());
1948 SetLiveRangeAssignedRegister(current, reg);
1952 // at the same lifetime positions as current.
1953 SplitAndSpillIntersecting(current);
1990 void LAllocator::SplitAndSpillIntersecting(LiveRange* current) {
1991 ASSERT(current->HasRegisterAssigned());
1992 int reg = current->assigned_register();
1993 LifetimePosition split_pos = current->Start();
1997 UsePosition* next_pos = range->NextRegisterPosition(current->Start());
2003 // remains spilled at least until the start of the current live range.
2005 // start before the current range as this violates allocation invariant
2009 // current live-range is larger than their end.
2010 SpillBetweenUntil(range, spill_pos, current->Start(), next_pos->pos());
2020 ASSERT(range->End().Value() > current->Start().Value());
2022 LifetimePosition next_intersection = range->FirstIntersection(current);
2024 UsePosition* next_pos = range->NextRegisterPosition(current->Start());
2182 LiveRange* current = live_ranges()->at(i);
2183 if (current != NULL) current->Verify();
