Lines Matching refs:START
63 DCHECK(Contains(pos) && pos.Value() != start().Value());
77 DCHECK(Start().Value() <= cur->pos().Value() &&
87 // Intervals overlap if the start of one is contained in the other.
88 if (current_interval->Contains(target->start()) ||
89 target->Contains(current_interval->start())) {
148 UsePosition* LiveRange::NextUsePosition(LifetimePosition start) {
151 while (use_pos != NULL && use_pos->pos().Value() < start.Value()) {
160 LifetimePosition start) {
161 UsePosition* pos = NextUsePosition(start);
170 LifetimePosition start) {
173 while (pos != NULL && pos->pos().Value() < start.Value()) {
181 UsePosition* LiveRange::NextRegisterPosition(LifetimePosition start) {
182 UsePosition* pos = NextUsePosition(start);
230 if (current_interval_->start().Value() > position.Value()) {
241 if (to_start_of->start().Value() > but_not_past.Value()) return;
242 LifetimePosition start =
244 : current_interval_->start();
245 if (to_start_of->start().Value() > start.Value()) {
254 DCHECK(Start().Value() < position.Value());
265 if (current->start().Value() == position.Value()) {
266 // When splitting at start we need to locate the previous use interval.
276 if (next->start().Value() >= position.Value()) {
277 split_at_start = (next->start().Value() == position.Value());
339 // start positions. This is needed for the correctness of the register
340 // allocation algorithm. If two live ranges start at the same offset then there
344 LifetimePosition start = Start();
345 LifetimePosition other_start = other->Start();
346 if (start.Value() == other_start.Value()) {
353 return start.Value() < other_start.Value();
357 void LiveRange::ShortenTo(LifetimePosition start) {
358 LAllocator::TraceAlloc("Shorten live range %d to [%d\n", id_, start.Value());
360 DCHECK(first_interval_->start().Value() <= start.Value());
361 DCHECK(start.Value() < first_interval_->end().Value());
362 first_interval_->set_start(start);
366 void LiveRange::EnsureInterval(LifetimePosition start,
371 start.Value(),
375 first_interval_->start().Value() <= end.Value()) {
382 UseInterval* new_interval = new(zone) UseInterval(start, new_end);
391 void LiveRange::AddUseInterval(LifetimePosition start,
396 start.Value(),
399 UseInterval* interval = new(zone) UseInterval(start, end);
403 if (end.Value() == first_interval_->start().Value()) {
404 first_interval_->set_start(start);
405 } else if (end.Value() < first_interval_->start().Value()) {
406 UseInterval* interval = new(zone) UseInterval(start, end);
413 DCHECK(start.Value() < first_interval_->end().Value());
414 first_interval_->start_ = Min(start, first_interval_->start_);
456 DCHECK(Start().Value() <= use_pos->pos().Value() &&
471 return Start().Value() <= position.Value() &&
483 interval->next()->start().Value() >= interval->start().Value());
486 if (interval->start().Value() > position.Value()) return false;
495 LifetimePosition advance_last_processed_up_to = b->start();
496 UseInterval* a = FirstSearchIntervalForPosition(b->start());
498 if (a->start().Value() > other->End().Value()) break;
499 if (b->start().Value() > End().Value()) break;
504 if (a->start().Value() < b->start().Value()) {
506 if (a == NULL || a->start().Value() > other->End().Value()) break;
575 LifetimePosition start = LifetimePosition::FromInstructionIndex(
583 range->AddUseInterval(start, end, zone());
700 if (range->IsEmpty() || range->Start().Value() > position.Value()) {
733 LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START,
754 int start = block->first_instruction_index();
756 if (start == -1) return;
757 for (int i = start; i <= end; ++i) {
762 if (i > start) prev_instr = InstructionAt(i - 1);
897 LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START,
1065 label->GetOrCreateParallelMove(LGap::START, chunk()->zone())->
1171 LGap::START, chunk()->zone())->AddMove(pred_op, cur_op,
1183 pos.IsInstructionStart() ? LGap::START : LGap::END, chunk()->zone());
1205 LifetimePosition pos = second_range->Start();
1287 LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START,
1318 LifetimePosition start = LifetimePosition::FromInstructionIndex(
1325 range->EnsureInterval(start, end, zone());
1396 int start = range->Start().InstructionIndex();
1401 DCHECK(cur->Start().InstructionIndex() >= start);
1407 if (start < last_range_start) {
1410 last_range_start = start;
1412 // Step across all the safe points that are before the start of this range,
1417 if (safe_point >= start) break;
1451 TraceAlloc("Pointer in register for range %d (start at %d) "
1453 cur->id(), cur->Start().Value(), safe_point);
1519 LifetimePosition position = current->Start();
1523 TraceAlloc("Processing interval %d start=%d\n",
1540 current->Start().NextInstruction().Value()) {
1542 // the register is too close to the start of live range.
1543 SpillBetween(current, current->Start(), pos->pos());
1647 DCHECK(allocation_finger_.Value() <= range->Start().Value());
1657 TraceAlloc("Add live range %d to unhandled at start\n", range->id());
1694 if (a->Start().Value() < b->Start().Value()) return false;
1716 range->TopLevel()->Start().Value()) {
1774 DCHECK(cur_inactive->End().Value() > current->Start().Value());
1813 if (pos.Value() <= current->Start().Value()) {
1819 // Register reg is available at the range start but becomes blocked before
1827 // Register reg is available at the range start and is free until
1840 UsePosition* register_use = current->NextRegisterPosition(current->Start());
1859 if (range->IsFixed() || !range->CanBeSpilled(current->Start())) {
1864 current->Start());
1875 DCHECK(range->End().Value() > current->Start().Value());
1900 SpillBetween(current, current->Start(), register_use->pos());
1908 current->Start(),
1964 LifetimePosition split_pos = current->Start();
1968 UsePosition* next_pos = range->NextRegisterPosition(current->Start());
1974 // remains spilled at least until the start of the current live range.
1976 // start before the current range as this violates allocation invariant
1978 // live-ranges: ranges are allocated in order of their start positions,
1979 // ranges are retired from active/inactive when the start of the
1981 SpillBetweenUntil(range, spill_pos, current->Start(), next_pos->pos());
1991 DCHECK(range->End().Value() > current->Start().Value());
1995 UsePosition* next_pos = range->NextRegisterPosition(current->Start());
2021 if (pos.Value() <= range->Start().Value()) return range;
2037 LifetimePosition start,
2042 start.Value(),
2045 LifetimePosition split_pos = FindOptimalSplitPos(start, end);
2046 DCHECK(split_pos.Value() >= start.Value());
2051 LifetimePosition LAllocator::FindOptimalSplitPos(LifetimePosition start,
2053 int start_instr = start.InstructionIndex();
2060 HBasicBlock* start_block = GetBlock(start);
2093 LifetimePosition start,
2095 SpillBetweenUntil(range, start, start, end);
2100 LifetimePosition start,
2103 CHECK(start.Value() < end.Value());
2104 LiveRange* second_part = SplitRangeAt(range, start);
2107 if (second_part->Start().Value() < end.Value()) {
2108 // The split result intersects with [start, end[.
2109 // Split it at position between ]start+1, end[, spill the middle part
2113 Max(second_part->Start().InstructionEnd(), until),
2122 // The split result does not intersect with [start, end[.
