Lines Matching refs:Interval
183 bool LinearScan::is_precolored_interval(const Interval* i) {
187 bool LinearScan::is_virtual_interval(const Interval* i) {
191 bool LinearScan::is_precolored_cpu_interval(const Interval* i) {
195 bool LinearScan::is_virtual_cpu_interval(const Interval* i) {
203 bool LinearScan::is_precolored_fpu_interval(const Interval* i) {
207 bool LinearScan::is_virtual_fpu_interval(const Interval* i) {
215 bool LinearScan::is_in_fpu_register(const Interval* i) {
220 bool LinearScan::is_oop_interval(const Interval* i) {
266 void LinearScan::assign_spill_slot(Interval* it) {
286 Interval* LinearScan::create_interval(int reg_num) {
289 Interval* interval = new Interval(reg_num);
301 void LinearScan::append_interval(Interval* it) {
308 void LinearScan::copy_register_flags(Interval* from, Interval* to) {
325 void LinearScan::change_spill_definition_pos(Interval* interval, int def_pos) {
356 void LinearScan::change_spill_state(Interval* interval, int spill_pos) {
395 bool LinearScan::must_store_at_definition(const Interval* i) {
405 // the list is sorted by Interval::spill_definition_pos
406 Interval* interval;
407 Interval* temp_list;
411 Interval* prev = NULL;
412 Interval* temp = interval;
413 while (temp != Interval::end()) {
451 Interval* interval = interval_at(op1->result_opr()->vreg_number());
461 assert(interval == Interval::end() || interval->spill_definition_pos() >= op_id, "invalid order");
462 assert(interval == Interval::end() || (interval->is_split_parent() && interval->spill_state() == storeAtDefinition), "invalid interval");
464 while (interval != Interval::end() && interval->spill_definition_pos() == op_id) {
489 assert(interval == Interval::end(), "missed an interval");
955 Interval* interval = interval_at(reg_num);
1000 Interval* interval = interval_at(reg_num);
1015 Interval* interval = interval_at(reg_num);
1196 Interval* interval = interval_at(reg_num(move->result_opr()));
1238 Interval* from = interval_at(reg_num(move_from));
1239 Interval* to = interval_at(reg_num(move_to));
1255 Interval* from = interval_at(reg_num(move_from));
1256 Interval* to = interval_at(reg_num(move_to));
1422 Interval* interval = interval_at(n);
1432 int LinearScan::interval_cmp(Interval** a, Interval** b) {
1453 Interval* it = intervals->at(i);
1489 void LinearScan::add_to_list(Interval** first, Interval** prev, Interval* interval) {
1498 void LinearScan::create_unhandled_lists(Interval** list1, Interval** list2, bool (is_list1)(const Interval* i), bool (is_list2)(const Interval* i)) {
1501 *list1 = *list2 = Interval::end();
1503 Interval* list1_prev = NULL;
1504 Interval* list2_prev = NULL;
1505 Interval* v;
1519 if (list1_prev != NULL) list1_prev->set_next(Interval::end());
1520 if (list2_prev != NULL) list2_prev->set_next(Interval::end());
1522 assert(list1_prev == NULL || list1_prev->next() == Interval::end(), "linear list ends not with sentinel");
1523 assert(list2_prev == NULL || list2_prev->next() == Interval::end(), "linear list ends not with sentinel");
1533 // Re-sort existing interval list because an Interval::from() has changed
1556 Interval* cur_interval = unsorted_list->at(unsorted_idx);
1584 // Re-sort existing interval list because an Interval::from() has changed
1626 Interval* precolored_cpu_intervals, *not_precolored_cpu_intervals;
1627 Interval* precolored_fpu_intervals, *not_precolored_fpu_intervals;
1637 assert(not_precolored_fpu_intervals == Interval::end(), "missed an uncolored fpu interval");
1658 // wrapper for Interval::split_child_at_op_id that performs a bailout in product mode
1660 Interval* LinearScan::split_child_at_op_id(Interval* interval, int op_id, LIR_OpVisitState::OprMode mode) {
1661 Interval* result = interval->split_child_at_op_id(op_id, mode);
1667 result = new Interval(LIR_OprDesc::vreg_base);
1674 Interval* LinearScan::interval_at_block_begin(BlockBegin* block, int reg_num) {
1681 Interval* LinearScan::interval_at_block_end(BlockBegin* block, int reg_num) {
1688 Interval* LinearScan::interval_at_op_id(int reg_num, int op_id) {
1708 Interval* from_interval = interval_at_block_end(from_block, r);
1709 Interval* to_interval = interval_at_block_begin(to_block, r);
1827 Interval* interval = interval_at_block_begin(block, reg_num);
1857 Interval* spilled_part = interval;
1902 Interval* to_interval = interval_at_block_begin(to_block, reg_num);
1921 Interval* from_interval = interval_at_op_id(from_value->operand()->vreg_number(), throwing_op_id);
1928 Interval* from_interval = interval_at_op_id(reg_num, throwing_op_id);
2019 VMReg LinearScan::vm_reg_for_interval(Interval* interval) {
2035 LIR_Opr LinearScan::operand_for_interval(Interval* interval) {
2046 LIR_Opr LinearScan::calc_operand_for_interval(const Interval* interval) {
2158 LIR_Opr LinearScan::canonical_spill_opr(Interval* interval) {
2166 Interval* interval = interval_at(opr->vreg_number());
2350 Interval* oop_intervals;
2351 Interval* non_oop_intervals;
2358 non_oop_intervals = new Interval(any_reg);
2388 for (Interval* interval = iw->active_first(fixedKind); interval != Interval::end(); interval = interval->next()) {
3126 Interval* interval = interval_at(i);
3188 Interval* i1 = interval_at(i);
3194 tty->print_cr("Interval %d is on position %d in list", i1->reg_num(), i); i1->print(); tty->cr();
3199 tty->print_cr("Interval %d has no type assigned", i1->reg_num()); i1->print(); tty->cr();
3204 tty->print_cr("Interval %d has no register assigned", i1->reg_num()); i1->print(); tty->cr();
3209 tty->print_cr("Interval %d: low and high register equal", i1->reg_num()); i1->print(); tty->cr();
3214 tty->print_cr("Can not have an Interval for an ignored register"); i1->print(); tty->cr();
3219 tty->print_cr("Interval %d has no Range", i1->reg_num()); i1->print(); tty->cr();
3225 tty->print_cr("Interval %d has zero length range", i1->reg_num()); i1->print(); tty->cr();
3231 Interval* i2 = interval_at(j);
3257 Interval* fixed_intervals;
3258 Interval* other_intervals;
3263 other_intervals = new Interval(any_reg);
3296 for (Interval* interval = iw->active_first(fixedKind);
3297 interval != Interval::end();
3339 Interval* interval = interval_at(reg_num(opr));
3395 Interval* interval_at(int reg_num) const { return _allocator->interval_at(reg_num); }
3408 void state_put(IntervalList* input_state, int reg, Interval* interval);
3409 bool check_state(IntervalList* input_state, int reg, Interval* interval);
3441 Interval* interval = interval_at(reg_num(opr));
3554 void RegisterVerifier::state_put(IntervalList* input_state, int reg, Interval* interval) {
3566 bool RegisterVerifier::check_state(IntervalList* input_state, int reg, Interval* interval) {
3593 Interval* interval = interval_at(reg_num(opr));
3638 Interval* interval = interval_at(reg_num(opr));
3653 Interval* interval = interval_at(reg_num(opr));
3724 Interval* it = _mapping_from.at(i);
3739 Interval* it = _mapping_to.at(i);
3751 Interval* it = _mapping_from.at(i);
3757 Interval* it = _mapping_to.at(i);
3766 void MoveResolver::block_registers(Interval* it) {
3780 void MoveResolver::unblock_registers(Interval* it) {
3794 bool MoveResolver::save_to_process_move(Interval* from, Interval* to) {
3834 void MoveResolver::insert_move(Interval* from_interval, Interval* to_interval) {
3854 void MoveResolver::insert_move(LIR_Opr from_opr, Interval* to_interval) {
3875 Interval* from_interval = _mapping_from.at(i);
3886 Interval* from_interval = _mapping_from.at(i);
3887 Interval* to_interval = _mapping_to.at(i);
3915 Interval* from_interval = _mapping_from.at(spill_candidate);
3916 Interval* spill_interval = new Interval(-1);
3934 TRACE_LINEAR_SCAN(4, tty->print_cr("created new Interval %d for spilling", spill_interval->reg_num()));
3979 void MoveResolver::add_mapping(Interval* from_interval, Interval* to_interval) {
3988 void MoveResolver::add_mapping(LIR_Opr from_opr, Interval* to_interval) {
4060 // **** Implementation of Interval **********************************
4063 Interval* Interval::_end = NULL;
4064 void Interval::initialize(Arena* arena) {
4066 _end = new (arena) Interval(-1);
4069 Interval::Interval(int reg_num) :
4093 int Interval::calc_to() {
4106 void Interval::check_split_children() {
4111 Interval* i1 = _split_children.at(i);
4118 Interval* i2 = _split_children.at(j);
4134 Interval* Interval::register_hint(bool search_split_child) const {
4149 Interval* cur = _register_hint->_split_children.at(i);
4163 Interval* Interval::split_child_at_op_id(int op_id, LIR_OpVisitState::OprMode mode) {
4167 Interval* result;
4179 Interval* cur = _split_children.at(i);
4195 Interval* tmp = _split_children.at(i);
4214 Interval* Interval::split_child_before_op_id(int op_id) {
4217 Interval* parent = split_parent();
4218 Interval* result = NULL;
4224 Interval* cur = parent->_split_children.at(i);
4236 bool Interval::split_child_covers(int op_id, LIR_OpVisitState::OprMode mode) {
4248 Interval* cur = _split_children.at(i);
4259 int Interval::first_usage(IntervalUseKind min_use_kind) const {
4270 int Interval::next_usage(IntervalUseKind min_use_kind, int from) const {
4281 int Interval::next_usage_exact(IntervalUseKind exact_use_kind, int from) const {
4292 int Interval::previous_usage(IntervalUseKind min_use_kind, int from) const {
4307 void Interval::add_use_pos(int pos, IntervalUseKind use_kind) {
4337 void Interval::add_range(int from, int to) {
4352 Interval* Interval::new_split_child() {
4354 Interval* result = new Interval(-1);
4357 Interval* parent = split_parent();
4383 Interval* Interval::split(int split_pos) {
4387 Interval* result = new_split_child();
4451 Interval* Interval::split_from_start(int split_pos) {
4458 Interval* result = new_split_child();
4476 bool Interval::covers(int op_id, LIR_OpVisitState::OprMode mode) const {
4496 bool Interval::has_hole_between(int hole_from, int hole_to) {
4525 void Interval::print(outputStream* out) const {
4589 IntervalWalker::IntervalWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first)
4595 _active_first[fixedKind] = Interval::end();
4596 _inactive_first[fixedKind] = Interval::end();
4597 _active_first[anyKind] = Interval::end();
4598 _inactive_first[anyKind] = Interval::end();
4606 void IntervalWalker::append_unsorted(Interval** list, Interval* interval) {
4612 void IntervalWalker::append_sorted(Interval** list, Interval* interval) {
4613 Interval* prev = NULL;
4614 Interval* cur = *list;
4626 void IntervalWalker::append_to_unhandled(Interval** list, Interval* interval) {
4629 Interval* prev = NULL;
4630 Interval* cur = *list;
4643 inline bool IntervalWalker::remove_from_list(Interval** list, Interval* i) {
4644 while (*list != Interval::end() && *list != i) {
4647 if (*list != Interval::end()) {
4656 void IntervalWalker::remove_from_list(Interval* i) {
4673 Interval** prev = state == activeState ? active_first_addr(kind) : inactive_first_addr(kind);
4674 Interval* next = *prev;
4676 Interval* cur = next;
4725 Interval* any = _unhandled_first[anyKind];
4726 Interval* fixed = _unhandled_first[fixedKind];
4728 if (any != Interval::end()) {
4730 kind = fixed != Interval::end() && fixed->from() <= any->from() ? fixedKind : anyKind;
4734 assert(any == Interval::end() || fixed == Interval::end() || any->from() != fixed->from() || kind == fixedKind, "if fixed and any-Interval start at same position, fixed must be processed first");
4736 } else if (fixed != Interval::end()) {
4744 _current->set_next(Interval::end());
4778 void IntervalWalker::interval_moved(Interval* interval, IntervalKind kind, IntervalState from, IntervalState to) {
4803 LinearScanWalker::LinearScanWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first)
4830 inline void LinearScanWalker::exclude_from_use(Interval* i) {
4837 inline void LinearScanWalker::set_use_pos(int reg, Interval* i, int use_pos, bool only_process_use_pos) {
4849 inline void LinearScanWalker::set_use_pos(Interval* i, int use_pos, bool only_process_use_pos) {
4857 inline void LinearScanWalker::set_block_pos(int reg, Interval* i, int block_pos) {
4867 inline void LinearScanWalker::set_block_pos(Interval* i, int block_pos) {
4877 Interval* list = active_first(fixedKind);
4878 while (list != Interval::end()) {
4886 Interval* list = active_first(anyKind);
4887 while (list != Interval::end()) {
4893 void LinearScanWalker::free_collect_inactive_fixed(Interval* cur) {
4894 Interval* list = inactive_first(fixedKind);
4895 while (list != Interval::end()) {
4906 void LinearScanWalker::free_collect_inactive_any(Interval* cur) {
4907 Interval* list = inactive_first(anyKind);
4908 while (list != Interval::end()) {
4914 void LinearScanWalker::free_collect_unhandled(IntervalKind kind, Interval* cur) {
4915 Interval* list = unhandled_first(kind);
4916 while (list != Interval::end()) {
4926 Interval* list = active_first(fixedKind);
4927 while (list != Interval::end()) {
4933 void LinearScanWalker::spill_block_unhandled_fixed(Interval* cur) {
4934 Interval* list = unhandled_first(fixedKind);
4935 while (list != Interval::end()) {
4941 void LinearScanWalker::spill_block_inactive_fixed(Interval* cur) {
4942 Interval* list = inactive_first(fixedKind);
4943 while (list != Interval::end()) {
4955 Interval* list = active_first(anyKind);
4956 while (list != Interval::end()) {
4962 void LinearScanWalker::spill_collect_inactive_any(Interval* cur) {
4963 Interval* list = inactive_first(anyKind);
4964 while (list != Interval::end()) {
4973 void LinearScanWalker::insert_move(int op_id, Interval* src_it, Interval* dst_it) {
5034 int LinearScanWalker::find_optimal_split_pos(Interval* it, int min_split_pos, int max_split_pos, bool do_loop_optimization) {
5120 void LinearScanWalker::split_before_usage(Interval* it, int min_split_pos, int max_split_pos) {
5154 Interval* split_part = it->split(optimal_split_pos);
5172 void LinearScanWalker::split_for_spilling(Interval* it) {
5197 Interval* parent = it;
5230 Interval* spilled_part = it->split(optimal_split_pos);
5251 void LinearScanWalker::split_stack_interval(Interval* it) {
5258 void LinearScanWalker::split_when_partial_register_available(Interval* it, int register_available_until) {
5265 void LinearScanWalker::split_and_spill_interval(Interval* it) {
5354 bool LinearScanWalker::alloc_free_reg(Interval* cur) {
5363 assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5372 Interval* register_hint = cur->register_hint();
5495 Interval* it = _spill_intervals[reg]->at(i);
5503 Interval* it = _spill_intervals[regHi]->at(i);
5513 // Split an Interval and spill it to memory so that cur can be placed in a register
5514 void LinearScanWalker::alloc_locked_reg(Interval* cur) {
5521 assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5616 bool LinearScanWalker::no_allocation_possible(Interval* cur) {
5640 void LinearScanWalker::init_vars_for_alloc(Interval* cur) {
5660 bool LinearScanWalker::is_move(LIR_Op* op, Interval* from, Interval* to) {
5673 void LinearScanWalker::combine_spilled_intervals(Interval* cur) {
5679 Interval* register_hint = cur->register_hint(false);
5704 Interval* begin_hint = register_hint->split_child_at_op_id(begin_pos, LIR_OpVisitState::inputMode);
5705 Interval* end_hint = register_hint->split_child_at_op_id(end_pos, LIR_OpVisitState::outputMode);
5732 Interval* cur = current();
6468 Interval* cur = allocator->interval_at(i);