struct fixup_replacement *next;
};
-struct insns_for_mem_entry {
+struct insns_for_mem_entry
+{
/* The KEY in HE will be a MEM. */
struct hash_entry he;
/* These are the INSNS which reference the MEM. */
static bool insns_for_mem_comp PARAMS ((hash_table_key, hash_table_key));
static int insns_for_mem_walk PARAMS ((rtx *, void *));
static void compute_insns_for_mem PARAMS ((rtx, rtx, struct hash_table *));
-static void mark_temp_slot PARAMS ((struct temp_slot *));
static void mark_function_status PARAMS ((struct function *));
static void maybe_mark_struct_function PARAMS ((void *));
static void prepare_function_start PARAMS ((void));
{
struct function *p = outer_function_chain;
struct var_refs_queue *queue;
- struct var_refs_queue *next;
cfun = p;
outer_function_chain = p->outer;
/* Finish doing put_var_into_stack for any of our variables
which became addressable during the nested function. */
- for (queue = p->fixup_var_refs_queue; queue; queue = next)
- {
- next = queue->next;
- fixup_var_refs (queue->modified, queue->promoted_mode,
- queue->unsignedp, 0);
- free (queue);
- }
+ for (queue = p->fixup_var_refs_queue; queue; queue = queue->next)
+ fixup_var_refs (queue->modified, queue->promoted_mode,
+ queue->unsignedp, 0);
+
p->fixup_var_refs_queue = 0;
/* Reset variables that have known state during rtx generation. */
free_after_compilation (f)
struct function *f;
{
- struct temp_slot *ts;
- struct temp_slot *next;
-
free_eh_status (f);
free_expr_status (f);
free_emit_status (f);
if (f->x_parm_reg_stack_loc)
free (f->x_parm_reg_stack_loc);
- for (ts = f->x_temp_slots; ts; ts = next)
- {
- next = ts->next;
- free (ts);
- }
f->x_temp_slots = NULL;
-
f->arg_offset_rtx = NULL;
f->return_rtx = NULL;
f->internal_arg_pointer = NULL;
f->original_decl_initial = NULL;
f->inl_last_parm_insn = NULL;
f->epilogue_delay_list = NULL;
-
- free (f);
}
\f
/* Allocate fixed slots in the stack frame of the current function. */
if (best_p->size - rounded_size >= alignment)
{
- p = (struct temp_slot *) xmalloc (sizeof (struct temp_slot));
+ p = (struct temp_slot *) ggc_alloc (sizeof (struct temp_slot));
p->in_use = p->addr_taken = 0;
p->size = best_p->size - rounded_size;
p->base_offset = best_p->base_offset + rounded_size;
{
HOST_WIDE_INT frame_offset_old = frame_offset;
- p = (struct temp_slot *) xmalloc (sizeof (struct temp_slot));
+ p = (struct temp_slot *) ggc_alloc (sizeof (struct temp_slot));
/* We are passing an explicit alignment request to assign_stack_local.
One side effect of that is assign_stack_local will not round SIZE
}
/* Either delete Q or advance past it. */
if (delete_q)
- {
- prev_q->next = q->next;
- free (q);
- }
+ prev_q->next = q->next;
else
prev_q = q;
}
struct var_refs_queue *temp;
temp
- = (struct var_refs_queue *) xmalloc (sizeof (struct var_refs_queue));
+ = (struct var_refs_queue *) ggc_alloc (sizeof (struct var_refs_queue));
temp->modified = reg;
temp->promoted_mode = promoted_mode;
temp->unsignedp = unsigned_p;
N.B. No need for special processing of CALL_PLACEHOLDERs here,
because the hash table will point straight to the interesting insn
(inside the CALL_PLACEHOLDER). */
+
static void
fixup_var_refs_insns_with_hash (ht, var, promoted_mode, unsignedp)
struct hash_table *ht;
references to, PROMOTED_MODE and UNSIGNEDP describe VAR, and
TOPLEVEL is nonzero if this is the main insn chain for this
function. */
+
static void
fixup_var_refs_insn (insn, var, promoted_mode, unsignedp, toplevel)
rtx insn;
return k1 == k2;
}
-struct insns_for_mem_walk_info {
+struct insns_for_mem_walk_info
+{
/* The hash table that we are using to record which INSNs use which
MEMs. */
struct hash_table *ht;
}
\f
/* Allocate a function structure and reset its contents to the defaults. */
+
static void
prepare_function_start ()
{
- cfun = (struct function *) xcalloc (1, sizeof (struct function));
+ cfun = (struct function *) ggc_alloc_cleared (sizeof (struct function));
init_stmt_for_function ();
init_eh_for_function ();
#endif /* HAVE_prologue or HAVE_epilogue */
}
-/* Mark T for GC. */
-
-static void
-mark_temp_slot (t)
- struct temp_slot *t;
-{
- while (t)
- {
- ggc_mark_rtx (t->slot);
- ggc_mark_rtx (t->address);
- ggc_mark_tree (t->rtl_expr);
- ggc_mark_tree (t->type);
-
- t = t->next;
- }
-}
-
/* Mark P for GC. */
static void
mark_function_status (p)
struct function *p;
{
+ struct var_refs_queue *q;
+ struct temp_slot *t;
int i;
rtx *r;
ggc_mark_rtx (p->epilogue_delay_list);
ggc_mark_rtx (p->x_clobber_return_insn);
- mark_temp_slot (p->x_temp_slots);
+ for (t = p->x_temp_slots; t != 0; t = t->next)
+ {
+ ggc_mark (t);
+ ggc_mark_rtx (t->slot);
+ ggc_mark_rtx (t->address);
+ ggc_mark_tree (t->rtl_expr);
+ ggc_mark_tree (t->type);
+ }
- {
- struct var_refs_queue *q = p->fixup_var_refs_queue;
- while (q)
- {
- ggc_mark_rtx (q->modified);
- q = q->next;
+ for (q = p->fixup_var_refs_queue; q != 0; q = q->next)
+ {
+ ggc_mark (q);
+ ggc_mark_rtx (q->modified);
}
- }
ggc_mark_rtx (p->x_nonlocal_goto_handler_slots);
ggc_mark_rtx (p->x_nonlocal_goto_handler_labels);
/* Mark the struct function pointed to by *ARG for GC, if it is not
NULL. This is used to mark the current function and the outer
function chain. */
+
static void
maybe_mark_struct_function (arg)
void *arg;
}
/* Mark a struct function * for GC. This is called from ggc-common.c. */
+
void
ggc_mark_struct_function (f)
struct function *f;
{
+ ggc_mark (f);
ggc_mark_tree (f->decl);
mark_function_status (f);
OSDN Git Service
