181 // ********** functions for classification of intervals
216   // fixed intervals not needed for FPU stack allocation
221   // fixed intervals never contain oops
285 // (only used for parent intervals that are created during the building phase)
292   // assign register number for precolored intervals
299 // assign a new reg_num to the interval and append it to the list of intervals
300 // (only used for child intervals that are created during register allocation)
317   //       intervals (only the very beginning of the interval must be in memory)
324 // called during building of intervals
336       assert(def_pos <= interval->spill_definition_pos(), "positions are processed in reverse order when intervals are created");
404   // collect all intervals that must be stored after their definion.
416       assert(temp->from() >= prev->from(), "intervals not sorted");
417       assert(temp->spill_definition_pos() >= prev->spill_definition_pos(), "when intervals are sorted by from, then they must also be sorted by spill_definition_pos");
422     assert(temp->spill_definition_pos() <= temp->from() + 2, "only intervals defined once at their start-pos can be optimized");
636         // fixed intervals are never live at block boundaries, so
680         // fixed intervals are never live at block boundaries, so
713         // fixed intervals are never live at block boundaries, so
830   // check that fixed intervals are not live at block boundaries
831   // (live set must be empty at fixed intervals)
878 // ********** Phase 4: build intervals
972       // also add use_kind for dead intervals
980     // also add use_kind for dead intervals
988     TRACE_LINEAR_SCAN(2, tty->print_cr("Warning: dead value %d at %d in live intervals", reg_num, def_pos));
1271   // initialize interval list with expected number of intervals
1330     // Update intervals for registers live at the end of this block;
1335       assert(number >= LIR_OprDesc::vreg_base, "fixed intervals must not be live on block bounds");
1353     // definitions of intervals are processed before uses
1419   // add the range [0, 1[ to all fixed intervals
1420   // -> the register allocator need not handle unhandled fixed intervals
1449 bool LinearScan::is_sorted(IntervalArray* intervals) {
1452   for (i = 0; i < intervals->length(); i ++) {
1453     Interval* it = intervals->at(i);
1463   // check in both directions if sorted list and unsorted list contain same intervals
1467       for (j = 0; j < intervals->length(); j++) {
1468         if (interval_at(i) == intervals->at(j)) {
1472       assert(num_found == 1, "lists do not contain same intervals");
1475   for (j = 0; j < intervals->length(); j++) {
1478       if (interval_at(i) == intervals->at(j)) {
1482     assert(num_found == 1, "lists do not contain same intervals");
1554   // only some intervals are swapped. So this is much faster than a complete QuickSort
1565         // the asumption that the intervals are already sorted failed,
1577   assert(is_sorted(_sorted_intervals), "intervals unsorted");
1595     // no intervals have been added during allocation, so sorted list is already up to date
1596     assert(is_sorted(_sorted_intervals), "intervals unsorted");
1600   // conventional sort-algorithm for new intervals
1619   assert(is_sorted(_sorted_intervals), "intervals unsorted");
1656 // (insert moves at edges between blocks if intervals have been split)
1808           // collect all intervals that have been split between from_block and to_block
2355   // intervals that have no oops inside need not to be processed
2368   // walk before the current operation -> intervals that start at
2387   // Iterate through active intervals
2398     // moves, any intervals which end at this instruction are included
2801         // considered in the live ranges of intervals)
2812       // The operand must be live because debug information is considered when building the intervals
3164 // (check that all intervals have a correct register and that no registers are overwritten)
3168   TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying intervals ******************************************"));
3171   TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying that no oops are in fixed intervals ****************"));
3234       // special intervals that are created in MoveResolver
3321               assert(ok, "fixed intervals should never be live across an oopmap point");
3378       assert(value != NULL, "all intervals live across block boundaries must have Value");
3471     tty->print_cr("Input-State of intervals:");
3946   // check that all intervals have been processed
4123           assert(i1->to() <= i2->from() && i1->to() < i2->to(), "intervals overlapping");
4125           assert(i2->from() < i1->from(), "intervals start at same op_id");
4126           assert(i2->to() <= i1->from() && i2->to() < i1->to(), "intervals overlapping");
4197         tty->print_cr("two valid result intervals found for op_id %d: %d and %d", op_id, result->reg_num(), tmp->reg_num());
4200         assert(false, "two valid result intervals found");
4260   assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4271   assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4282   assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4293   assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4310   // do not add use positions for precolored intervals because
4377 // (the split parent) and the intervals that are split off this interval (the split children)
4384   assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
4452   assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
4533     // need a temporary operand for fixed intervals because type() cannot be called
4729     // intervals may start at same position -> prefer fixed interval
4947       assert(list->current_intersects_at(cur) == -1, "invalid optimization: intervals intersect");
5194     // Also kick parent intervals out of register to memory when they have no use
5195     // position. This avoids short interval in register surrounded by intervals in
5363   assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5367   // only intervals overlapping with cur are processed, non-overlapping invervals can be ignored safely
5378       assert(hint_reg != any_reg && hint_regHi == any_reg, "must be for fixed intervals");
5521   assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5530       tty->print("      reg %d: use_pos: %d, block_pos: %d, intervals: ", i, _use_pos[i], _block_pos[i]);
5618   // fast calculation of intervals that can never get a register because the
5672 // assign same spill slot to non-intersecting intervals
5687     // combining the stack slots for intervals where spill move optimization is applied
5722   // modify intervals such that cur gets the same stack slot as register_hint
5723   // delete use positions to prevent the intervals to get a register at beginning
5758     // (this is the normal case for most intervals)
5761     // assign same spill slot to non-intersecting intervals
5771     // spilled intervals need not be move to active-list
6356     case counter_interval:        return "intervals";
6357     case counter_fixed_interval:  return "fixed intervals";

Indexes created Tue Jul 24 14:28:13 CEST 2018