Lines Matching refs:regs
91 struct ra_reg *regs;
106 BITSET_WORD *regs;
111 * This is "how many regs are in the set."
161 struct ra_regs *regs;
177 unsigned int (*select_reg_callback)(struct ra_graph *g, BITSET_WORD *regs,
192 struct ra_regs *regs;
194 regs = rzalloc(mem_ctx, struct ra_regs);
195 regs->count = count;
196 regs->regs = rzalloc_array(regs, struct ra_reg, count);
199 regs->regs[i].conflicts = rzalloc_array(regs->regs, BITSET_WORD,
201 BITSET_SET(regs->regs[i].conflicts, i);
204 regs->regs[i].conflict_list = ralloc_array(regs->regs,
206 regs->regs[i].conflict_list_size = 4;
207 regs->regs[i].conflict_list[0] = i;
209 regs->regs[i].conflict_list = NULL;
210 regs->regs[i].conflict_list_size = 0;
212 regs->regs[i].num_conflicts = 1;
215 return regs;
229 ra_set_allocate_round_robin(struct ra_regs *regs)
231 regs->round_robin = true;
235 ra_add_conflict_list(struct ra_regs *regs, unsigned int r1, unsigned int r2)
237 struct ra_reg *reg1 = ®s->regs[r1];
242 reg1->conflict_list = reralloc(regs->regs, reg1->conflict_list,
251 ra_add_reg_conflict(struct ra_regs *regs, unsigned int r1, unsigned int r2)
253 if (!BITSET_TEST(regs->regs[r1].conflicts, r2)) {
254 ra_add_conflict_list(regs, r1, r2);
255 ra_add_conflict_list(regs, r2, r1);
268 ra_add_transitive_reg_conflict(struct ra_regs *regs,
273 ra_add_reg_conflict(regs, reg, base_reg);
275 for (i = 0; i < regs->regs[base_reg].num_conflicts; i++) {
276 ra_add_reg_conflict(regs, reg, regs->regs[base_reg].conflict_list[i]);
290 ra_make_reg_conflicts_transitive(struct ra_regs *regs, unsigned int r)
292 struct ra_reg *reg = ®s->regs[r];
296 BITSET_FOREACH_SET(c, tmp, reg->conflicts, regs->count) {
297 struct ra_reg *other = ®s->regs[c];
299 for (i = 0; i < BITSET_WORDS(regs->count); i++)
305 ra_alloc_reg_class(struct ra_regs *regs)
309 regs->classes = reralloc(regs->regs, regs->classes, struct ra_class *,
310 regs->class_count + 1);
312 class = rzalloc(regs, struct ra_class);
313 regs->classes[regs->class_count] = class;
315 class->regs = rzalloc_array(class, BITSET_WORD, BITSET_WORDS(regs->count));
317 return regs->class_count++;
321 ra_class_add_reg(struct ra_regs *regs, unsigned int c, unsigned int r)
323 struct ra_class *class = regs->classes[c];
325 BITSET_SET(class->regs, r);
335 return BITSET_TEST(c->regs, r);
345 ra_set_finalize(struct ra_regs *regs, unsigned int **q_values)
349 for (b = 0; b < regs->class_count; b++) {
350 regs->classes[b]->q = ralloc_array(regs, unsigned int, regs->class_count);
354 for (b = 0; b < regs->class_count; b++) {
355 for (c = 0; c < regs->class_count; c++) {
356 regs->classes[b]->q[c] = q_values[b][c];
360 /* Compute, for each class B and C, how many regs of B an
363 for (b = 0; b < regs->class_count; b++) {
364 for (c = 0; c < regs->class_count; c++) {
368 for (rc = 0; rc < regs->count; rc++) {
372 if (!reg_belongs_to_class(rc, regs->classes[c]))
375 for (i = 0; i < regs->regs[rc].num_conflicts; i++) {
376 unsigned int rb = regs->regs[rc].conflict_list[i];
377 if (reg_belongs_to_class(rb, regs->classes[b]))
382 regs->classes[b]->q[c] = max_conflicts;
387 for (b = 0; b < regs->count; b++) {
388 ralloc_free(regs->regs[b].conflict_list);
389 regs->regs[b].conflict_list = NULL;
402 g->nodes[n1].q_total += g->regs->classes[n1_class]->q[n2_class];
417 ra_alloc_interference_graph(struct ra_regs *regs, unsigned int count)
423 g->regs = regs;
447 BITSET_WORD *regs,
477 return g->nodes[n].q_total < g->regs->classes[n_class]->p;
491 assert(g->nodes[n2].q_total >= g->regs->classes[n2_class]->q[n_class]);
492 g->nodes[n2].q_total -= g->regs->classes[n2_class]->q[n_class];
563 BITSET_TEST(g->regs->regs[r].conflicts, g->nodes[n2].reg)) {
571 /* Computes a bitfield of what regs are available for a given register
578 ra_compute_available_regs(struct ra_graph *g, unsigned int n, BITSET_WORD *regs)
580 struct ra_class *c = g->regs->classes[g->nodes[n].class];
582 /* Populate with the set of regs that are in the node's class. */
583 memcpy(regs, c->regs, BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
585 /* Remove any regs that conflict with nodes that we're adjacent to and have
593 for (int j = 0; j < BITSET_WORDS(g->regs->count); j++)
594 regs[j] &= ~g->regs->regs[r].conflicts[j];
598 for (int i = 0; i < BITSET_WORDS(g->regs->count); i++) {
599 if (regs[i])
620 select_regs = malloc(BITSET_WORDS(g->regs->count) * sizeof(BITSET_WORD));
626 struct ra_class *c = g->regs->classes[g->nodes[n].class];
644 for (ri = 0; ri < g->regs->count; ri++) {
645 r = (start_search_reg + ri) % g->regs->count;
653 if (ri >= g->regs->count)
669 if (g->regs->round_robin &&
727 benefit += ((float)g->regs->classes[n_class]->q[n2_class] /
728 g->regs->classes[n_class]->p);