void et_free_tree_force (struct et_node *t) { et_occurrences.remove (t->rightmost_occ); if (t->parent_occ) et_occurrences.remove (t->parent_occ); et_nodes.remove (t); }
void et_free_tree (struct et_node *t) { while (t->son) et_split (t->son); if (t->father) et_split (t); et_occurrences.remove (t->rightmost_occ); et_nodes.remove (t); }
/* Create and return pseudo live range with given attributes. */ static lra_live_range_t create_live_range (int regno, int start, int finish, lra_live_range_t next) { lra_live_range_t p = lra_live_range_pool.allocate (); p->regno = regno; p->start = start; p->finish = finish; p->next = next; return p; }
/* Free live range list LR. */ static void free_live_range_list (lra_live_range_t lr) { lra_live_range_t next; while (lr != NULL) { next = lr->next; lra_live_range_pool.remove (lr); lr = next; } }
/* Merge *non-intersected* ranges R1 and R2 and returns the result. The function maintains the order of ranges and tries to minimize size of the result range list. Ranges R1 and R2 may not be used after the call. */ lra_live_range_t lra_merge_live_ranges (lra_live_range_t r1, lra_live_range_t r2) { lra_live_range_t first, last; if (r1 == NULL) return r2; if (r2 == NULL) return r1; for (first = last = NULL; r1 != NULL && r2 != NULL;) { if (r1->start < r2->start) std::swap (r1, r2); if (r1->start == r2->finish + 1) { /* Joint ranges: merge r1 and r2 into r1. */ r1->start = r2->start; lra_live_range_t temp = r2; r2 = r2->next; lra_live_range_pool.remove (temp); } else { gcc_assert (r2->finish + 1 < r1->start); /* Add r1 to the result. */ if (first == NULL) first = last = r1; else { last->next = r1; last = r1; } r1 = r1->next; } } if (r1 != NULL) { if (first == NULL) first = r1; else last->next = r1; } else { lra_assert (r2 != NULL); if (first == NULL) first = r2; else last->next = r2; } return first; }
void et_split (struct et_node *t) { struct et_node *father = t->father; struct et_occ *r, *l, *rmost, *p_occ; /* Update the path represented by the splay tree. */ rmost = t->rightmost_occ; et_splay (rmost); for (r = rmost->next; r->prev; r = r->prev) continue; et_splay (r); r->prev->parent = NULL; p_occ = t->parent_occ; et_splay (p_occ); t->parent_occ = NULL; l = p_occ->prev; p_occ->next->parent = NULL; set_prev (r, l); et_recomp_min (r); et_splay (rmost); rmost->depth = 0; rmost->min = 0; et_occurrences.remove (p_occ); /* Update the tree. */ if (father->son == t) father->son = t->right; if (father->son == t) father->son = NULL; else { t->left->right = t->right; t->right->left = t->left; } t->left = t->right = NULL; t->father = NULL; #ifdef DEBUG_ET et_check_tree_sanity (rmost); record_path_before (rmost); et_check_tree_sanity (r); record_path_before (r); #endif }
static void free_debug_insn_changes (struct value_data *vd, unsigned int regno) { struct queued_debug_insn_change *cur, *next; for (cur = vd->e[regno].debug_insn_changes; cur; cur = next) { next = cur->next; --vd->n_debug_insn_changes; queued_debug_insn_change_pool.remove (cur); } vd->e[regno].debug_insn_changes = NULL; }
struct et_node * et_new_tree (void *data) { et_node *nw = et_nodes.allocate (); nw->data = data; nw->father = NULL; nw->left = NULL; nw->right = NULL; nw->son = NULL; nw->rightmost_occ = et_new_occ (nw); nw->parent_occ = NULL; return nw; }
static struct et_occ * et_new_occ (struct et_node *node) { et_occ *nw = et_occurrences.allocate (); nw->of = node; nw->parent = NULL; nw->prev = NULL; nw->next = NULL; nw->depth = 0; nw->min_occ = nw; nw->min = 0; return nw; }
void et_free_pools (void) { et_occurrences.release_if_empty (); et_nodes.release_if_empty (); }