* gimple.c (gt_ggc_mx (gimple)): New, as required by GTY((user)).
(gt_pch_nx (gimple)): Likewise.
(gt_pch_nx (gimple, gt_pointer_operator, void *)): Likewise.
* gimple.h (gt_ggc_mx (gimple)): Declare.
(gt_pch_nx (gimple)): Declare.
(gt_pch_nx (gimple, gt_pointer_operator, void *)): Declare.
* tree-cfg.c (ggc_mx (gimple&)): Remove declaration, as this
collides with the function that GTY((user)) expects.
(gt_ggc_mx (edge_def *)): Replace call to gt_ggc_mx on the
gimple with gt_ggc_mx_gimple_statement_base: in the
pre-GTY((user)) world, "gt_ggc_mx" was the function to be called
on a possibly NULL pointed to check if needed marking and if so
to traverse its fields. In the GTY((user)) world, "gt_ggc_mx"
is the function to be called on non-NULL objects immediately *after*
they have been marked: it does not mark the object itself.
(gt_pch_nx (gimple&)): Remove declaration.
(gt_pch_nx (edge_def *)): Update as per the mx hook.
---
gcc/gimple.c | 743 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
gcc/gimple.h | 6 +
gcc/tree-cfg.c | 6 +-
3 files changed, 751 insertions(+), 4 deletions(-)
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 1ad36d1..dd99cda 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -4338,4 +4338,747 @@ build_type_cast (tree to_type, gimple op, enum ssa_mode
mode)
return build_type_cast (to_type, gimple_assign_lhs (op), mode);
}
+void
+gt_ggc_mx (gimple gs)
+{
+ gimple x = gs;
+ /* Emulation of the "chain_next" GTY attribute.
+
+ gs has already been marked.
+ Iterate the chain of next statements, marking until we reach one that
+ has already been marked, or NULL. */
+ gimple xlimit = gs->next;
+ while (ggc_test_and_set_mark (xlimit))
+ xlimit = xlimit->next;
+
+ /* All of the statements within the half-open interval [x..xlimit) have
+ just been marked. Iterate through the list, visiting their fields. */
+ while (x != xlimit)
+ {
+ gt_ggc_m_15basic_block_def (x->bb);
+ switch (gimple_statement_structure (&((*x))))
+ {
+ case GSS_BASE:
+ break;
+ case GSS_WITH_OPS:
+ {
+ gimple_statement_with_ops *stmt
+ = static_cast <gimple_statement_with_ops *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_ggc_m_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_WITH_MEM_OPS_BASE:
+ break;
+ case GSS_WITH_MEM_OPS:
+ {
+ gimple_statement_with_memory_ops *stmt
+ = static_cast <gimple_statement_with_memory_ops *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_ggc_m_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_CALL:
+ {
+ gimple_statement_call *stmt
+ = static_cast <gimple_statement_call *> (x);
+ gt_ggc_m_15bitmap_head_def (stmt->call_used.vars);
+ gt_ggc_m_15bitmap_head_def (stmt->call_clobbered.vars);
+ switch (stmt->subcode & GF_CALL_INTERNAL)
+ {
+ case 0:
+ gt_ggc_m_9tree_node (stmt->u.fntype);
+ break;
+ case GF_CALL_INTERNAL:
+ break;
+ default:
+ break;
+ }
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_ggc_m_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_OMP:
+ {
+ gimple_statement_omp *stmt
+ = static_cast <gimple_statement_omp *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ }
+ break;
+ case GSS_BIND:
+ {
+ gimple_statement_bind *stmt
+ = static_cast <gimple_statement_bind *> (x);
+ gt_ggc_m_9tree_node (stmt->vars);
+ gt_ggc_m_9tree_node (stmt->block);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ }
+ break;
+ case GSS_CATCH:
+ {
+ gimple_statement_catch *stmt
+ = static_cast <gimple_statement_catch *> (x);
+ gt_ggc_m_9tree_node (stmt->types);
+ gt_ggc_mx_gimple_statement_base (stmt->handler);
+ }
+ break;
+ case GSS_EH_FILTER:
+ {
+ gimple_statement_eh_filter *stmt
+ = static_cast <gimple_statement_eh_filter *> (x);
+ gt_ggc_m_9tree_node (stmt->types);
+ gt_ggc_mx_gimple_statement_base (stmt->failure);
+ }
+ break;
+ case GSS_EH_MNT:
+ {
+ gimple_statement_eh_mnt *stmt
+ = static_cast <gimple_statement_eh_mnt *> (x);
+ gt_ggc_m_9tree_node (stmt->fndecl);
+ }
+ break;
+ case GSS_EH_ELSE:
+ {
+ gimple_statement_eh_else*stmt
+ = static_cast <gimple_statement_eh_else *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->n_body);
+ gt_ggc_mx_gimple_statement_base (stmt->e_body);
+ }
+ break;
+ case GSS_PHI:
+ {
+ gimple_statement_phi *stmt
+ = static_cast <gimple_statement_phi *> (x);
+ size_t num = (size_t)(stmt->nargs);
+ gt_ggc_m_9tree_node (stmt->result);
+ for (size_t i = 0; i != num; i++)
+ gt_ggc_m_9tree_node (stmt->args[i].def);
+ }
+ break;
+ case GSS_EH_CTRL:
+ break;
+ case GSS_TRY:
+ {
+ gimple_statement_try *stmt
+ = static_cast <gimple_statement_try *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->eval);
+ gt_ggc_mx_gimple_statement_base (stmt->cleanup);
+ }
+ break;
+ case GSS_WCE:
+ {
+ gimple_statement_wce *stmt
+ = static_cast <gimple_statement_wce *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->cleanup);
+ }
+ break;
+ case GSS_ASM:
+ {
+ gimple_statement_asm *stmt
+ = static_cast <gimple_statement_asm *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ gt_ggc_m_S (stmt->string);
+ for (size_t i = 0; i != num; i++)
+ gt_ggc_m_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_OMP_CRITICAL:
+ {
+ gimple_statement_omp_critical *stmt
+ = static_cast <gimple_statement_omp_critical *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->name);
+ }
+ break;
+ case GSS_OMP_FOR:
+ {
+ gimple_statement_omp_for *stmt
+ = static_cast <gimple_statement_omp_for *> (x);
+ size_t num = (size_t)(stmt->collapse);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->clauses);
+ if (stmt->iter != NULL) {
+ for (size_t i = 0; i != num; i++) {
+ gt_ggc_m_9tree_node (stmt->iter[i].index);
+ gt_ggc_m_9tree_node (stmt->iter[i].initial);
+ gt_ggc_m_9tree_node (stmt->iter[i].final);
+ gt_ggc_m_9tree_node (stmt->iter[i].incr);
+ }
+ ggc_mark (stmt->iter);
+ }
+ gt_ggc_mx_gimple_statement_base (stmt->pre_body);
+ }
+ break;
+ case GSS_OMP_PARALLEL:
+ {
+ gimple_statement_omp_parallel *stmt
+ = static_cast <gimple_statement_omp_parallel *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->clauses);
+ gt_ggc_m_9tree_node (stmt->child_fn);
+ gt_ggc_m_9tree_node (stmt->data_arg);
+ }
+ break;
+ case GSS_OMP_TASK:
+ {
+ gimple_statement_omp_task *stmt
+ = static_cast <gimple_statement_omp_task *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->clauses);
+ gt_ggc_m_9tree_node (stmt->child_fn);
+ gt_ggc_m_9tree_node (stmt->data_arg);
+ gt_ggc_m_9tree_node (stmt->copy_fn);
+ gt_ggc_m_9tree_node (stmt->arg_size);
+ gt_ggc_m_9tree_node (stmt->arg_align);
+ }
+ break;
+ case GSS_OMP_SECTIONS:
+ {
+ gimple_statement_omp_sections *stmt
+ = static_cast <gimple_statement_omp_sections *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->clauses);
+ gt_ggc_m_9tree_node (stmt->control);
+ }
+ break;
+ case GSS_OMP_SINGLE:
+ {
+ gimple_statement_omp_single *stmt
+ = static_cast <gimple_statement_omp_single *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->clauses);
+ }
+ break;
+ case GSS_OMP_CONTINUE:
+ {
+ gimple_statement_omp_continue *stmt
+ = static_cast <gimple_statement_omp_continue *> (x);
+ gt_ggc_m_9tree_node (stmt->control_def);
+ gt_ggc_m_9tree_node (stmt->control_use);
+ }
+ break;
+ case GSS_OMP_ATOMIC_LOAD:
+ {
+ gimple_statement_omp_atomic_load *stmt
+ = static_cast <gimple_statement_omp_atomic_load *> (x);
+ gt_ggc_m_9tree_node (stmt->rhs);
+ gt_ggc_m_9tree_node (stmt->lhs);
+ }
+ break;
+ case GSS_OMP_ATOMIC_STORE:
+ {
+ gimple_statement_omp_atomic_store *stmt
+ = static_cast <gimple_statement_omp_atomic_store *> (x);
+ gt_ggc_m_9tree_node (stmt->val);
+ }
+ break;
+ case GSS_TRANSACTION:
+ {
+ gimple_statement_transaction *stmt
+ = static_cast <gimple_statement_transaction *> (x);
+ gt_ggc_mx_gimple_statement_base (stmt->body);
+ gt_ggc_m_9tree_node (stmt->label);
+ }
+ break;
+ default:
+ break;
+ }
+ x = x->next;
+ }
+}
+
+void
+gt_pch_nx (gimple gs)
+{
+ gimple x = gs;
+ /* Emulation of the "chain_next" GTY attribute.
+
+ gs has already been marked.
+ Iterate the chain of next statements, marking until we reach one that
+ has already been marked, or NULL. */
+ gimple xlimit = gs->next;
+ while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_21gimple_statement_base))
+ xlimit = xlimit->next;
+
+ /* All of the statements within the half-open interval [x..xlimit) have
+ just been marked. Iterate through the list, visiting their fields. */
+ while (x != xlimit)
+ {
+ gt_pch_n_15basic_block_def (x->bb);
+ switch (gimple_statement_structure (&((*x))))
+ {
+ case GSS_BASE:
+ break;
+ case GSS_WITH_OPS:
+ {
+ gimple_statement_with_ops *stmt
+ = static_cast <gimple_statement_with_ops *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_pch_n_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_WITH_MEM_OPS_BASE:
+ break;
+ case GSS_WITH_MEM_OPS:
+ {
+ gimple_statement_with_memory_ops *stmt
+ = static_cast <gimple_statement_with_memory_ops *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_pch_n_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_CALL:
+ {
+ gimple_statement_call *stmt
+ = static_cast <gimple_statement_call *> (x);
+ gt_pch_n_15bitmap_head_def (stmt->call_used.vars);
+ gt_pch_n_15bitmap_head_def (stmt->call_clobbered.vars);
+ switch (stmt->subcode & GF_CALL_INTERNAL)
+ {
+ case 0:
+ gt_pch_n_9tree_node (stmt->u.fntype);
+ break;
+ case GF_CALL_INTERNAL:
+ break;
+ default:
+ break;
+ }
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ gt_pch_n_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_OMP:
+ {
+ gimple_statement_omp *stmt
+ = static_cast <gimple_statement_omp *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ }
+ break;
+ case GSS_BIND:
+ {
+ gimple_statement_bind *stmt
+ = static_cast <gimple_statement_bind *> (x);
+ gt_pch_n_9tree_node (stmt->vars);
+ gt_pch_n_9tree_node (stmt->block);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ }
+ break;
+ case GSS_CATCH:
+ {
+ gimple_statement_catch *stmt
+ = static_cast <gimple_statement_catch *> (x);
+ gt_pch_n_9tree_node (stmt->types);
+ gt_pch_nx_gimple_statement_base (stmt->handler);
+ }
+ break;
+ case GSS_EH_FILTER:
+ {
+ gimple_statement_eh_filter *stmt
+ = static_cast <gimple_statement_eh_filter *> (x);
+ gt_pch_n_9tree_node (stmt->types);
+ gt_pch_nx_gimple_statement_base (stmt->failure);
+ }
+ break;
+ case GSS_EH_MNT:
+ {
+ gimple_statement_eh_mnt *stmt
+ = static_cast <gimple_statement_eh_mnt *> (x);
+ gt_pch_n_9tree_node (stmt->fndecl);
+ }
+ break;
+ case GSS_EH_ELSE:
+ {
+ gimple_statement_eh_else*stmt
+ = static_cast <gimple_statement_eh_else *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->n_body);
+ gt_pch_nx_gimple_statement_base (stmt->e_body);
+ }
+ break;
+ case GSS_PHI:
+ {
+ gimple_statement_phi *stmt
+ = static_cast <gimple_statement_phi *> (x);
+ size_t num = (size_t)(stmt->nargs);
+ gt_pch_n_9tree_node (stmt->result);
+ for (size_t i = 0; i != num; i++)
+ gt_pch_n_9tree_node (stmt->args[i].def);
+ }
+ break;
+ case GSS_EH_CTRL:
+ break;
+ case GSS_TRY:
+ {
+ gimple_statement_try *stmt
+ = static_cast <gimple_statement_try *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->eval);
+ gt_pch_nx_gimple_statement_base (stmt->cleanup);
+ }
+ break;
+ case GSS_WCE:
+ {
+ gimple_statement_wce *stmt
+ = static_cast <gimple_statement_wce *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->cleanup);
+ }
+ break;
+ case GSS_ASM:
+ {
+ gimple_statement_asm *stmt
+ = static_cast <gimple_statement_asm *> (x);
+ size_t num = (size_t)(stmt->num_ops);
+ gt_pch_n_S (stmt->string);
+ for (size_t i = 0; i != num; i++)
+ gt_pch_n_9tree_node (stmt->op[i]);
+ }
+ break;
+ case GSS_OMP_CRITICAL:
+ {
+ gimple_statement_omp_critical *stmt
+ = static_cast <gimple_statement_omp_critical *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->name);
+ }
+ break;
+ case GSS_OMP_FOR:
+ {
+ gimple_statement_omp_for *stmt
+ = static_cast <gimple_statement_omp_for *> (x);
+ size_t num = (size_t)(stmt->collapse);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->clauses);
+ if (stmt->iter != NULL) {
+ for (size_t i = 0; i != num; i++) {
+ gt_pch_n_9tree_node (stmt->iter[i].index);
+ gt_pch_n_9tree_node (stmt->iter[i].initial);
+ gt_pch_n_9tree_node (stmt->iter[i].final);
+ gt_pch_n_9tree_node (stmt->iter[i].incr);
+ }
+ gt_pch_note_object (stmt->iter, x,
+ gt_pch_p_21gimple_statement_base);
+ }
+ gt_pch_nx_gimple_statement_base (stmt->pre_body);
+ }
+ break;
+ case GSS_OMP_PARALLEL:
+ {
+ gimple_statement_omp_parallel *stmt
+ = static_cast <gimple_statement_omp_parallel *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->clauses);
+ gt_pch_n_9tree_node (stmt->child_fn);
+ gt_pch_n_9tree_node (stmt->data_arg);
+ }
+ break;
+ case GSS_OMP_TASK:
+ {
+ gimple_statement_omp_task *stmt
+ = static_cast <gimple_statement_omp_task *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->clauses);
+ gt_pch_n_9tree_node (stmt->child_fn);
+ gt_pch_n_9tree_node (stmt->data_arg);
+ gt_pch_n_9tree_node (stmt->copy_fn);
+ gt_pch_n_9tree_node (stmt->arg_size);
+ gt_pch_n_9tree_node (stmt->arg_align);
+ }
+ break;
+ case GSS_OMP_SECTIONS:
+ {
+ gimple_statement_omp_sections *stmt
+ = static_cast <gimple_statement_omp_sections *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->clauses);
+ gt_pch_n_9tree_node (stmt->control);
+ }
+ break;
+ case GSS_OMP_SINGLE:
+ {
+ gimple_statement_omp_single *stmt
+ = static_cast <gimple_statement_omp_single *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->clauses);
+ }
+ break;
+ case GSS_OMP_CONTINUE:
+ {
+ gimple_statement_omp_continue *stmt
+ = static_cast <gimple_statement_omp_continue *> (x);
+ gt_pch_n_9tree_node (stmt->control_def);
+ gt_pch_n_9tree_node (stmt->control_use);
+ }
+ break;
+ case GSS_OMP_ATOMIC_LOAD:
+ {
+ gimple_statement_omp_atomic_load *stmt
+ = static_cast <gimple_statement_omp_atomic_load *> (x);
+ gt_pch_n_9tree_node (stmt->rhs);
+ gt_pch_n_9tree_node (stmt->lhs);
+ }
+ break;
+ case GSS_OMP_ATOMIC_STORE:
+ {
+ gimple_statement_omp_atomic_store *stmt
+ = static_cast <gimple_statement_omp_atomic_store *> (x);
+ gt_pch_n_9tree_node (stmt->val);
+ }
+ break;
+ case GSS_TRANSACTION:
+ {
+ gimple_statement_transaction *stmt
+ = static_cast <gimple_statement_transaction *> (x);
+ gt_pch_nx_gimple_statement_base (stmt->body);
+ gt_pch_n_9tree_node (stmt->label);
+ }
+ break;
+ default:
+ break;
+ }
+ x = x->next;
+ }
+}
+
+void
+gt_pch_nx (gimple gs, gt_pointer_operator op, void *cookie)
+{
+ op (&(gs->bb), cookie);
+ op (&(gs->next), cookie);
+ switch (gimple_statement_structure (gs))
+ {
+ case GSS_BASE:
+ break;
+ case GSS_WITH_OPS:
+ {
+ gimple_statement_with_ops *stmt
+ = static_cast <gimple_statement_with_ops *> (gs);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ op (&(stmt->op[i]), cookie);
+ }
+ break;
+ case GSS_WITH_MEM_OPS_BASE:
+ break;
+ case GSS_WITH_MEM_OPS:
+ {
+ gimple_statement_with_memory_ops *stmt
+ = static_cast <gimple_statement_with_memory_ops *> (gs);
+ size_t num = (size_t)(stmt->num_ops);
+ for (size_t i = 0; i != num; i++)
+ op (&(stmt->op[i]), cookie);
+ }
+ break;
+ case GSS_CALL:
+ {
+ gimple_statement_call *stmt
+ = static_cast <gimple_statement_call *> (gs);
+ size_t num = (size_t)(stmt->num_ops);
+ op (&(stmt->call_used.vars), cookie);
+ op (&(stmt->call_clobbered.vars), cookie);
+ switch (stmt->subcode & GF_CALL_INTERNAL)
+ {
+ case 0:
+ op (&(stmt->u.fntype), cookie);
+ break;
+ case GF_CALL_INTERNAL:
+ break;
+ default:
+ break;
+ }
+ for (size_t i = 0; i != num; i++)
+ op (&(stmt->op[i]), cookie);
+ }
+ break;
+ case GSS_OMP:
+ {
+ gimple_statement_omp *stmt
+ = static_cast <gimple_statement_omp *> (gs);
+ op (&(stmt->body), cookie);
+ }
+ break;
+ case GSS_BIND:
+ {
+ gimple_statement_bind *stmt
+ = static_cast <gimple_statement_bind *> (gs);
+ op (&(stmt->vars), cookie);
+ op (&(stmt->block), cookie);
+ op (&(stmt->body), cookie);
+ }
+ break;
+ case GSS_CATCH:
+ {
+ gimple_statement_catch *stmt
+ = static_cast <gimple_statement_catch *> (gs);
+ op (&(stmt->types), cookie);
+ op (&(stmt->handler), cookie);
+ }
+ break;
+ case GSS_EH_FILTER:
+ {
+ gimple_statement_eh_filter *stmt
+ = static_cast <gimple_statement_eh_filter *> (gs);
+ op (&(stmt->types), cookie);
+ op (&(stmt->failure), cookie);
+ }
+ break;
+ case GSS_EH_MNT:
+ {
+ gimple_statement_eh_mnt *stmt
+ = static_cast <gimple_statement_eh_mnt *> (gs);
+ op (&(stmt->fndecl), cookie);
+ }
+ break;
+ case GSS_EH_ELSE:
+ {
+ gimple_statement_eh_else*stmt
+ = static_cast <gimple_statement_eh_else *> (gs);
+ op (&(stmt->n_body), cookie);
+ op (&(stmt->e_body), cookie);
+ }
+ break;
+ case GSS_PHI:
+ {
+ gimple_statement_phi *stmt
+ = static_cast <gimple_statement_phi *> (gs);
+ size_t num = (size_t)(stmt->nargs);
+ op (&(stmt->result), cookie);
+ for (size_t i = 0; i != num; i++)
+ op (&(stmt->args[i].def), cookie);
+ }
+ break;
+ case GSS_EH_CTRL:
+ break;
+ case GSS_TRY:
+ {
+ gimple_statement_try *stmt
+ = static_cast <gimple_statement_try *> (gs);
+ op (&(stmt->eval), cookie);
+ op (&(stmt->cleanup), cookie);
+ }
+ break;
+ case GSS_WCE:
+ {
+ gimple_statement_wce *stmt
+ = static_cast <gimple_statement_wce *> (gs);
+ op (&(stmt->cleanup), cookie);
+ }
+ break;
+ case GSS_ASM:
+ {
+ gimple_statement_asm *stmt
+ = static_cast <gimple_statement_asm *> (gs);
+ size_t num = (size_t)(stmt->num_ops);
+ op (&(stmt->string), cookie);
+ for (size_t i = 0; i != num; i++)
+ op (&(stmt->op[i]), cookie);
+ }
+ break;
+ case GSS_OMP_CRITICAL:
+ {
+ gimple_statement_omp_critical *stmt
+ = static_cast <gimple_statement_omp_critical *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->name), cookie);
+ }
+ break;
+ case GSS_OMP_FOR:
+ {
+ gimple_statement_omp_for *stmt
+ = static_cast <gimple_statement_omp_for *> (gs);
+ size_t num = (size_t)(stmt->collapse);
+ op (&(stmt->body), cookie);
+ op (&(stmt->clauses), cookie);
+ if (stmt->iter != NULL) {
+ for (size_t i = 0; i != num; i++) {
+ op (&(stmt->iter[i].index), cookie);
+ op (&(stmt->iter[i].initial), cookie);
+ op (&(stmt->iter[i].final), cookie);
+ op (&(stmt->iter[i].incr), cookie);
+ }
+ op (&(stmt->iter), cookie);
+ }
+ op (&(stmt->pre_body), cookie);
+ }
+ break;
+ case GSS_OMP_PARALLEL:
+ {
+ gimple_statement_omp_parallel *stmt
+ = static_cast <gimple_statement_omp_parallel *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->clauses), cookie);
+ op (&(stmt->child_fn), cookie);
+ op (&(stmt->data_arg), cookie);
+ }
+ break;
+ case GSS_OMP_TASK:
+ {
+ gimple_statement_omp_task *stmt
+ = static_cast <gimple_statement_omp_task *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->clauses), cookie);
+ op (&(stmt->child_fn), cookie);
+ op (&(stmt->data_arg), cookie);
+ op (&(stmt->copy_fn), cookie);
+ op (&(stmt->arg_size), cookie);
+ op (&(stmt->arg_align), cookie);
+ }
+ break;
+ case GSS_OMP_SECTIONS:
+ {
+ gimple_statement_omp_sections *stmt
+ = static_cast <gimple_statement_omp_sections *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->clauses), cookie);
+ op (&(stmt->control), cookie);
+ }
+ break;
+ case GSS_OMP_SINGLE:
+ {
+ gimple_statement_omp_single *stmt
+ = static_cast <gimple_statement_omp_single *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->clauses), cookie);
+ }
+ break;
+ case GSS_OMP_CONTINUE:
+ {
+ gimple_statement_omp_continue *stmt
+ = static_cast <gimple_statement_omp_continue *> (gs);
+ op (&(stmt->control_def), cookie);
+ op (&(stmt->control_use), cookie);
+ }
+ break;
+ case GSS_OMP_ATOMIC_LOAD:
+ {
+ gimple_statement_omp_atomic_load *stmt
+ = static_cast <gimple_statement_omp_atomic_load *> (gs);
+ op (&(stmt->rhs), cookie);
+ op (&(stmt->lhs), cookie);
+ }
+ break;
+ case GSS_OMP_ATOMIC_STORE:
+ {
+ gimple_statement_omp_atomic_store *stmt
+ = static_cast <gimple_statement_omp_atomic_store *> (gs);
+ op (&(stmt->val), cookie);
+ }
+ break;
+ case GSS_TRANSACTION:
+ {
+ gimple_statement_transaction *stmt
+ = static_cast <gimple_statement_transaction *> (gs);
+ op (&(stmt->body), cookie);
+ op (&(stmt->label), cookie);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+
#include "gt-gimple.h"
diff --git a/gcc/gimple.h b/gcc/gimple.h
index daab54e..9b428eb 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -222,6 +222,12 @@ struct GTY((user)) gimple_statement_base {
gimple GTY((skip)) prev;
};
+/* GTY((user)) hooks for gimple, called once per-traversal. */
+void gt_ggc_mx (gimple gs);
+void gt_pch_nx (gimple gs);
+void gt_pch_nx (gimple gs, gt_pointer_operator op, void *cookie);
+
+
/* Base structure for tuples with operands. */
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index af8685c..185c072 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -8291,7 +8291,6 @@ make_pass_warn_unused_result (gcc::context *ctxt)
/* Garbage collection support for edge_def. */
extern void gt_ggc_mx (tree&);
-extern void gt_ggc_mx (gimple&);
extern void gt_ggc_mx (rtx&);
extern void gt_ggc_mx (basic_block&);
@@ -8302,7 +8301,7 @@ gt_ggc_mx (edge_def *e)
gt_ggc_mx (e->src);
gt_ggc_mx (e->dest);
if (current_ir_type () == IR_GIMPLE)
- gt_ggc_mx (e->insns.g);
+ gt_ggc_mx_gimple_statement_base (e->insns.g);
else
gt_ggc_mx (e->insns.r);
gt_ggc_mx (block);
@@ -8311,7 +8310,6 @@ gt_ggc_mx (edge_def *e)
/* PCH support for edge_def. */
extern void gt_pch_nx (tree&);
-extern void gt_pch_nx (gimple&);
extern void gt_pch_nx (rtx&);
extern void gt_pch_nx (basic_block&);
@@ -8322,7 +8320,7 @@ gt_pch_nx (edge_def *e)
gt_pch_nx (e->src);
gt_pch_nx (e->dest);
if (current_ir_type () == IR_GIMPLE)
- gt_pch_nx (e->insns.g);
+ gt_pch_nx_gimple_statement_base (e->insns.g);
else
gt_pch_nx (e->insns.r);
gt_pch_nx (block);
--
1.7.11.7
