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);
