Lines Matching defs:reg
54 unsigned reg = *(const unsigned *)data;
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
90 } else if (interval->reg->interval_end > offset) {
93 /* There is no interval covering reg, and ra_file_search_sloppy()
106 return b->reg->interval_start - a->reg->interval_start;
114 ir3_reg_interval_search_right(tree, interval->reg->interval_start);
115 if (right && right->reg->interval_start < interval->reg->interval_end) {
128 * has been bitcasted as a half-reg? Would that element alone have to
129 * be small enough to be used as a half-reg source? Let's keep that
132 assert((interval->reg->flags & IR3_REG_HALF) ==
133 (right->reg->flags & IR3_REG_HALF));
135 if (right->reg->interval_end <= interval->reg->interval_end &&
136 right->reg->interval_start >= interval->reg->interval_start) {
144 right && right->reg->interval_start < interval->reg->interval_end;
147 assert(right->reg->interval_end <= interval->reg->interval_end);
148 assert((interval->reg->flags & IR3_REG_HALF) ==
149 (right->reg->flags & IR3_REG_HALF));
161 assert(right->reg->interval_start <= interval->reg->interval_start);
261 mesa_log_stream_printf(stream, "reg %u start %u\n", interval->reg->name,
262 interval->reg->interval_start);
270 mesa_log_stream_printf(stream, "reg %u end %u\n", interval->reg->name,
271 interval->reg->interval_end);
421 physreg_t reg = *(const physreg_t *)data;
423 if (interval->physreg_start > reg)
425 else if (interval->physreg_end <= reg)
432 ra_interval_search_sloppy(struct rb_tree *tree, physreg_t reg)
434 struct rb_node *node = rb_tree_search_sloppy(tree, ®, ra_interval_cmp);
438 /* Get the interval covering the reg, or the closest to the right if it
442 ra_interval_search_right(struct rb_tree *tree, physreg_t reg)
444 struct ra_interval *interval = ra_interval_search_sloppy(tree, reg);
447 } else if (interval->physreg_end > reg) {
450 /* There is no interval covering reg, and ra_file_search_sloppy()
459 ra_file_search_right(struct ra_file *file, physreg_t reg)
461 return ra_interval_search_right(&file->physreg_intervals, reg);
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);
554 if (interval->interval.reg->flags & IR3_REG_HALF)
593 unsigned child_start = interval->interval.reg->interval_start;
600 (child_start - interval->interval.reg->interval_start);
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);
663 reg_file_size(struct ra_file *file, struct ir3_register *reg)
666 if (reg->flags & IR3_REG_HALF)
688 /* Check if we've already moved this reg before */
722 if (interval->interval.reg->flags & IR3_REG_HALF)
738 ra_get_file(struct ra_ctx *ctx, struct ir3_register *reg)
740 if (reg->flags & IR3_REG_SHARED)
742 else if (ctx->merged_regs || !(reg->flags & IR3_REG_HALF))
787 is_early_clobber(struct ir3_register *reg)
789 return (reg->flags & IR3_REG_EARLY_CLOBBER) || reg->tied;
794 struct ir3_register *reg, physreg_t physreg, bool is_source)
796 for (unsigned i = 0; i < reg_size(reg); i++) {
797 if (!BITSET_TEST(is_early_clobber(reg) || is_source ?
804 check_dst_overlap(ctx, file, reg, physreg, physreg + reg_size(reg)))
811 * "reg". That is, move them to other places so that we can allocate "physreg"
817 struct ir3_register *reg, physreg_t physreg,
827 for (unsigned i = 0; i < reg_size(reg); i++) {
837 conflicting->physreg_start < physreg + reg_size(reg);
839 if (!is_early_clobber(reg) && !is_source && conflicting->is_killed)
848 reg_file_size(file, conflicting->interval.reg);
856 if (!(conflicting->interval.reg->flags & IR3_REG_HALF) &&
865 !check_dst_overlap(ctx, file, reg, avail_start, avail_start +
894 conflicting->physreg_end > reg_file_size(file, killed->interval.reg))
912 if (check_dst_overlap(ctx, file, reg, killed->physreg_start,
916 /* Check for alignment if one is a full reg */
917 if ((!(killed->interval.reg->flags & IR3_REG_HALF) ||
918 !(conflicting->interval.reg->flags & IR3_REG_HALF)) &&
980 unsigned i1_align = reg_elem_size(i1->interval->interval.reg);
981 unsigned i2_align = reg_elem_size(i2->interval->interval.reg);
1044 struct ir3_register *reg)
1046 unsigned align = reg_elem_size(reg);
1054 array_insert(ctx, dsts, reg);
1055 bool dst_inserted[reg->instr->dsts_count];
1057 unsigned dst_size = reg->tied ? 0 : reg_size(reg);
1058 unsigned ec_dst_size = is_early_clobber(reg) ? reg_size(reg) : 0;
1076 ra_foreach_dst_n (other_dst, n, reg->instr) {
1077 if (other_dst == reg)
1108 other_interval->interval.reg->name,
1115 if (other_interval->interval.reg->flags & IR3_REG_HALF)
1119 if (other_interval->interval.reg->flags & IR3_REG_HALF)
1151 if (interval->interval.reg->flags & IR3_REG_HALF)
1155 if (interval->interval.reg->flags & IR3_REG_HALF)
1160 d("popping interval %u physreg %u%s\n", interval->interval.reg->name,
1191 bool live_half = live_interval->interval.reg->flags & IR3_REG_HALF;
1220 intervals[live_index].interval->interval.reg;
1241 d("pushing reg %u physreg %u\n", cur_reg->name, physreg);
1248 unreachable("reg pressure calculation was wrong!");
1253 if (cur_reg == reg) {
1278 ra_foreach_dst (dst, reg->instr) {
1279 if (dst == reg)
1300 update_affinity(struct ra_file *file, struct ir3_register *reg,
1303 if (!reg->merge_set || reg->merge_set->preferred_reg != (physreg_t)~0)
1306 if (physreg < reg->merge_set_offset)
1309 if ((physreg - reg->merge_set_offset + reg->merge_set->size) > file->size)
1312 reg->merge_set->preferred_reg = physreg - reg->merge_set_offset;
1362 * for "reg", shuffling around sources if necessary. In the normal case where
1371 get_reg(struct ra_ctx *ctx, struct ra_file *file, struct ir3_register *reg)
1373 unsigned file_size = reg_file_size(file, reg);
1374 if (reg->merge_set && reg->merge_set->preferred_reg != (physreg_t)~0) {
1376 reg->merge_set->preferred_reg + reg->merge_set_offset;
1377 if (preferred_reg + reg_size(reg) <= file_size &&
1378 preferred_reg % reg_elem_size(reg) == 0 &&
1379 get_reg_specified(ctx, file, reg, preferred_reg, false))
1387 unsigned size = reg_size(reg);
1388 if (reg->merge_set && reg->merge_set->preferred_reg == (physreg_t)~0 &&
1389 size < reg->merge_set->size) {
1390 physreg_t best_reg = find_best_gap(ctx, file, reg, file_size,
1391 reg->merge_set->size,
1392 reg->merge_set->alignment);
1394 best_reg += reg->merge_set_offset;
1399 /* For ALU and SFU instructions, if the src reg is avail to pick, use it.
1404 if (is_sfu(reg->instr) || is_alu(reg->instr)) {
1405 for (unsigned i = 0; i < reg->instr->srcs_count; i++) {
1406 struct ir3_register *src = reg->instr->srcs[i];
1412 if (src_physreg % reg_elem_size(reg) == 0 &&
1414 get_reg_specified(ctx, file, reg, src_physreg, false))
1421 find_best_gap(ctx, file, reg, file_size, size, reg_elem_size(reg));
1431 for (physreg_t i = 0; i + size <= file_size; i += reg_elem_size(reg)) {
1433 if (try_evict_regs(ctx, file, reg, i, &eviction_count, false, true)) {
1443 ctx, file, reg, best_reg, &best_eviction_count, false, false);
1449 return compress_regs_left(ctx, file, reg);
1453 assign_reg(struct ir3_instruction *instr, struct ir3_register *reg,
1456 if (reg->flags & IR3_REG_ARRAY) {
1457 reg->array.base = num;
1458 if (reg->flags & IR3_REG_RELATIV)
1459 reg->array.offset += num;
1461 reg->num = num + reg->array.offset;
1463 reg->num = num;
1599 struct ir3_register *reg =
1601 entry->interval->interval.reg->flags &
1603 reg->size = entry->interval->interval.reg->size;
1604 reg->wrmask = entry->interval->interval.reg->wrmask;
1605 assign_reg(pcopy, reg, ra_interval_get_num(entry->interval));
1610 struct ir3_register *reg =
1612 entry->interval->interval.reg->flags &
1614 reg->size = entry->interval->interval.reg->size;
1615 reg->wrmask = entry->interval->interval.reg->wrmask;
1616 assign_reg(pcopy, reg, ra_physreg_to_num(entry->src, reg->flags));
1719 if (reg_size(interval->interval.reg) >= reg_size(instr->dsts[0])) {
1721 interval->interval.reg->merge_set_offset + dst_offset;
1985 (def->interval_start - parent_ir3->reg->interval_start);
2040 struct ir3_register *reg)
2059 unsigned flags = reg->flags & (IR3_REG_HALF | IR3_REG_ARRAY);
2062 dst_reg->wrmask = reg->wrmask;
2063 dst_reg->size = reg->size;
2064 assign_reg(pcopy, dst_reg, ra_physreg_to_num(dst, reg->flags));
2071 src_reg->wrmask = reg->wrmask;
2072 src_reg->size = reg->size;
2073 assign_reg(pcopy, src_reg, ra_physreg_to_num(src, reg->flags));
2084 bool shared = interval->interval.reg->flags & IR3_REG_SHARED;
2098 physreg_t pred_reg = read_register(ctx, pred, interval->interval.reg);
2100 insert_liveout_copy(pred, physreg, pred_reg, interval->interval.reg);
2120 _mesa_hash_table_insert(pred_state->renames, interval->interval.reg,
2136 if (BITSET_TEST(live_in, interval->interval.reg->name))
2146 _mesa_hash_table_insert(state->entry_regs, interval->interval.reg,
2193 succ_state->entry_regs, interval->interval.reg);
2200 interval->interval.reg);
2255 struct ir3_register *reg = ctx->live->definitions[name];
2256 handle_live_in(ctx, reg);
2313 struct ir3_register *reg = ctx->live->definitions[name];
2314 handle_live_out(ctx, reg);
2348 add_pressure(struct ir3_pressure *pressure, struct ir3_register *reg,
2351 unsigned size = reg_size(reg);
2352 if (reg->flags & IR3_REG_HALF)
2354 if (!(reg->flags & IR3_REG_HALF) || merged_regs)
2428 struct ir3_register *reg = live->definitions[name];
2429 ir3_reg_interval_init(&intervals[reg->name], reg);
2430 ir3_reg_interval_insert(ctx, &intervals[reg->name]);
2465 add_pressure(&cur_pressure, interval->reg, v->mergedregs);
2590 /* TODO shared reg -> normal reg spilling */
2642 * an array whose size is determined by reg->size. So keep the array