static inline void bitmap_element_free (bitmap head, bitmap_element *elt) { bitmap_element *next = elt->next; bitmap_element *prev = elt->prev; if (prev) prev->next = next; if (next) next->prev = prev; if (head->first == elt) head->first = next; /* Since the first thing we try is to insert before current, make current the next entry in preference to the previous. */ if (head->current == elt) { head->current = next != 0 ? next : prev; if (head->current) head->indx = head->current->indx; else head->indx = 0; } if (GATHER_STATISTICS) register_overhead (head, -((int)sizeof (bitmap_element))); bitmap_elem_to_freelist (head, elt); }
static void * vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, bool exact MEM_STAT_DECL) { struct vec_prefix *pfx = (struct vec_prefix *) vec; unsigned alloc = calculate_allocation (pfx, reserve, exact); if (!alloc) { if (pfx) vec_heap_free (pfx); return NULL; } #ifdef GATHER_STATISTICS if (vec) free_overhead (pfx); #endif vec = xrealloc (vec, vec_offset + alloc * elt_size); ((struct vec_prefix *)vec)->alloc = alloc; if (!pfx) ((struct vec_prefix *)vec)->num = 0; #ifdef GATHER_STATISTICS if (vec) register_overhead ((struct vec_prefix *)vec, vec_offset + alloc * elt_size PASS_MEM_STAT); #endif return vec; }
static inline bitmap_element * bitmap_element_allocate (bitmap head) { bitmap_element *element; bitmap_obstack *bit_obstack = head->obstack; if (bit_obstack) { element = bit_obstack->elements; if (element) /* Use up the inner list first before looking at the next element of the outer list. */ if (element->next) { bit_obstack->elements = element->next; bit_obstack->elements->prev = element->prev; } else /* Inner list was just a singleton. */ bit_obstack->elements = element->prev; else element = XOBNEW (&bit_obstack->obstack, bitmap_element); } else { element = bitmap_ggc_free; if (element) /* Use up the inner list first before looking at the next element of the outer list. */ if (element->next) { bitmap_ggc_free = element->next; bitmap_ggc_free->prev = element->prev; } else /* Inner list was just a singleton. */ bitmap_ggc_free = element->prev; else element = ggc_alloc<bitmap_element> (); } if (GATHER_STATISTICS) register_overhead (head, sizeof (bitmap_element)); memset (element->bits, 0, sizeof (element->bits)); return element; }
void bitmap_elt_clear_from (bitmap head, bitmap_element *elt) { bitmap_element *prev; bitmap_obstack *bit_obstack = head->obstack; if (!elt) return; if (GATHER_STATISTICS) { int n = 0; for (prev = elt; prev; prev = prev->next) n++; register_overhead (head, -sizeof (bitmap_element) * n); } prev = elt->prev; if (prev) { prev->next = NULL; if (head->current->indx > prev->indx) { head->current = prev; head->indx = prev->indx; } } else { head->first = NULL; head->current = NULL; head->indx = 0; } /* Put the entire list onto the free list in one operation. */ if (bit_obstack) { elt->prev = bit_obstack->elements; bit_obstack->elements = elt; } else { elt->prev = bitmap_ggc_free; bitmap_ggc_free = elt; } }