Lines Matching defs:interval
32 * that multiple values may share the same register interval. From the
37 * instruction, are "locked" to their parent interval. The details of this are
55 const struct ir3_reg_interval *interval =
57 if (interval->reg->interval_start > reg)
59 else if (interval->reg->interval_end <= reg)
80 /* Get the interval covering the reg, or the closest to the right if it
86 struct ir3_reg_interval *interval =
88 if (!interval) {
90 } else if (interval->reg->interval_end > offset) {
91 return interval;
93 /* There is no interval covering reg, and ra_file_search_sloppy()
94 * returned the closest range to the left, so the next interval to the
97 return ir3_reg_interval_next_or_null(interval);
111 struct ir3_reg_interval *interval)
114 ir3_reg_interval_search_right(tree, interval->reg->interval_start);
115 if (right && right->reg->interval_start < interval->reg->interval_end) {
132 assert((interval->reg->flags & IR3_REG_HALF) ==
135 if (right->reg->interval_end <= interval->reg->interval_end &&
136 right->reg->interval_start >= interval->reg->interval_start) {
138 assert(interval != right);
140 /* "right" is contained in "interval" and must become a child of
144 right && right->reg->interval_start < interval->reg->interval_end;
146 /* "right" must be contained in "interval." */
147 assert(right->reg->interval_end <= interval->reg->interval_end);
148 assert((interval->reg->flags & IR3_REG_HALF) ==
152 right->parent = interval;
154 rb_tree_insert(&interval->children, &right->node,
158 /* "right" must contain "interval," since intervals must form a
161 assert(right->reg->interval_start <= interval->reg->interval_start);
162 interval->parent = right;
163 interval_insert(ctx, &right->children, interval);
168 if (!interval->parent)
169 ctx->interval_add(ctx, interval);
170 rb_tree_insert(tree, &interval->node, ir3_reg_interval_insert_cmp);
171 interval->inserted = true;
176 struct ir3_reg_interval *interval)
178 rb_tree_init(&interval->children);
179 interval->parent = NULL;
180 interval_insert(ctx, &ctx->intervals, interval);
183 /* Call after ir3_reg_interval_remove_temp() to reinsert the interval */
186 struct ir3_reg_interval *interval)
188 interval->parent = NULL;
189 interval_insert(ctx, &ctx->intervals, interval);
194 struct ir3_reg_interval *interval)
196 if (interval->parent) {
197 rb_tree_remove(&interval->parent->children, &interval->node);
199 ctx->interval_delete(ctx, interval);
200 rb_tree_remove(&ctx->intervals, &interval->node);
203 rb_tree_foreach_safe (struct ir3_reg_interval, child, &interval->children,
205 rb_tree_remove(&interval->children, &child->node);
206 child->parent = interval->parent;
208 if (interval->parent) {
212 ctx->interval_readd(ctx, interval, child);
218 interval->inserted = false;
222 _mark_free(struct ir3_reg_interval *interval)
224 interval->inserted = false;
225 rb_tree_foreach (struct ir3_reg_interval, child, &interval->children, node) {
230 /* Remove an interval and all its children from the tree. */
233 struct ir3_reg_interval *interval)
235 assert(!interval->parent);
237 ctx->interval_delete(ctx, interval);
238 rb_tree_remove(&ctx->intervals, &interval->node);
239 _mark_free(interval);
242 /* Used when popping an interval to be shuffled around. Don't disturb children
247 struct ir3_reg_interval *interval)
249 assert(!interval->parent);
251 ctx->interval_delete(ctx, interval);
252 rb_tree_remove(&ctx->intervals, &interval->node);
256 interval_dump(struct log_stream *stream, struct ir3_reg_interval *interval,
261 mesa_log_stream_printf(stream, "reg %u start %u\n", interval->reg->name,
262 interval->reg->interval_start);
264 rb_tree_foreach (struct ir3_reg_interval, child, &interval->children, node) {
270 mesa_log_stream_printf(stream, "reg %u end %u\n", interval->reg->name,
271 interval->reg->interval_end);
275 ir3_reg_interval_dump(struct log_stream *stream, struct ir3_reg_interval *interval)
277 interval_dump(stream, interval, 0);
286 struct ir3_reg_interval interval;
297 /* True if this interval cannot be moved from its position. This is only
344 struct ra_interval *interval;
380 #define foreach_interval(interval, file) \
381 rb_tree_foreach (struct ra_interval, interval, &(file)->physreg_intervals, \
383 #define foreach_interval_rev(interval, file) \
384 rb_tree_foreach (struct ra_interval, interval, &(file)->physreg_intervals, \
386 #define foreach_interval_safe(interval, file) \
387 rb_tree_foreach_safe (struct ra_interval, interval, \
389 #define foreach_interval_rev_safe(interval, file) \
390 rb_tree_foreach_rev_safe(struct ra_interval, interval, \
406 ra_interval_next(struct ra_interval *interval)
408 struct rb_node *next = rb_node_next(&interval->physreg_node);
413 ra_interval_next_or_null(struct ra_interval *interval)
415 return interval ? ra_interval_next(interval) : NULL;
422 const struct ra_interval *interval = rb_node_to_interval_const(node);
423 if (interval->physreg_start > reg)
425 else if (interval->physreg_end <= reg)
438 /* Get the interval covering the reg, or the closest to the right if it
444 struct ra_interval *interval = ra_interval_search_sloppy(tree, reg);
445 if (!interval) {
447 } else if (interval->physreg_end > reg) {
448 return interval;
450 /* There is no interval covering reg, and ra_file_search_sloppy()
451 * returned the closest range to the left, so the next interval to the
454 return ra_interval_next_or_null(interval);
473 interval)
475 return rb_node_data(struct ra_interval, interval, interval);
487 struct ra_interval *interval = ir3_reg_interval_to_ra_interval(_interval);
493 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
498 rb_tree_insert(&file->physreg_intervals, &interval->physreg_node,
505 struct ra_interval *interval = ir3_reg_interval_to_ra_interval(_interval);
508 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
513 rb_tree_remove(&file->physreg_intervals, &interval->physreg_node);
524 parent->physreg_start + (child->interval.reg->interval_start -
525 parent->interval.reg->interval_start);
528 (child->interval.reg->interval_end - child->interval.reg->interval_start);
550 ra_file_insert(struct ra_file *file, struct ra_interval *interval)
552 assert(interval->physreg_start < interval->physreg_end);
553 assert(interval->physreg_end <= file->size);
554 if (interval->interval.reg->flags & IR3_REG_HALF)
555 assert(interval->physreg_end <= RA_HALF_SIZE);
557 ir3_reg_interval_insert(&file->reg_ctx, &interval->interval);
561 ra_file_remove(struct ra_file *file, struct ra_interval *interval)
563 ir3_reg_interval_remove(&file->reg_ctx, &interval->interval);
567 ra_file_mark_killed(struct ra_file *file, struct ra_interval *interval)
569 assert(!interval->interval.parent);
571 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
575 interval->is_killed = true;
579 ra_file_unmark_killed(struct ra_file *file, struct ra_interval *interval)
581 assert(!interval->interval.parent);
583 for (physreg_t i = interval->physreg_start; i < interval->physreg_end; i++) {
587 interval->is_killed = false;
591 ra_interval_get_physreg(const struct ra_interval *interval)
593 unsigned child_start = interval->interval.reg->interval_start;
595 while (interval->interval.parent) {
596 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
599 return interval->physreg_start +
600 (child_start - interval->interval.reg->interval_start);
604 ra_interval_get_num(const struct ra_interval *interval)
606 return ra_physreg_to_num(ra_interval_get_physreg(interval),
607 interval->interval.reg->flags);
611 ra_interval_init(struct ra_interval *interval, struct ir3_register *reg)
613 ir3_reg_interval_init(&interval->interval, reg);
614 interval->is_killed = false;
615 interval->frozen = false;
619 ra_interval_dump(struct log_stream *stream, struct ra_interval *interval)
621 mesa_log_stream_printf(stream, "physreg %u ", interval->physreg_start);
623 ir3_reg_interval_dump(stream, &interval->interval);
629 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
631 ra_interval_dump(stream, interval);
678 struct ra_interval *interval;
684 struct ra_interval *interval)
686 assert(!interval->interval.parent);
692 if (ctx->parallel_copies[pcopy_index].interval == interval)
699 .interval = interval,
700 .src = interval->physreg_start,
704 ir3_reg_interval_remove_temp(&file->reg_ctx, &interval->interval);
707 .interval = interval,
708 .size = interval->physreg_end - interval->physreg_start,
716 struct ra_interval *interval = removed->interval;
718 interval->physreg_start = dst;
719 interval->physreg_end = dst + removed->size;
721 ir3_reg_interval_reinsert(&file->reg_ctx, &interval->interval);
724 /* Pick up the interval and place it at "dst". */
727 struct ra_interval *interval, physreg_t dst)
729 struct ra_removed_interval temp = ra_pop_interval(ctx, file, interval);
784 reg_file_size(file, conflicting->interval.reg);
792 if (!(conflicting->interval.reg->flags & IR3_REG_HALF) &&
826 conflicting->physreg_end > reg_file_size(file, killed->interval.reg))
845 if ((!(killed->interval.reg->flags & IR3_REG_HALF) ||
846 !(conflicting->interval.reg->flags & IR3_REG_HALF)) &&
907 unsigned i1_align = reg_elem_size(i1->interval->interval.reg);
908 unsigned i2_align = reg_elem_size(i2->interval->interval.reg);
915 if (i2->interval->is_killed)
917 if (i1->interval->is_killed)
920 if (i2->interval->is_killed)
922 if (i1->interval->is_killed)
930 * destination register. As there can be gaps when a more-aligned interval
931 * follows a less-aligned interval, this also sorts them to remove such
951 foreach_interval_rev_safe (interval, file) {
958 if (interval->physreg_end + size + removed_size <= file->size &&
960 interval->physreg_end + size + removed_half_size <= file_size)) {
961 start_reg = interval->physreg_end;
968 interval->frozen);
973 if (!interval->is_killed || is_source) {
974 removed_size += interval->physreg_end - interval->physreg_start;
975 if (interval->interval.reg->flags & IR3_REG_HALF) {
976 removed_half_size += interval->physreg_end -
977 interval->physreg_start;
982 d("popping interval %u physreg %u\n", interval->interval.reg->name,
983 interval->physreg_start);
984 array_insert(ctx, intervals, ra_pop_interval(ctx, file, interval));
997 ((intervals[i].interval->is_killed && !is_source) ||
998 !(intervals[i].interval->interval.reg->flags & IR3_REG_HALF))) {
1003 (is_source || !intervals[i].interval->is_killed)) {
1007 if (!(intervals[i].interval->interval.reg->flags & IR3_REG_HALF)) {
1012 reg_file_size(file, intervals[i].interval->interval.reg)) {
1013 d("ran out of room for interval %u!\n",
1014 intervals[i].interval->interval.reg->name);
1019 d("pushing interval %u physreg %u\n",
1020 intervals[i].interval->interval.reg->name, physreg);
1031 d("ran out of room for the new interval!\n");
1216 struct ra_interval *interval = &ctx->intervals[src->def->name];
1218 if (!(src->flags & IR3_REG_FIRST_KILL) || interval->is_killed ||
1219 interval->interval.parent ||
1220 !rb_tree_is_empty(&interval->interval.children))
1223 ra_file_mark_killed(ra_get_file(ctx, src), interval);
1230 struct ra_interval *interval = &ctx->intervals[dst->name];
1232 d("insert dst %u physreg %u", dst->name, ra_interval_get_physreg(interval));
1235 ra_file_insert(file, interval);
1237 assign_reg(dst->instr, dst, ra_interval_get_num(interval));
1245 struct ra_interval *interval = &ctx->intervals[dst->name];
1248 ra_interval_init(interval, dst);
1249 interval->physreg_start = physreg;
1250 interval->physreg_end = physreg + reg_size(dst);
1278 .interval = dst_interval,
1296 struct ra_interval *interval = &ctx->intervals[src->def->name];
1305 physreg = ra_interval_get_physreg(interval);
1311 ra_file_remove(file, interval);
1331 entry->interval->interval.reg->flags & ~IR3_REG_SSA);
1332 reg->size = entry->interval->interval.reg->size;
1333 reg->wrmask = entry->interval->interval.reg->wrmask;
1334 assign_reg(pcopy, reg, ra_interval_get_num(entry->interval));
1341 entry->interval->interval.reg->flags & ~IR3_REG_SSA);
1342 reg->size = entry->interval->interval.reg->size;
1343 reg->wrmask = entry->interval->interval.reg->wrmask;
1413 /* We need to check if any of the sources are contained in an interval
1415 * the vector inside that larger interval. (There should be one
1435 struct ra_interval *interval = &ctx->intervals[src->def->name];
1437 if (src->def->merge_set != dst_set || interval->is_killed)
1439 while (interval->interval.parent != NULL) {
1440 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
1442 if (reg_size(interval->interval.reg) >= reg_size(instr->dsts[0])) {
1443 dst_fixed = interval->physreg_start -
1444 interval->interval.reg->merge_set_offset + dst_offset;
1446 /* For sources whose root interval is smaller than the
1452 interval);
1463 struct ra_interval *interval = &ctx->intervals[src->def->name];
1464 while (interval->interval.parent != NULL) {
1465 interval = ir3_reg_interval_to_ra_interval(interval->interval.parent);
1469 if (interval != &ctx->intervals[src->def->name] ||
1471 ra_file_unmark_killed(ra_get_file(ctx, src), interval);
1523 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1527 interval->frozen = true;
1539 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1540 ra_file_insert(file, interval);
1546 struct ra_interval *interval = &ctx->intervals[instr->dsts[0]->name];
1550 assign_reg(instr, instr->dsts[0], ra_interval_get_num(interval));
1552 interval->frozen = false;
1556 ra_file_remove(file, interval);
1582 struct ra_interval *interval = &ctx->intervals[src->def->name];
1585 if (ra_interval_get_num(interval) == src->num)
1601 ra_move_interval(ctx, file, interval, physreg);
1619 struct ra_interval *interval = &ctx->intervals[src->def->name];
1621 ra_file_remove(file, interval);
1659 struct ra_interval *interval = &ctx->intervals[def->name];
1661 ra_interval_init(interval, def);
1662 interval->physreg_start = physreg;
1663 interval->physreg_end = physreg + reg_size(def);
1664 ra_file_insert(file, interval);
1678 struct ra_interval *interval = &ctx->intervals[def->name];
1679 physreg_t physreg = ra_interval_get_physreg(interval);
1691 struct ra_interval *interval = &ctx->intervals[def->name];
1710 ra_file_insert(file, interval);
1717 struct ra_interval *interval = &ctx->intervals[phi->dsts[0]->name];
1718 assert(!interval->interval.parent);
1719 unsigned num = ra_interval_get_num(interval);
1731 ra_file_remove(file, interval);
1798 insert_live_in_move(struct ra_ctx *ctx, struct ra_interval *interval)
1800 physreg_t physreg = ra_interval_get_physreg(interval);
1802 bool shared = interval->interval.reg->flags & IR3_REG_SHARED;
1816 physreg_t pred_reg = read_register(ctx, pred, interval->interval.reg);
1818 insert_liveout_copy(pred, physreg, pred_reg, interval->interval.reg);
1838 _mesa_hash_table_insert(pred_state->renames, interval->interval.reg,
1848 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
1854 if (BITSET_TEST(live_in, interval->interval.reg->name))
1855 insert_live_in_move(ctx, interval);
1862 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
1864 _mesa_hash_table_insert(state->entry_regs, interval->interval.reg,
1865 (void *)(uintptr_t)interval->physreg_start);
1898 insert_live_out_move(struct ra_ctx *ctx, struct ra_interval *interval)
1911 succ_state->entry_regs, interval->interval.reg);
1916 if (new_reg != interval->physreg_start) {
1917 insert_liveout_copy(ctx->block, new_reg, interval
1918 interval->interval.reg);
1926 rb_tree_foreach (struct ra_interval, interval, &file->physreg_intervals,
1928 insert_live_out_move(ctx, interval);
1987 /* After this point, every live-in/phi/input has an interval assigned to
2077 dummy_interval_add(struct ir3_reg_ctx *ctx, struct ir3_reg_interval *interval)
2082 dummy_interval_delete(struct ir3_reg_ctx *ctx, struct ir3_reg_interval *interval)
2180 struct ir3_reg_interval *interval = &intervals[src->def->name];
2181 while (interval->parent)
2182 interval = interval->parent;
2183 add_pressure(&cur_pressure, interval->reg, v->mergedregs);
Indexes created Thu Jul 02 00:25:40 UTC 2026