13184 lines
372 KiB
C++
13184 lines
372 KiB
C++
/* Type information for GCC.
|
|
Copyright (C) 2004-2022 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* This file is machine generated. Do not edit. */
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "backend.h"
|
|
#include "predict.h"
|
|
#include "tree.h"
|
|
#include "rtl.h"
|
|
#include "gimple.h"
|
|
#include "fold-const.h"
|
|
#include "insn-codes.h"
|
|
#include "splay-tree.h"
|
|
#include "alias.h"
|
|
#include "insn-config.h"
|
|
#include "flags.h"
|
|
#include "expmed.h"
|
|
#include "dojump.h"
|
|
#include "explow.h"
|
|
#include "calls.h"
|
|
#include "memmodel.h"
|
|
#include "emit-rtl.h"
|
|
#include "varasm.h"
|
|
#include "stmt.h"
|
|
#include "expr.h"
|
|
#include "alloc-pool.h"
|
|
#include "cselib.h"
|
|
#include "insn-addr.h"
|
|
#include "optabs.h"
|
|
#include "libfuncs.h"
|
|
#include "debug.h"
|
|
#include "internal-fn.h"
|
|
#include "gimple-fold.h"
|
|
#include "value-range.h"
|
|
#include "tree-eh.h"
|
|
#include "gimple-iterator.h"
|
|
#include "gimple-ssa.h"
|
|
#include "tree-cfg.h"
|
|
#include "tree-vrp.h"
|
|
#include "tree-phinodes.h"
|
|
#include "ssa-iterators.h"
|
|
#include "stringpool.h"
|
|
#include "tree-ssanames.h"
|
|
#include "tree-ssa-loop.h"
|
|
#include "tree-ssa-loop-ivopts.h"
|
|
#include "tree-ssa-loop-manip.h"
|
|
#include "tree-ssa-loop-niter.h"
|
|
#include "tree-into-ssa.h"
|
|
#include "tree-dfa.h"
|
|
#include "tree-ssa.h"
|
|
#include "reload.h"
|
|
#include "cpplib.h"
|
|
#include "tree-chrec.h"
|
|
#include "except.h"
|
|
#include "output.h"
|
|
#include "cfgloop.h"
|
|
#include "target.h"
|
|
#include "lto-streamer.h"
|
|
#include "target-globals.h"
|
|
#include "ipa-ref.h"
|
|
#include "cgraph.h"
|
|
#include "symbol-summary.h"
|
|
#include "ipa-prop.h"
|
|
#include "ipa-fnsummary.h"
|
|
#include "dwarf2out.h"
|
|
#include "omp-general.h"
|
|
#include "omp-offload.h"
|
|
#include "ipa-modref-tree.h"
|
|
#include "ipa-modref.h"
|
|
#include "symtab-thunks.h"
|
|
#include "symtab-clones.h"
|
|
#include "diagnostic-spec.h"
|
|
#include "ctfc.h"
|
|
|
|
/* See definition in function.h. */
|
|
#undef cfun
|
|
|
|
/* Types with a "gcc::" namespace have it stripped
|
|
during gengtype parsing. Provide a "using" directive
|
|
to ensure that the fully-qualified types are found. */
|
|
using namespace gcc;
|
|
|
|
void
|
|
gt_ggc_mx_line_maps (void *x_p)
|
|
{
|
|
struct line_maps * const x = (struct line_maps *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x).info_ordinary).used);
|
|
if ((*x).info_ordinary.maps != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_ggc_m_S ((*x).info_ordinary.maps[i0].to_file);
|
|
}
|
|
ggc_mark ((*x).info_ordinary.maps);
|
|
}
|
|
}
|
|
{
|
|
size_t l1 = (size_t)(((*x).info_macro).used);
|
|
if ((*x).info_macro.maps != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1); i1++) {
|
|
{
|
|
union tree_node * const x2 =
|
|
((*x).info_macro.maps[i1].macro) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).info_macro.maps[i1].macro))) : NULL;
|
|
gt_ggc_m_9tree_node (x2);
|
|
}
|
|
if ((*x).info_macro.maps[i1].macro_locations != NULL) {
|
|
ggc_mark ((*x).info_macro.maps[i1].macro_locations);
|
|
}
|
|
}
|
|
ggc_mark ((*x).info_macro.maps);
|
|
}
|
|
}
|
|
{
|
|
size_t l3 = (size_t)(((*x).location_adhoc_data_map).allocated);
|
|
if ((*x).location_adhoc_data_map.data != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3); i3++) {
|
|
}
|
|
ggc_mark ((*x).location_adhoc_data_map.data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cpp_token (void *x_p)
|
|
{
|
|
struct cpp_token * const x = (struct cpp_token *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
switch ((int) (cpp_token_val_index (&((*x)))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * const x0 =
|
|
((*x).val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.node))) : NULL;
|
|
gt_ggc_m_9tree_node (x0);
|
|
}
|
|
{
|
|
union tree_node * const x1 =
|
|
((*x).val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.spelling))) : NULL;
|
|
gt_ggc_m_9tree_node (x1);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
gt_ggc_m_9cpp_token ((*x).val.source);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
gt_ggc_m_S ((*x).val.str.text);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * const x2 =
|
|
((*x).val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.macro_arg.spelling))) : NULL;
|
|
gt_ggc_m_9tree_node (x2);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cpp_macro (void *x_p)
|
|
{
|
|
struct cpp_macro * const x = (struct cpp_macro *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
switch ((int) (((*x)).kind == cmk_assert))
|
|
{
|
|
case false:
|
|
if ((*x).parm.params != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(((*x)).paramc); i0++) {
|
|
{
|
|
union tree_node * const x1 =
|
|
((*x).parm.params[i0]) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).parm.params[i0]))) : NULL;
|
|
gt_ggc_m_9tree_node (x1);
|
|
}
|
|
}
|
|
ggc_mark ((*x).parm.params);
|
|
}
|
|
break;
|
|
case true:
|
|
gt_ggc_m_9cpp_macro ((*x).parm.next);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x)).kind == cmk_traditional))
|
|
{
|
|
case false:
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(((*x)).count);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
switch ((int) (cpp_token_val_index (&((*x).exp.tokens[i2]))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * const x3 =
|
|
((*x).exp.tokens[i2].val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.node))) : NULL;
|
|
gt_ggc_m_9tree_node (x3);
|
|
}
|
|
{
|
|
union tree_node * const x4 =
|
|
((*x).exp.tokens[i2].val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.spelling))) : NULL;
|
|
gt_ggc_m_9tree_node (x4);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
gt_ggc_m_9cpp_token ((*x).exp.tokens[i2].val.source);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
gt_ggc_m_S ((*x).exp.tokens[i2].val.str.text);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * const x5 =
|
|
((*x).exp.tokens[i2].val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.macro_arg.spelling))) : NULL;
|
|
gt_ggc_m_9tree_node (x5);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case true:
|
|
gt_ggc_m_S ((*x).exp.text);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_string_concat (void *x_p)
|
|
{
|
|
struct string_concat * const x = (struct string_concat *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
if ((*x).m_locs != NULL) {
|
|
ggc_mark ((*x).m_locs);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_string_concat_db (void *x_p)
|
|
{
|
|
struct string_concat_db * const x = (struct string_concat_db *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_38hash_map_location_hash_string_concat__ ((*x).m_table);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_location_hash_string_concat__ (void *x_p)
|
|
{
|
|
hash_map<location_hash,string_concat*> * const x = (hash_map<location_hash,string_concat*> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct string_concat *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_string_concat ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_bitmap_head (void *x_p)
|
|
{
|
|
struct bitmap_head * const x = (struct bitmap_head *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_14bitmap_element ((*x).first);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_rtx_def (void *x_p)
|
|
{
|
|
struct rtx_def * x = (struct rtx_def *)x_p;
|
|
struct rtx_def * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = (RTX_NEXT (&(*xlimit)));
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct rtx_def * const xprev = (RTX_PREV (&(*x)));
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) ggc_test_and_set_mark (xprev);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
switch ((int) (GET_CODE (&(*x))))
|
|
{
|
|
case DEBUG_MARKER:
|
|
break;
|
|
case DEBUG_PARAMETER_REF:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case ENTRY_VALUE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_IMPLICIT_PTR:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case VAR_LOCATION:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case FMA:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_TRUNCATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_TRUNCATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_MINUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_ASHIFT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_ASHIFT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_ABS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_NEG:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_NEG:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_MINUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_PLUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_PLUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_SERIES:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_DUPLICATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_CONCAT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_SELECT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_MERGE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LO_SUM:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case HIGH:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ZERO_EXTRACT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SIGN_EXTRACT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PARITY:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POPCOUNT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CTZ:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLZ:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLRSB:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FFS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case BSWAP:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SQRT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ABS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_SAT_FRACT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SAT_FRACT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FRACT_CONVERT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FRACT_CONVERT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FIX:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FLOAT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FIX:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT_TRUNCATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT_EXTEND:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case TRUNCATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ZERO_EXTEND:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SIGN_EXTEND:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNLT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNLE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNGT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNGE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNEQ:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ORDERED:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNORDERED:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LTU:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LEU:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GTU:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GEU:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LTGT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EQ:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_MODIFY:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_MODIFY:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_INC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_DEC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_INC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_DEC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMAX:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMIN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMAX:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMIN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ROTATERT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LSHIFTRT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ASHIFTRT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ROTATE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ASHIFT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NOT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case XOR:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case IOR:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case AND:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMOD:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UDIV:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MOD:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_DIV:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_DIV:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DIV:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMUL_HIGHPART:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMUL_HIGHPART:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_MULT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_MULT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MULT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NEG:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MINUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PLUS:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case COMPARE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case IF_THEN_ELSE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SYMBOL_REF:
|
|
switch ((int) (SYMBOL_REF_HAS_BLOCK_INFO_P (&(*x))))
|
|
{
|
|
case 1:
|
|
gt_ggc_m_12object_block ((*x).u.block_sym.block);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (CONSTANT_POOL_ADDRESS_P (&(*x))))
|
|
{
|
|
case 1:
|
|
gt_ggc_m_23constant_descriptor_rtx ((*x).u.fld[1].rt_constant);
|
|
break;
|
|
default:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[1].rt_tree);
|
|
break;
|
|
}
|
|
gt_ggc_m_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case LABEL_REF:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MEM:
|
|
gt_ggc_m_9mem_attrs ((*x).u.fld[1].rt_mem);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CONCATN:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case CONCAT:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case STRICT_LOW_PART:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SUBREG:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SCRATCH:
|
|
break;
|
|
case REG:
|
|
gt_ggc_m_9reg_attrs ((*x).u.reg.attrs);
|
|
break;
|
|
case PC:
|
|
break;
|
|
case CONST:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CONST_STRING:
|
|
gt_ggc_m_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case CONST_VECTOR:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case CONST_DOUBLE:
|
|
break;
|
|
case CONST_FIXED:
|
|
break;
|
|
case CONST_POLY_INT:
|
|
break;
|
|
case CONST_WIDE_INT:
|
|
break;
|
|
case CONST_INT:
|
|
break;
|
|
case TRAP_IF:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EH_RETURN:
|
|
break;
|
|
case SIMPLE_RETURN:
|
|
break;
|
|
case RETURN:
|
|
break;
|
|
case CALL:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLOBBER:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case USE:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SET:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PREFETCH:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDR_DIFF_VEC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[1].rt_rtvec);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDR_VEC:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case UNSPEC_VOLATILE:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case UNSPEC:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case ASM_OPERANDS:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[5].rt_rtvec);
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[4].rt_rtvec);
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[3].rt_rtvec);
|
|
gt_ggc_m_S ((*x).u.fld[1].rt_str);
|
|
gt_ggc_m_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case ASM_INPUT:
|
|
gt_ggc_m_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case PARALLEL:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case COND_EXEC:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NOTE:
|
|
switch ((int) (NOTE_KIND (&(*x))))
|
|
{
|
|
default:
|
|
gt_ggc_m_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
|
|
break;
|
|
case NOTE_INSN_CFI_LABEL:
|
|
break;
|
|
case NOTE_INSN_CFI:
|
|
break;
|
|
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
|
|
break;
|
|
case NOTE_INSN_BASIC_BLOCK:
|
|
break;
|
|
case NOTE_INSN_INLINE_ENTRY:
|
|
break;
|
|
case NOTE_INSN_BEGIN_STMT:
|
|
break;
|
|
case NOTE_INSN_VAR_LOCATION:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
break;
|
|
case NOTE_INSN_EH_REGION_END:
|
|
break;
|
|
case NOTE_INSN_EH_REGION_BEG:
|
|
break;
|
|
case NOTE_INSN_EPILOGUE_BEG:
|
|
break;
|
|
case NOTE_INSN_PROLOGUE_END:
|
|
break;
|
|
case NOTE_INSN_FUNCTION_BEG:
|
|
break;
|
|
case NOTE_INSN_BLOCK_END:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[3].rt_tree);
|
|
break;
|
|
case NOTE_INSN_BLOCK_BEG:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[3].rt_tree);
|
|
break;
|
|
case NOTE_INSN_DELETED_DEBUG_LABEL:
|
|
gt_ggc_m_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_DELETED_LABEL:
|
|
gt_ggc_m_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_DELETED:
|
|
break;
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CODE_LABEL:
|
|
gt_ggc_m_S ((*x).u.fld[6].rt_str);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case BARRIER:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case JUMP_TABLE_DATA:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CALL_INSN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[7].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case JUMP_INSN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[7].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case INSN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_INSN:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_ggc_m_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDRESS:
|
|
break;
|
|
case SEQUENCE:
|
|
gt_ggc_m_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case INT_LIST:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
break;
|
|
case INSN_LIST:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EXPR_LIST:
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_EXPR:
|
|
gt_ggc_m_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case VALUE:
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = (RTX_NEXT (&(*x)));
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_rtvec_def (void *x_p)
|
|
{
|
|
struct rtvec_def * const x = (struct rtvec_def *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x)).num_elem);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_7rtx_def ((*x).elem[i0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_gimple (void *x_p)
|
|
{
|
|
struct gimple * x = (struct gimple *)x_p;
|
|
struct gimple * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (gimple_statement_structure (&((*x)))))
|
|
{
|
|
case GSS_BASE:
|
|
gt_ggc_m_15basic_block_def ((*x).bb);
|
|
gt_ggc_m_6gimple ((*x).next);
|
|
break;
|
|
case GSS_WCE:
|
|
{
|
|
gimple_statement_wce *sub = static_cast <gimple_statement_wce *> (x);
|
|
gt_ggc_m_6gimple ((*sub).cleanup);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP:
|
|
{
|
|
gimple_statement_omp *sub = static_cast <gimple_statement_omp *> (x);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_SECTIONS:
|
|
{
|
|
gomp_sections *sub = static_cast <gomp_sections *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
gt_ggc_m_9tree_node ((*sub).control);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_PARALLEL_LAYOUT:
|
|
{
|
|
gimple_statement_omp_parallel_layout *sub = static_cast <gimple_statement_omp_parallel_layout *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
gt_ggc_m_9tree_node ((*sub).child_fn);
|
|
gt_ggc_m_9tree_node ((*sub).data_arg);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_TASK:
|
|
{
|
|
gomp_task *sub = static_cast <gomp_task *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).copy_fn);
|
|
gt_ggc_m_9tree_node ((*sub).arg_size);
|
|
gt_ggc_m_9tree_node ((*sub).arg_align);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
gt_ggc_m_9tree_node ((*sub).child_fn);
|
|
gt_ggc_m_9tree_node ((*sub).data_arg);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_FOR:
|
|
{
|
|
gomp_for *sub = static_cast <gomp_for *> (x);
|
|
{
|
|
size_t l0 = (size_t)(((*sub)).collapse);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
if ((*sub).iter != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_ggc_m_9tree_node ((*sub).iter[i0].index);
|
|
gt_ggc_m_9tree_node ((*sub).iter[i0].initial);
|
|
gt_ggc_m_9tree_node ((*sub).iter[i0].final);
|
|
gt_ggc_m_9tree_node ((*sub).iter[i0].incr);
|
|
}
|
|
ggc_mark ((*sub).iter);
|
|
}
|
|
gt_ggc_m_6gimple ((*sub).pre_body);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_OMP_SINGLE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_single_layout *sub = static_cast <gimple_statement_omp_single_layout *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_CRITICAL:
|
|
{
|
|
gomp_critical *sub = static_cast <gomp_critical *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).clauses);
|
|
gt_ggc_m_9tree_node ((*sub).name);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_CONTINUE:
|
|
{
|
|
gomp_continue *sub = static_cast <gomp_continue *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).control_def);
|
|
gt_ggc_m_9tree_node ((*sub).control_use);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_STORE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_atomic_store_layout *sub = static_cast <gimple_statement_omp_atomic_store_layout *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).val);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_LOAD:
|
|
{
|
|
gomp_atomic_load *sub = static_cast <gomp_atomic_load *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).rhs);
|
|
gt_ggc_m_9tree_node ((*sub).lhs);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_TRY:
|
|
{
|
|
gtry *sub = static_cast <gtry *> (x);
|
|
gt_ggc_m_6gimple ((*sub).eval);
|
|
gt_ggc_m_6gimple ((*sub).cleanup);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_PHI:
|
|
{
|
|
gphi *sub = static_cast <gphi *> (x);
|
|
{
|
|
size_t l1 = (size_t)(((*sub)).nargs);
|
|
gt_ggc_m_9tree_node ((*sub).result);
|
|
{
|
|
size_t i1;
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_ggc_m_9tree_node ((*sub).args[i1].def);
|
|
}
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_EH_CTRL:
|
|
{
|
|
gimple_statement_eh_ctrl *sub = static_cast <gimple_statement_eh_ctrl *> (x);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_ELSE:
|
|
{
|
|
geh_else *sub = static_cast <geh_else *> (x);
|
|
gt_ggc_m_6gimple ((*sub).n_body);
|
|
gt_ggc_m_6gimple ((*sub).e_body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_MNT:
|
|
{
|
|
geh_mnt *sub = static_cast <geh_mnt *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).fndecl);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_FILTER:
|
|
{
|
|
geh_filter *sub = static_cast <geh_filter *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).types);
|
|
gt_ggc_m_6gimple ((*sub).failure);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_CATCH:
|
|
{
|
|
gcatch *sub = static_cast <gcatch *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).types);
|
|
gt_ggc_m_6gimple ((*sub).handler);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_BIND:
|
|
{
|
|
gbind *sub = static_cast <gbind *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).vars);
|
|
gt_ggc_m_9tree_node ((*sub).block);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS_BASE:
|
|
{
|
|
gimple_statement_with_memory_ops_base *sub = static_cast <gimple_statement_with_memory_ops_base *> (x);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_TRANSACTION:
|
|
{
|
|
gtransaction *sub = static_cast <gtransaction *> (x);
|
|
gt_ggc_m_6gimple ((*sub).body);
|
|
gt_ggc_m_9tree_node ((*sub).label_norm);
|
|
gt_ggc_m_9tree_node ((*sub).label_uninst);
|
|
gt_ggc_m_9tree_node ((*sub).label_over);
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_CALL:
|
|
{
|
|
gcall *sub = static_cast <gcall *> (x);
|
|
{
|
|
size_t l2 = (size_t)(((*sub)).num_ops);
|
|
gt_ggc_m_11bitmap_head ((*sub).call_used.vars);
|
|
gt_ggc_m_11bitmap_head ((*sub).call_clobbered.vars);
|
|
switch ((int) (((*sub)).subcode & GF_CALL_INTERNAL))
|
|
{
|
|
case 0:
|
|
gt_ggc_m_9tree_node ((*sub).u.fntype);
|
|
break;
|
|
case GF_CALL_INTERNAL:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
{
|
|
size_t i2;
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
gt_ggc_m_9tree_node ((*sub).op[i2]);
|
|
}
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_ASM:
|
|
{
|
|
gasm *sub = static_cast <gasm *> (x);
|
|
{
|
|
size_t l3 = (size_t)(((*sub)).num_ops);
|
|
gt_ggc_m_S ((*sub).string);
|
|
{
|
|
size_t i3;
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
gt_ggc_m_9tree_node ((*sub).op[i3]);
|
|
}
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS:
|
|
{
|
|
gimple_statement_with_memory_ops *sub = static_cast <gimple_statement_with_memory_ops *> (x);
|
|
{
|
|
size_t l4 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i4;
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
gt_ggc_m_9tree_node ((*sub).op[i4]);
|
|
}
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_OPS:
|
|
{
|
|
gimple_statement_with_ops *sub = static_cast <gimple_statement_with_ops *> (x);
|
|
{
|
|
size_t l5 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i5;
|
|
for (i5 = 0; i5 != l5; i5++) {
|
|
gt_ggc_m_9tree_node ((*sub).op[i5]);
|
|
}
|
|
}
|
|
gt_ggc_m_15basic_block_def ((*sub).bb);
|
|
gt_ggc_m_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_symtab_node (void *x_p)
|
|
{
|
|
struct symtab_node * x = (struct symtab_node *)x_p;
|
|
struct symtab_node * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct symtab_node * const xprev = ((*x).previous);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) ggc_test_and_set_mark (xprev);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case SYMTAB_SYMBOL:
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
gt_ggc_m_11symtab_node ((*x).next);
|
|
gt_ggc_m_11symtab_node ((*x).previous);
|
|
gt_ggc_m_11symtab_node ((*x).next_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*x).previous_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*x).same_comdat_group);
|
|
gt_ggc_m_9tree_node ((*x).alias_target);
|
|
gt_ggc_m_18lto_file_decl_data ((*x).lto_file_data);
|
|
gt_ggc_m_9tree_node ((*x).x_comdat_group);
|
|
gt_ggc_m_18section_hash_entry ((*x).x_section);
|
|
break;
|
|
case SYMTAB_VARIABLE:
|
|
{
|
|
varpool_node *sub = static_cast <varpool_node *> (x);
|
|
gt_ggc_m_9tree_node ((*sub).decl);
|
|
gt_ggc_m_11symtab_node ((*sub).next);
|
|
gt_ggc_m_11symtab_node ((*sub).previous);
|
|
gt_ggc_m_11symtab_node ((*sub).next_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*sub).previous_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*sub).same_comdat_group);
|
|
gt_ggc_m_9tree_node ((*sub).alias_target);
|
|
gt_ggc_m_18lto_file_decl_data ((*sub).lto_file_data);
|
|
gt_ggc_m_9tree_node ((*sub).x_comdat_group);
|
|
gt_ggc_m_18section_hash_entry ((*sub).x_section);
|
|
}
|
|
break;
|
|
case SYMTAB_FUNCTION:
|
|
{
|
|
cgraph_node *sub = static_cast <cgraph_node *> (x);
|
|
gt_ggc_m_11cgraph_edge ((*sub).callees);
|
|
gt_ggc_m_11cgraph_edge ((*sub).callers);
|
|
gt_ggc_m_11cgraph_edge ((*sub).indirect_calls);
|
|
gt_ggc_m_11symtab_node ((*sub).next_sibling_clone);
|
|
gt_ggc_m_11symtab_node ((*sub).prev_sibling_clone);
|
|
gt_ggc_m_11symtab_node ((*sub).clones);
|
|
gt_ggc_m_11symtab_node ((*sub).clone_of);
|
|
gt_ggc_m_30hash_table_cgraph_edge_hasher_ ((*sub).call_site_hash);
|
|
gt_ggc_m_9tree_node ((*sub).former_clone_of);
|
|
gt_ggc_m_17cgraph_simd_clone ((*sub).simdclone);
|
|
gt_ggc_m_11symtab_node ((*sub).simd_clones);
|
|
gt_ggc_m_11symtab_node ((*sub).inlined_to);
|
|
gt_ggc_m_15cgraph_rtl_info ((*sub).rtl);
|
|
gt_ggc_m_9tree_node ((*sub).decl);
|
|
gt_ggc_m_11symtab_node ((*sub).next);
|
|
gt_ggc_m_11symtab_node ((*sub).previous);
|
|
gt_ggc_m_11symtab_node ((*sub).next_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*sub).previous_sharing_asm_name);
|
|
gt_ggc_m_11symtab_node ((*sub).same_comdat_group);
|
|
gt_ggc_m_9tree_node ((*sub).alias_target);
|
|
gt_ggc_m_18lto_file_decl_data ((*sub).lto_file_data);
|
|
gt_ggc_m_9tree_node ((*sub).x_comdat_group);
|
|
gt_ggc_m_18section_hash_entry ((*sub).x_section);
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cgraph_edge (void *x_p)
|
|
{
|
|
struct cgraph_edge * x = (struct cgraph_edge *)x_p;
|
|
struct cgraph_edge * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next_caller);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct cgraph_edge * const xprev = ((*x).prev_caller);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) ggc_test_and_set_mark (xprev);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_11symtab_node ((*x).caller);
|
|
gt_ggc_m_11symtab_node ((*x).callee);
|
|
gt_ggc_m_11cgraph_edge ((*x).prev_caller);
|
|
gt_ggc_m_11cgraph_edge ((*x).next_caller);
|
|
gt_ggc_m_11cgraph_edge ((*x).prev_callee);
|
|
gt_ggc_m_11cgraph_edge ((*x).next_callee);
|
|
gt_ggc_m_6gimple ((*x).call_stmt);
|
|
gt_ggc_m_25cgraph_indirect_call_info ((*x).indirect_info);
|
|
x = ((*x).next_caller);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct cgraph_edge& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_edge * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_11symtab_node ((*x).caller);
|
|
gt_ggc_m_11symtab_node ((*x).callee);
|
|
gt_ggc_m_11cgraph_edge ((*x).prev_caller);
|
|
gt_ggc_m_11cgraph_edge ((*x).next_caller);
|
|
gt_ggc_m_11cgraph_edge ((*x).prev_callee);
|
|
gt_ggc_m_11cgraph_edge ((*x).next_callee);
|
|
gt_ggc_m_6gimple ((*x).call_stmt);
|
|
gt_ggc_m_25cgraph_indirect_call_info ((*x).indirect_info);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct cgraph_edge *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_cgraph_edge ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_section (void *x_p)
|
|
{
|
|
union section * const x = (union section *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
gt_ggc_m_S ((*x).named.name);
|
|
gt_ggc_m_9tree_node ((*x).named.decl);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
gt_ggc_m_S ((*x).unnamed.data);
|
|
gt_ggc_m_7section ((*x).unnamed.next);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (union section& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
union section * ATTRIBUTE_UNUSED x = &x_r;
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
gt_ggc_m_S ((*x).named.name);
|
|
gt_ggc_m_9tree_node ((*x).named.decl);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
gt_ggc_m_S ((*x).unnamed.data);
|
|
gt_ggc_m_7section ((*x).unnamed.next);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (union section *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_section ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cl_target_option (void *x_p)
|
|
{
|
|
struct cl_target_option * const x = (struct cl_target_option *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cl_optimization (void *x_p)
|
|
{
|
|
struct cl_optimization * const x = (struct cl_optimization *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_S ((*x).x_str_align_functions);
|
|
gt_ggc_m_S ((*x).x_str_align_jumps);
|
|
gt_ggc_m_S ((*x).x_str_align_labels);
|
|
gt_ggc_m_S ((*x).x_str_align_loops);
|
|
gt_ggc_m_S ((*x).x_flag_patchable_function_entry);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_edge_def (void *x_p)
|
|
{
|
|
edge_def * const x = (edge_def *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_basic_block_def (void *x_p)
|
|
{
|
|
struct basic_block_def * x = (struct basic_block_def *)x_p;
|
|
struct basic_block_def * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next_bb);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct basic_block_def * const xprev = ((*x).prev_bb);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) ggc_test_and_set_mark (xprev);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_15vec_edge_va_gc_ ((*x).preds);
|
|
gt_ggc_m_15vec_edge_va_gc_ ((*x).succs);
|
|
gt_ggc_m_4loop ((*x).loop_father);
|
|
gt_ggc_m_15basic_block_def ((*x).prev_bb);
|
|
gt_ggc_m_15basic_block_def ((*x).next_bb);
|
|
switch ((int) (((((*x)).flags & BB_RTL) != 0)))
|
|
{
|
|
case 0:
|
|
gt_ggc_m_6gimple ((*x).il.gimple.seq);
|
|
gt_ggc_m_6gimple ((*x).il.gimple.phi_nodes);
|
|
break;
|
|
case 1:
|
|
gt_ggc_m_7rtx_def ((*x).il.x.head_);
|
|
gt_ggc_m_11rtl_bb_info ((*x).il.x.rtl);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
x = ((*x).next_bb);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_bitmap_element (void *x_p)
|
|
{
|
|
struct bitmap_element * x = (struct bitmap_element *)x_p;
|
|
struct bitmap_element * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_14bitmap_element ((*x).next);
|
|
gt_ggc_m_14bitmap_element ((*x).prev);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_generic_wide_int_wide_int_storage_ (void *x_p)
|
|
{
|
|
generic_wide_int<wide_int_storage> * const x = (generic_wide_int<wide_int_storage> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct wide_int_storage& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct wide_int_storage * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_mem_attrs (void *x_p)
|
|
{
|
|
struct mem_attrs * const x = (struct mem_attrs *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).expr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_reg_attrs (void *x_p)
|
|
{
|
|
struct reg_attrs * const x = (struct reg_attrs *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct reg_attrs& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct reg_attrs * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct reg_attrs *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_reg_attrs ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_object_block (void *x_p)
|
|
{
|
|
struct object_block * const x = (struct object_block *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_7section ((*x).sect);
|
|
gt_ggc_m_14vec_rtx_va_gc_ ((*x).objects);
|
|
gt_ggc_m_14vec_rtx_va_gc_ ((*x).anchors);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct object_block& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct object_block * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_7section ((*x).sect);
|
|
gt_ggc_m_14vec_rtx_va_gc_ ((*x).objects);
|
|
gt_ggc_m_14vec_rtx_va_gc_ ((*x).anchors);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct object_block *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_object_block ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_rtx_va_gc_ (void *x_p)
|
|
{
|
|
vec<rtx,va_gc> * const x = (vec<rtx,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct rtx_def *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_rtx_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_real_value (void *x_p)
|
|
{
|
|
struct real_value * const x = (struct real_value *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_fixed_value (void *x_p)
|
|
{
|
|
struct fixed_value * const x = (struct fixed_value *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (&((*x).mode));
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_function (void *x_p)
|
|
{
|
|
struct function * const x = (struct function *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9eh_status ((*x).eh);
|
|
gt_ggc_m_18control_flow_graph ((*x).cfg);
|
|
gt_ggc_m_6gimple ((*x).gimple_body);
|
|
gt_ggc_m_9gimple_df ((*x).gimple_df);
|
|
gt_ggc_m_5loops ((*x).x_current_loops);
|
|
gt_ggc_m_S ((*x).pass_startwith);
|
|
gt_ggc_m_11stack_usage ((*x).su);
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
gt_ggc_m_9tree_node ((*x).static_chain_decl);
|
|
gt_ggc_m_9tree_node ((*x).nonlocal_goto_save_area);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).local_decls);
|
|
gt_ggc_m_16machine_function ((*x).machine);
|
|
gt_ggc_m_17language_function ((*x).language);
|
|
gt_ggc_m_14hash_set_tree_ ((*x).used_types_hash);
|
|
gt_ggc_m_11dw_fde_node ((*x).fde);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_target_rtl (void *x_p)
|
|
{
|
|
struct target_rtl * const x = (struct target_rtl *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(GR_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_7rtx_def ((*x).x_global_rtl[i0]);
|
|
}
|
|
}
|
|
gt_ggc_m_7rtx_def ((*x).x_pic_offset_table_rtx);
|
|
gt_ggc_m_7rtx_def ((*x).x_return_address_pointer_rtx);
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_ggc_m_7rtx_def ((*x).x_initial_regno_reg_rtx[i1]);
|
|
}
|
|
}
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(MAX_MACHINE_MODE);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
gt_ggc_m_7rtx_def ((*x).x_top_of_stack[i2]);
|
|
}
|
|
}
|
|
{
|
|
size_t i3;
|
|
size_t l3 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
gt_ggc_m_7rtx_def ((*x).x_static_reg_base_value[i3]);
|
|
}
|
|
}
|
|
{
|
|
size_t i4;
|
|
size_t l4 = (size_t)((int) MAX_MACHINE_MODE);
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
gt_ggc_m_9mem_attrs ((*x).x_mode_mem_attrs[i4]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cgraph_rtl_info (void *x_p)
|
|
{
|
|
struct cgraph_rtl_info * const x = (struct cgraph_rtl_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_tree_tree_decl_tree_cache_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,decl_tree_cache_traits> * const x = (hash_map<tree,tree,decl_tree_cache_traits> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct decl_tree_cache_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_tree_cache_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (union tree_node *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_lang_tree_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_tree_tree_type_tree_cache_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,type_tree_cache_traits> * const x = (hash_map<tree,tree,type_tree_cache_traits> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct type_tree_cache_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct type_tree_cache_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_tree_tree_decl_tree_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,decl_tree_traits> * const x = (hash_map<tree,tree,decl_tree_traits> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct decl_tree_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_tree_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ptr_info_def (void *x_p)
|
|
{
|
|
struct ptr_info_def * const x = (struct ptr_info_def *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11bitmap_head ((*x).pt.vars);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_range_info_def (void *x_p)
|
|
{
|
|
struct range_info_def * const x = (struct range_info_def *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_constructor_elt_va_gc_ (void *x_p)
|
|
{
|
|
vec<constructor_elt,va_gc> * const x = (vec<constructor_elt,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct constructor_elt& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct constructor_elt * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).index);
|
|
gt_ggc_m_9tree_node ((*x).value);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_tree_va_gc_ (void *x_p)
|
|
{
|
|
vec<tree,va_gc> * const x = (vec<tree,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tree_statement_list_node (void *x_p)
|
|
{
|
|
struct tree_statement_list_node * x = (struct tree_statement_list_node *)x_p;
|
|
struct tree_statement_list_node * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct tree_statement_list_node * const xprev = ((*x).prev);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) ggc_test_and_set_mark (xprev);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_24tree_statement_list_node ((*x).prev);
|
|
gt_ggc_m_24tree_statement_list_node ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).stmt);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_target_globals (void *x_p)
|
|
{
|
|
struct target_globals * const x = (struct target_globals *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_10target_rtl ((*x).rtl);
|
|
gt_ggc_m_15target_libfuncs ((*x).libfuncs);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tree_map (void *x_p)
|
|
{
|
|
struct tree_map * const x = (struct tree_map *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_9tree_node ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_9tree_node ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_map *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_tree_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tree_decl_map (void *x_p)
|
|
{
|
|
struct tree_decl_map * const x = (struct tree_decl_map *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_9tree_node ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_decl_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_decl_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_9tree_node ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_decl_map *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_tree_decl_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tree_int_map (void *x_p)
|
|
{
|
|
struct tree_int_map * const x = (struct tree_int_map *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_int_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_int_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_int_map *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_tree_int_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tree_vec_map (void *x_p)
|
|
{
|
|
struct tree_vec_map * const x = (struct tree_vec_map *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_vec_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_vec_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).base.from);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tree_vec_map *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_tree_vec_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_alias_pair_va_gc_ (void *x_p)
|
|
{
|
|
vec<alias_pair,va_gc> * const x = (vec<alias_pair,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct alias_pair& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct alias_pair * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
gt_ggc_m_9tree_node ((*x).target);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_libfunc_entry (void *x_p)
|
|
{
|
|
struct libfunc_entry * const x = (struct libfunc_entry *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_7rtx_def ((*x).libfunc);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct libfunc_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct libfunc_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_7rtx_def ((*x).libfunc);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct libfunc_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_libfunc_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_libfunc_hasher_ (void *x_p)
|
|
{
|
|
hash_table<libfunc_hasher> * const x = (hash_table<libfunc_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct libfunc_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct libfunc_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_target_libfuncs (void *x_p)
|
|
{
|
|
struct target_libfuncs * const x = (struct target_libfuncs *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTI_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_7rtx_def ((*x).x_libfunc_table[i0]);
|
|
}
|
|
}
|
|
gt_ggc_m_26hash_table_libfunc_hasher_ ((*x).x_libfunc_hash);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_sequence_stack (void *x_p)
|
|
{
|
|
struct sequence_stack * const x = (struct sequence_stack *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_7rtx_def ((*x).first);
|
|
gt_ggc_m_7rtx_def ((*x).last);
|
|
gt_ggc_m_14sequence_stack ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_rtx_insn__va_gc_ (void *x_p)
|
|
{
|
|
vec<rtx_insn*,va_gc> * const x = (vec<rtx_insn*,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct rtx_insn *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_rtx_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_uchar_va_gc_ (void *x_p)
|
|
{
|
|
vec<uchar,va_gc> * const x = (vec<uchar,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_call_site_record_va_gc_ (void *x_p)
|
|
{
|
|
vec<call_site_record,va_gc> * const x = (vec<call_site_record,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct call_site_record_d *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_call_site_record_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_gimple_df (void *x_p)
|
|
{
|
|
struct gimple_df * const x = (struct gimple_df *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).ssa_names);
|
|
gt_ggc_m_9tree_node ((*x).vop);
|
|
gt_ggc_m_11bitmap_head ((*x).escaped.vars);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).free_ssanames);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).free_ssanames_queue);
|
|
gt_ggc_m_27hash_table_ssa_name_hasher_ ((*x).default_defs);
|
|
gt_ggc_m_20ssa_operand_memory_d ((*x).ssa_operands.operand_memory);
|
|
gt_ggc_m_29hash_table_tm_restart_hasher_ ((*x).tm_restart);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_dw_fde_node (void *x_p)
|
|
{
|
|
struct dw_fde_node * const x = (struct dw_fde_node *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
gt_ggc_m_S ((*x).dw_fde_begin);
|
|
gt_ggc_m_S ((*x).dw_fde_current_label);
|
|
gt_ggc_m_S ((*x).dw_fde_end);
|
|
gt_ggc_m_S ((*x).dw_fde_vms_end_prologue);
|
|
gt_ggc_m_S ((*x).dw_fde_vms_begin_epilogue);
|
|
gt_ggc_m_S ((*x).dw_fde_second_begin);
|
|
gt_ggc_m_S ((*x).dw_fde_second_end);
|
|
gt_ggc_m_21vec_dw_cfi_ref_va_gc_ ((*x).dw_fde_cfi);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_frame_space (void *x_p)
|
|
{
|
|
struct frame_space * const x = (struct frame_space *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11frame_space ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_callinfo_callee_va_gc_ (void *x_p)
|
|
{
|
|
vec<callinfo_callee,va_gc> * const x = (vec<callinfo_callee,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct callinfo_callee& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct callinfo_callee * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).decl);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_callinfo_dalloc_va_gc_ (void *x_p)
|
|
{
|
|
vec<callinfo_dalloc,va_gc> * const x = (vec<callinfo_dalloc,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct callinfo_dalloc& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct callinfo_dalloc * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_S ((*x).name);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_stack_usage (void *x_p)
|
|
{
|
|
struct stack_usage * const x = (struct stack_usage *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_26vec_callinfo_callee_va_gc_ ((*x).callees);
|
|
gt_ggc_m_26vec_callinfo_dalloc_va_gc_ ((*x).dallocs);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_eh_status (void *x_p)
|
|
{
|
|
struct eh_status * const x = (struct eh_status *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11eh_region_d ((*x).region_tree);
|
|
gt_ggc_m_20vec_eh_region_va_gc_ ((*x).region_array);
|
|
gt_ggc_m_25vec_eh_landing_pad_va_gc_ ((*x).lp_array);
|
|
gt_ggc_m_21hash_map_gimple__int_ ((*x).throw_stmt_table);
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).ttype_data);
|
|
switch ((int) (targetm.arm_eabi_unwinder))
|
|
{
|
|
case 1:
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).ehspec_data.arm_eabi);
|
|
break;
|
|
case 0:
|
|
gt_ggc_m_16vec_uchar_va_gc_ ((*x).ehspec_data.other);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_control_flow_graph (void *x_p)
|
|
{
|
|
struct control_flow_graph * const x = (struct control_flow_graph *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_15basic_block_def ((*x).x_entry_block_ptr);
|
|
gt_ggc_m_15basic_block_def ((*x).x_exit_block_ptr);
|
|
gt_ggc_m_22vec_basic_block_va_gc_ ((*x).x_basic_block_info);
|
|
gt_ggc_m_22vec_basic_block_va_gc_ ((*x).x_label_to_block_map);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_loops (void *x_p)
|
|
{
|
|
struct loops * const x = (struct loops *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_17vec_loop_p_va_gc_ ((*x).larray);
|
|
gt_ggc_m_28hash_table_loop_exit_hasher_ ((*x).exits);
|
|
gt_ggc_m_4loop ((*x).tree_root);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_set_tree_ (void *x_p)
|
|
{
|
|
hash_set<tree> * const x = (hash_set<tree> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_types_used_by_vars_entry (void *x_p)
|
|
{
|
|
struct types_used_by_vars_entry * const x = (struct types_used_by_vars_entry *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
gt_ggc_m_9tree_node ((*x).var_decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct types_used_by_vars_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct types_used_by_vars_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
gt_ggc_m_9tree_node ((*x).var_decl);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct types_used_by_vars_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_types_used_by_vars_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_used_type_hasher_ (void *x_p)
|
|
{
|
|
hash_table<used_type_hasher> * const x = (hash_table<used_type_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct used_type_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct used_type_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_nb_iter_bound (void *x_p)
|
|
{
|
|
struct nb_iter_bound * x = (struct nb_iter_bound *)x_p;
|
|
struct nb_iter_bound * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_6gimple ((*x).stmt);
|
|
gt_ggc_m_13nb_iter_bound ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_loop_exit (void *x_p)
|
|
{
|
|
struct loop_exit * const x = (struct loop_exit *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_8edge_def ((*x).e);
|
|
gt_ggc_m_9loop_exit ((*x).prev);
|
|
gt_ggc_m_9loop_exit ((*x).next);
|
|
gt_ggc_m_9loop_exit ((*x).next_e);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct loop_exit& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct loop_exit * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_8edge_def ((*x).e);
|
|
gt_ggc_m_9loop_exit ((*x).prev);
|
|
gt_ggc_m_9loop_exit ((*x).next);
|
|
gt_ggc_m_9loop_exit ((*x).next_e);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct loop_exit *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_loop_exit ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_loop (void *x_p)
|
|
{
|
|
struct loop * x = (struct loop *)x_p;
|
|
struct loop * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_15basic_block_def ((*x).header);
|
|
gt_ggc_m_15basic_block_def ((*x).latch);
|
|
gt_ggc_m_17vec_loop_p_va_gc_ ((*x).superloops);
|
|
gt_ggc_m_4loop ((*x).inner);
|
|
gt_ggc_m_4loop ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).nb_iterations);
|
|
gt_ggc_m_9tree_node ((*x).simduid);
|
|
gt_ggc_m_13nb_iter_bound ((*x).bounds);
|
|
gt_ggc_m_10control_iv ((*x).control_ivs);
|
|
gt_ggc_m_9loop_exit ((*x).exits);
|
|
gt_ggc_m_10niter_desc ((*x).simple_loop_desc);
|
|
gt_ggc_m_15basic_block_def ((*x).former_header);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_control_iv (void *x_p)
|
|
{
|
|
struct control_iv * x = (struct control_iv *)x_p;
|
|
struct control_iv * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).base);
|
|
gt_ggc_m_9tree_node ((*x).step);
|
|
gt_ggc_m_10control_iv ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_loop_p_va_gc_ (void *x_p)
|
|
{
|
|
vec<loop_p,va_gc> * const x = (vec<loop_p,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct loop *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_loop ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_niter_desc (void *x_p)
|
|
{
|
|
struct niter_desc * const x = (struct niter_desc *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_8edge_def ((*x).out_edge);
|
|
gt_ggc_m_8edge_def ((*x).in_edge);
|
|
gt_ggc_m_7rtx_def ((*x).assumptions);
|
|
gt_ggc_m_7rtx_def ((*x).noloop_assumptions);
|
|
gt_ggc_m_7rtx_def ((*x).infinite);
|
|
gt_ggc_m_7rtx_def ((*x).niter_expr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_loop_exit_hasher_ (void *x_p)
|
|
{
|
|
hash_table<loop_exit_hasher> * const x = (hash_table<loop_exit_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct loop_exit_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct loop_exit_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_basic_block_va_gc_ (void *x_p)
|
|
{
|
|
vec<basic_block,va_gc> * const x = (vec<basic_block,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct basic_block_def *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_basic_block_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_rtl_bb_info (void *x_p)
|
|
{
|
|
struct rtl_bb_info * const x = (struct rtl_bb_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_7rtx_def ((*x).end_);
|
|
gt_ggc_m_7rtx_def ((*x).header_);
|
|
gt_ggc_m_7rtx_def ((*x).footer_);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_edge_va_gc_ (void *x_p)
|
|
{
|
|
vec<edge,va_gc> * const x = (vec<edge,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (edge_def *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_edge_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_section_hash_entry (void *x_p)
|
|
{
|
|
struct section_hash_entry * const x = (struct section_hash_entry *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_S ((*x).name);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct section_hash_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct section_hash_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_S ((*x).name);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct section_hash_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_section_hash_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_lto_file_decl_data (void *x_p)
|
|
{
|
|
struct lto_file_decl_data * const x = (struct lto_file_decl_data *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_17lto_in_decl_state ((*x).current_decl_state);
|
|
gt_ggc_m_17lto_in_decl_state ((*x).global_decl_state);
|
|
gt_ggc_m_29hash_table_decl_state_hasher_ ((*x).function_decl_states);
|
|
gt_ggc_m_18lto_file_decl_data ((*x).next);
|
|
gt_ggc_m_S ((*x).mode_table);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_replace_map (void *x_p)
|
|
{
|
|
struct ipa_replace_map * const x = (struct ipa_replace_map *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).new_tree);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cgraph_simd_clone (void *x_p)
|
|
{
|
|
struct cgraph_simd_clone * const x = (struct cgraph_simd_clone *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x)).nargs);
|
|
gt_ggc_m_11symtab_node ((*x).prev_clone);
|
|
gt_ggc_m_11symtab_node ((*x).next_clone);
|
|
gt_ggc_m_11symtab_node ((*x).origin);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_9tree_node ((*x).args[i0].orig_arg);
|
|
gt_ggc_m_9tree_node ((*x).args[i0].orig_type);
|
|
gt_ggc_m_9tree_node ((*x).args[i0].vector_arg);
|
|
gt_ggc_m_9tree_node ((*x).args[i0].vector_type);
|
|
gt_ggc_m_9tree_node ((*x).args[i0].simd_array);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cgraph_function_version_info (void *x_p)
|
|
{
|
|
struct cgraph_function_version_info * const x = (struct cgraph_function_version_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11symtab_node ((*x).this_node);
|
|
gt_ggc_m_28cgraph_function_version_info ((*x).prev);
|
|
gt_ggc_m_28cgraph_function_version_info ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).dispatcher_resolver);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct cgraph_function_version_info& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_function_version_info * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_11symtab_node ((*x).this_node);
|
|
gt_ggc_m_28cgraph_function_version_info ((*x).prev);
|
|
gt_ggc_m_28cgraph_function_version_info ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).dispatcher_resolver);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct cgraph_function_version_info *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_cgraph_function_version_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_cgraph_edge_hasher_ (void *x_p)
|
|
{
|
|
hash_table<cgraph_edge_hasher> * const x = (hash_table<cgraph_edge_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct cgraph_edge_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_edge_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_cgraph_indirect_call_info (void *x_p)
|
|
{
|
|
struct cgraph_indirect_call_info * const x = (struct cgraph_indirect_call_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).context.outer_type);
|
|
gt_ggc_m_9tree_node ((*x).context.speculative_outer_type);
|
|
gt_ggc_m_9tree_node ((*x).otr_type);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_asm_node (void *x_p)
|
|
{
|
|
struct asm_node * const x = (struct asm_node *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_8asm_node ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).asm_str);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_thunk_info (void *x_p)
|
|
{
|
|
struct thunk_info * const x = (struct thunk_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_9tree_node ((*x).alias);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_function_summary_thunk_info__ (void *x_p)
|
|
{
|
|
function_summary<thunk_info*> * const x = (function_summary<thunk_info*> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct thunk_info *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_thunk_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_clone_info (void *x_p)
|
|
{
|
|
struct clone_info * const x = (struct clone_info *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_27vec_ipa_replace_map__va_gc_ ((*x).tree_map);
|
|
gt_ggc_m_21ipa_param_adjustments ((*x).param_adjustments);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_function_summary_clone_info__ (void *x_p)
|
|
{
|
|
function_summary<clone_info*> * const x = (function_summary<clone_info*> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct clone_info *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_clone_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_symbol_table (void *x_p)
|
|
{
|
|
struct symbol_table * const x = (struct symbol_table *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11symtab_node ((*x).nodes);
|
|
gt_ggc_m_8asm_node ((*x).asmnodes);
|
|
gt_ggc_m_8asm_node ((*x).asm_last_node);
|
|
gt_ggc_m_31hash_table_section_name_hasher_ ((*x).section_hash);
|
|
gt_ggc_m_26hash_table_asmname_hasher_ ((*x).assembler_name_hash);
|
|
gt_ggc_m_42hash_map_symtab_node__symbol_priority_map_ ((*x).init_priority_hash);
|
|
gt_ggc_m_29function_summary_thunk_info__ ((*x).m_thunks);
|
|
gt_ggc_m_29function_summary_clone_info__ ((*x).m_clones);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_section_name_hasher_ (void *x_p)
|
|
{
|
|
hash_table<section_name_hasher> * const x = (hash_table<section_name_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct section_name_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct section_name_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_asmname_hasher_ (void *x_p)
|
|
{
|
|
hash_table<asmname_hasher> * const x = (hash_table<asmname_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct asmname_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct asmname_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_symtab_node__symbol_priority_map_ (void *x_p)
|
|
{
|
|
hash_map<symtab_node*,symbol_priority_map> * const x = (hash_map<symtab_node*,symbol_priority_map> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct symbol_priority_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct symbol_priority_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct symtab_node *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_symtab_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_constant_descriptor_tree (void *x_p)
|
|
{
|
|
struct constant_descriptor_tree * const x = (struct constant_descriptor_tree *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_7rtx_def ((*x).rtl);
|
|
gt_ggc_m_9tree_node ((*x).value);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct constant_descriptor_tree& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct constant_descriptor_tree * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_7rtx_def ((*x).rtl);
|
|
gt_ggc_m_9tree_node ((*x).value);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct constant_descriptor_tree *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_constant_descriptor_tree ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_replace_map__va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_replace_map*,va_gc> * const x = (vec<ipa_replace_map*,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_replace_map *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipa_replace_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_param_adjustments (void *x_p)
|
|
{
|
|
struct ipa_param_adjustments * const x = (struct ipa_param_adjustments *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_29vec_ipa_adjusted_param_va_gc_ ((*x).m_adj_params);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_lto_in_decl_state (void *x_p)
|
|
{
|
|
struct lto_in_decl_state * const x = (struct lto_in_decl_state *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).streams[i0]);
|
|
}
|
|
}
|
|
gt_ggc_m_9tree_node ((*x).fn_decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct lto_in_decl_state& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct lto_in_decl_state * ATTRIBUTE_UNUSED x = &x_r;
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_ggc_m_15vec_tree_va_gc_ ((*x).streams[i1]);
|
|
}
|
|
}
|
|
gt_ggc_m_9tree_node ((*x).fn_decl);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct lto_in_decl_state *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_lto_in_decl_state ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_node_params (void *x_p)
|
|
{
|
|
struct ipa_node_params * const x = (struct ipa_node_params *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_31vec_ipa_param_descriptor_va_gc_ ((*x).descriptors);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_node_params& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_node_params * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_31vec_ipa_param_descriptor_va_gc_ ((*x).descriptors);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_node_params *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipa_node_params ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_edge_args (void *x_p)
|
|
{
|
|
struct ipa_edge_args * const x = (struct ipa_edge_args *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_24vec_ipa_jump_func_va_gc_ ((*x).jump_functions);
|
|
gt_ggc_m_39vec_ipa_polymorphic_call_context_va_gc_ ((*x).polymorphic_call_contexts);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_edge_args& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_edge_args * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_24vec_ipa_jump_func_va_gc_ ((*x).jump_functions);
|
|
gt_ggc_m_39vec_ipa_polymorphic_call_context_va_gc_ ((*x).polymorphic_call_contexts);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_edge_args *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipa_edge_args ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_agg_replacement_value (void *x_p)
|
|
{
|
|
struct ipa_agg_replacement_value * const x = (struct ipa_agg_replacement_value *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_25ipa_agg_replacement_value ((*x).next);
|
|
gt_ggc_m_9tree_node ((*x).value);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_fn_summary (void *x_p)
|
|
{
|
|
struct ipa_fn_summary * const x = (struct ipa_fn_summary *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_20vec_condition_va_gc_ ((*x).conds);
|
|
gt_ggc_m_37vec_ipa_freqcounting_predicate_va_gc_ ((*x).loop_iterations);
|
|
gt_ggc_m_37vec_ipa_freqcounting_predicate_va_gc_ ((*x).loop_strides);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_adjusted_param_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_adjusted_param,va_gc> * const x = (vec<ipa_adjusted_param,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_adjusted_param& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_adjusted_param * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
gt_ggc_m_9tree_node ((*x).alias_ptr_type);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_modref_tree_alias_set_type_ (void *x_p)
|
|
{
|
|
modref_tree<alias_set_type> * const x = (modref_tree<alias_set_type> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_modref_summary (void *x_p)
|
|
{
|
|
struct modref_summary * const x = (struct modref_summary *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_27modref_tree_alias_set_type_ ((*x).loads);
|
|
gt_ggc_m_27modref_tree_alias_set_type_ ((*x).stores);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_location_hash_nowarn_spec_t_ (void *x_p)
|
|
{
|
|
hash_map<location_hash,nowarn_spec_t> * const x = (hash_map<location_hash,nowarn_spec_t> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct nowarn_spec_t& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct nowarn_spec_t * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_dw_cfi_node (void *x_p)
|
|
{
|
|
struct dw_cfi_node * const x = (struct dw_cfi_node *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
switch ((int) (dw_cfi_oprnd1_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
gt_ggc_m_S ((*x).dw_cfi_oprnd1.dw_cfi_addr);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
gt_ggc_m_17dw_loc_descr_node ((*x).dw_cfi_oprnd1.dw_cfi_loc);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
gt_ggc_m_15dw_cfa_location ((*x).dw_cfi_oprnd1.dw_cfi_cfa_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (dw_cfi_oprnd2_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
gt_ggc_m_S ((*x).dw_cfi_oprnd2.dw_cfi_addr);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
gt_ggc_m_17dw_loc_descr_node ((*x).dw_cfi_oprnd2.dw_cfi_loc);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
gt_ggc_m_15dw_cfa_location ((*x).dw_cfi_oprnd2.dw_cfi_cfa_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_dw_loc_descr_node (void *x_p)
|
|
{
|
|
struct dw_loc_descr_node * x = (struct dw_loc_descr_node *)x_p;
|
|
struct dw_loc_descr_node * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).dw_loc_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_17dw_loc_descr_node ((*x).dw_loc_next);
|
|
gt_ggc_m_16addr_table_entry ((*x).dw_loc_oprnd1.val_entry);
|
|
switch ((int) (((*x).dw_loc_oprnd1).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
gt_ggc_m_7rtx_def ((*x).dw_loc_oprnd1.v.val_addr);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
gt_ggc_m_18dw_loc_list_struct ((*x).dw_loc_oprnd1.v.val_loc_list);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
gt_ggc_m_10die_struct ((*x).dw_loc_oprnd1.v.val_view_list);
|
|
break;
|
|
case dw_val_class_loc:
|
|
gt_ggc_m_17dw_loc_descr_node ((*x).dw_loc_oprnd1.v.val_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
gt_ggc_m_34generic_wide_int_wide_int_storage_ ((*x).dw_loc_oprnd1.v.val_wide);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd1.v.val_vec.array != NULL) {
|
|
ggc_mark ((*x).dw_loc_oprnd1.v.val_vec.array);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
gt_ggc_m_10die_struct ((*x).dw_loc_oprnd1.v.val_die_ref.die);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
gt_ggc_m_20indirect_string_node ((*x).dw_loc_oprnd1.v.val_str);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd1.v.val_lbl_id);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
gt_ggc_m_15dwarf_file_data ((*x).dw_loc_oprnd1.v.val_file);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
gt_ggc_m_15dwarf_file_data ((*x).dw_loc_oprnd1.v.val_file_implicit);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
gt_ggc_m_9tree_node ((*x).dw_loc_oprnd1.v.val_decl_ref);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd1.v.val_vms_delta.lbl1);
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd1.v.val_vms_delta.lbl2);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd1.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
gt_ggc_m_18dw_discr_list_node ((*x).dw_loc_oprnd1.v.val_discr_list);
|
|
break;
|
|
case dw_val_class_symview:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd1.v.val_symbolic_view);
|
|
break;
|
|
}
|
|
gt_ggc_m_16addr_table_entry ((*x).dw_loc_oprnd2.val_entry);
|
|
switch ((int) (((*x).dw_loc_oprnd2).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
gt_ggc_m_7rtx_def ((*x).dw_loc_oprnd2.v.val_addr);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
gt_ggc_m_18dw_loc_list_struct ((*x).dw_loc_oprnd2.v.val_loc_list);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
gt_ggc_m_10die_struct ((*x).dw_loc_oprnd2.v.val_view_list);
|
|
break;
|
|
case dw_val_class_loc:
|
|
gt_ggc_m_17dw_loc_descr_node ((*x).dw_loc_oprnd2.v.val_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
gt_ggc_m_34generic_wide_int_wide_int_storage_ ((*x).dw_loc_oprnd2.v.val_wide);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd2.v.val_vec.array != NULL) {
|
|
ggc_mark ((*x).dw_loc_oprnd2.v.val_vec.array);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
gt_ggc_m_10die_struct ((*x).dw_loc_oprnd2.v.val_die_ref.die);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
gt_ggc_m_20indirect_string_node ((*x).dw_loc_oprnd2.v.val_str);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd2.v.val_lbl_id);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
gt_ggc_m_15dwarf_file_data ((*x).dw_loc_oprnd2.v.val_file);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
gt_ggc_m_15dwarf_file_data ((*x).dw_loc_oprnd2.v.val_file_implicit);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
gt_ggc_m_9tree_node ((*x).dw_loc_oprnd2.v.val_decl_ref);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd2.v.val_vms_delta.lbl1);
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd2.v.val_vms_delta.lbl2);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd2.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
gt_ggc_m_18dw_discr_list_node ((*x).dw_loc_oprnd2.v.val_discr_list);
|
|
break;
|
|
case dw_val_class_symview:
|
|
gt_ggc_m_S ((*x).dw_loc_oprnd2.v.val_symbolic_view);
|
|
break;
|
|
}
|
|
x = ((*x).dw_loc_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_dw_discr_list_node (void *x_p)
|
|
{
|
|
struct dw_discr_list_node * const x = (struct dw_discr_list_node *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_18dw_discr_list_node ((*x).dw_discr_next);
|
|
switch ((int) (((*x).dw_discr_lower_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x).dw_discr_upper_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_dw_cfi_ref_va_gc_ (void *x_p)
|
|
{
|
|
vec<dw_cfi_ref,va_gc> * const x = (vec<dw_cfi_ref,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct dw_cfi_node *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_dw_cfi_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_dwarf_file_data (void *x_p)
|
|
{
|
|
struct dwarf_file_data * const x = (struct dwarf_file_data *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_S ((*x).key);
|
|
gt_ggc_m_S ((*x).filename);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct dwarf_file_data& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct dwarf_file_data * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_S ((*x).key);
|
|
gt_ggc_m_S ((*x).filename);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct dwarf_file_data *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_dwarf_file_data ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_string (void *x_p)
|
|
{
|
|
struct ctf_string * x = (struct ctf_string *)x_p;
|
|
struct ctf_string * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).cts_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_S ((*x).cts_str);
|
|
gt_ggc_m_10ctf_string ((*x).cts_next);
|
|
x = ((*x).cts_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_dmdef (void *x_p)
|
|
{
|
|
struct ctf_dmdef * x = (struct ctf_dmdef *)x_p;
|
|
struct ctf_dmdef * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).dmd_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_S ((*x).dmd_name);
|
|
gt_ggc_m_9ctf_dmdef ((*x).dmd_next);
|
|
x = ((*x).dmd_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_func_arg (void *x_p)
|
|
{
|
|
struct ctf_func_arg * const x = (struct ctf_func_arg *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_S ((*x).farg_name);
|
|
gt_ggc_m_12ctf_func_arg ((*x).farg_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_dtdef (void *x_p)
|
|
{
|
|
struct ctf_dtdef * const x = (struct ctf_dtdef *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_10die_struct ((*x).dtd_key);
|
|
gt_ggc_m_S ((*x).dtd_name);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
gt_ggc_m_9ctf_dmdef ((*x).dtd_u.dtu_members);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
gt_ggc_m_12ctf_func_arg ((*x).dtd_u.dtu_argv);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctf_dtdef& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctf_dtdef * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_10die_struct ((*x).dtd_key);
|
|
gt_ggc_m_S ((*x).dtd_name);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
gt_ggc_m_9ctf_dmdef ((*x).dtd_u.dtu_members);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
gt_ggc_m_12ctf_func_arg ((*x).dtd_u.dtu_argv);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctf_dtdef *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ctf_dtdef ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_dvdef (void *x_p)
|
|
{
|
|
struct ctf_dvdef * const x = (struct ctf_dvdef *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_10die_struct ((*x).dvd_key);
|
|
gt_ggc_m_S ((*x).dvd_name);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctf_dvdef& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctf_dvdef * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_10die_struct ((*x).dvd_key);
|
|
gt_ggc_m_S ((*x).dvd_name);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctf_dvdef *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ctf_dvdef ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_ctfc_dtd_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ctfc_dtd_hasher> * const x = (hash_table<ctfc_dtd_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctfc_dtd_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctfc_dtd_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_ctfc_dvd_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ctfc_dvd_hasher> * const x = (hash_table<ctfc_dvd_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ctfc_dvd_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctfc_dvd_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ctf_container (void *x_p)
|
|
{
|
|
struct ctf_container * const x = (struct ctf_container *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(0);
|
|
size_t l1 = (size_t)(0);
|
|
size_t l2 = (size_t)(0);
|
|
size_t l3 = (size_t)(0);
|
|
gt_ggc_m_27hash_table_ctfc_dtd_hasher_ ((*x).ctfc_types);
|
|
gt_ggc_m_27hash_table_ctfc_dvd_hasher_ ((*x).ctfc_vars);
|
|
gt_ggc_m_27hash_table_ctfc_dvd_hasher_ ((*x).ctfc_ignore_vars);
|
|
gt_ggc_m_10ctf_string ((*x).ctfc_strtable.ctstab_head);
|
|
gt_ggc_m_10ctf_string ((*x).ctfc_strtable.ctstab_tail);
|
|
gt_ggc_m_S ((*x).ctfc_strtable.ctstab_estr);
|
|
gt_ggc_m_10ctf_string ((*x).ctfc_aux_strtable.ctstab_head);
|
|
gt_ggc_m_10ctf_string ((*x).ctfc_aux_strtable.ctstab_tail);
|
|
gt_ggc_m_S ((*x).ctfc_aux_strtable.ctstab_estr);
|
|
if ((*x).ctfc_vars_list != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_ggc_m_9ctf_dvdef ((*x).ctfc_vars_list[i0]);
|
|
}
|
|
ggc_mark ((*x).ctfc_vars_list);
|
|
}
|
|
if ((*x).ctfc_types_list != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1); i1++) {
|
|
gt_ggc_m_9ctf_dtdef ((*x).ctfc_types_list[i1]);
|
|
}
|
|
ggc_mark ((*x).ctfc_types_list);
|
|
}
|
|
if ((*x).ctfc_gfuncs_list != NULL) {
|
|
size_t i2;
|
|
for (i2 = 0; i2 != (size_t)(l2); i2++) {
|
|
gt_ggc_m_9ctf_dtdef ((*x).ctfc_gfuncs_list[i2]);
|
|
}
|
|
ggc_mark ((*x).ctfc_gfuncs_list);
|
|
}
|
|
if ((*x).ctfc_gobjts_list != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3); i3++) {
|
|
gt_ggc_m_9ctf_dvdef ((*x).ctfc_gobjts_list[i3]);
|
|
}
|
|
ggc_mark ((*x).ctfc_gobjts_list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_temp_slot_p_va_gc_ (void *x_p)
|
|
{
|
|
vec<temp_slot_p,va_gc> * const x = (vec<temp_slot_p,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct temp_slot *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_temp_slot ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_eh_region_d (void *x_p)
|
|
{
|
|
struct eh_region_d * const x = (struct eh_region_d *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_11eh_region_d ((*x).outer);
|
|
gt_ggc_m_11eh_region_d ((*x).inner);
|
|
gt_ggc_m_11eh_region_d ((*x).next_peer);
|
|
switch ((int) ((*x).type))
|
|
{
|
|
case ERT_TRY:
|
|
gt_ggc_m_10eh_catch_d ((*x).u.eh_try.first_catch);
|
|
gt_ggc_m_10eh_catch_d ((*x).u.eh_try.last_catch);
|
|
break;
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
|
gt_ggc_m_9tree_node ((*x).u.allowed.type_list);
|
|
gt_ggc_m_9tree_node ((*x).u.allowed.label);
|
|
break;
|
|
case ERT_MUST_NOT_THROW:
|
|
gt_ggc_m_9tree_node ((*x).u.must_not_throw.failure_decl);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
gt_ggc_m_16eh_landing_pad_d ((*x).landing_pads);
|
|
gt_ggc_m_7rtx_def ((*x).exc_ptr_reg);
|
|
gt_ggc_m_7rtx_def ((*x).filter_reg);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_eh_landing_pad_d (void *x_p)
|
|
{
|
|
struct eh_landing_pad_d * const x = (struct eh_landing_pad_d *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_16eh_landing_pad_d ((*x).next_lp);
|
|
gt_ggc_m_11eh_region_d ((*x).region);
|
|
gt_ggc_m_9tree_node ((*x).post_landing_pad);
|
|
gt_ggc_m_7rtx_def ((*x).landing_pad);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_eh_catch_d (void *x_p)
|
|
{
|
|
struct eh_catch_d * const x = (struct eh_catch_d *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_10eh_catch_d ((*x).next_catch);
|
|
gt_ggc_m_10eh_catch_d ((*x).prev_catch);
|
|
gt_ggc_m_9tree_node ((*x).type_list);
|
|
gt_ggc_m_9tree_node ((*x).filter_list);
|
|
gt_ggc_m_9tree_node ((*x).label);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_eh_region_va_gc_ (void *x_p)
|
|
{
|
|
vec<eh_region,va_gc> * const x = (vec<eh_region,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct eh_region_d *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_eh_region_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_eh_landing_pad_va_gc_ (void *x_p)
|
|
{
|
|
vec<eh_landing_pad,va_gc> * const x = (vec<eh_landing_pad,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct eh_landing_pad_d *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_eh_landing_pad_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_gimple__int_ (void *x_p)
|
|
{
|
|
hash_map<gimple*,int> * const x = (hash_map<gimple*,int> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct gimple *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_gimple ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_tm_restart_node (void *x_p)
|
|
{
|
|
struct tm_restart_node * const x = (struct tm_restart_node *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_6gimple ((*x).stmt);
|
|
gt_ggc_m_9tree_node ((*x).label_or_list);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tm_restart_node& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tm_restart_node * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_6gimple ((*x).stmt);
|
|
gt_ggc_m_9tree_node ((*x).label_or_list);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tm_restart_node *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_tm_restart_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_map_tree_tree_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree> * const x = (hash_map<tree,tree> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_ssa_name_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ssa_name_hasher> * const x = (hash_table<ssa_name_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ssa_name_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ssa_name_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_tm_restart_hasher_ (void *x_p)
|
|
{
|
|
hash_table<tm_restart_hasher> * const x = (hash_table<tm_restart_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct tm_restart_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tm_restart_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ssa_operand_memory_d (void *x_p)
|
|
{
|
|
struct ssa_operand_memory_d * x = (struct ssa_operand_memory_d *)x_p;
|
|
struct ssa_operand_memory_d * xlimit = x;
|
|
while (ggc_test_and_set_mark (xlimit))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_ggc_m_20ssa_operand_memory_d ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_int_range_1_ (void *x_p)
|
|
{
|
|
int_range<1> * const x = (int_range<1> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_agg_jf_item_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_agg_jf_item,va_gc> * const x = (vec<ipa_agg_jf_item,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_agg_jf_item& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_agg_jf_item * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
switch ((int) (((*x)).jftype))
|
|
{
|
|
case IPA_JF_CONST:
|
|
gt_ggc_m_9tree_node ((*x).value.constant);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
gt_ggc_m_9tree_node ((*x).value.pass_through.operand);
|
|
break;
|
|
case IPA_JF_LOAD_AGG:
|
|
gt_ggc_m_9tree_node ((*x).value.load_agg.pass_through.operand);
|
|
gt_ggc_m_9tree_node ((*x).value.load_agg.type);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_bits (void *x_p)
|
|
{
|
|
struct ipa_bits * const x = (struct ipa_bits *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_param_descriptor_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_param_descriptor,va_gc> * const x = (vec<ipa_param_descriptor,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_param_descriptor& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_param_descriptor * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).decl_or_type);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_bits__va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_bits*,va_gc> * const x = (vec<ipa_bits*,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_bits *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipa_bits ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_vr_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_vr,va_gc> * const x = (vec<ipa_vr,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_vr& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_vr * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_mx (&((*x).min));
|
|
gt_ggc_mx (&((*x).max));
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipcp_transformation (void *x_p)
|
|
{
|
|
struct ipcp_transformation * const x = (struct ipcp_transformation *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_m_25ipa_agg_replacement_value ((*x).agg_values);
|
|
gt_ggc_m_20vec_ipa_bits__va_gc_ ((*x).bits);
|
|
gt_ggc_m_17vec_ipa_vr_va_gc_ ((*x).m_vr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_jump_func_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_jump_func,va_gc> * const x = (vec<ipa_jump_func,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_jump_func& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_jump_func * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_26vec_ipa_agg_jf_item_va_gc_ ((*x).agg.items);
|
|
gt_ggc_m_8ipa_bits ((*x).bits);
|
|
gt_ggc_m_12int_range_1_ ((*x).m_vr);
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case IPA_JF_CONST:
|
|
gt_ggc_m_9tree_node ((*x).value.constant.value);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
gt_ggc_m_9tree_node ((*x).value.pass_through.operand);
|
|
break;
|
|
case IPA_JF_ANCESTOR:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_polymorphic_call_context_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_polymorphic_call_context,va_gc> * const x = (vec<ipa_polymorphic_call_context,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_polymorphic_call_context& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_polymorphic_call_context * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).outer_type);
|
|
gt_ggc_m_9tree_node ((*x).speculative_outer_type);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_node_params_t (void *x_p)
|
|
{
|
|
ipa_node_params_t * const x = (ipa_node_params_t *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_ipa_edge_args_sum_t (void *x_p)
|
|
{
|
|
ipa_edge_args_sum_t * const x = (ipa_edge_args_sum_t *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_function_summary_ipcp_transformation__ (void *x_p)
|
|
{
|
|
function_summary<ipcp_transformation*> * const x = (function_summary<ipcp_transformation*> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipcp_transformation *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipcp_transformation ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_hash_table_decl_state_hasher_ (void *x_p)
|
|
{
|
|
hash_table<decl_state_hasher> * const x = (hash_table<decl_state_hasher> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct decl_state_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_state_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_expr_eval_op_va_gc_ (void *x_p)
|
|
{
|
|
vec<expr_eval_op,va_gc> * const x = (vec<expr_eval_op,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct expr_eval_op& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct expr_eval_op * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(2);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_ggc_m_9tree_node ((*x).val[i0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_condition_va_gc_ (void *x_p)
|
|
{
|
|
vec<condition,va_gc> * const x = (vec<condition,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct condition& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct condition * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_ggc_m_9tree_node ((*x).type);
|
|
gt_ggc_m_9tree_node ((*x).val);
|
|
gt_ggc_m_23vec_expr_eval_op_va_gc_ ((*x).param_ops);
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_vec_ipa_freqcounting_predicate_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_freqcounting_predicate,va_gc> * const x = (vec<ipa_freqcounting_predicate,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_freqcounting_predicate& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_freqcounting_predicate * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx_fast_function_summary_ipa_fn_summary__va_gc_ (void *x_p)
|
|
{
|
|
fast_function_summary<ipa_fn_summary*,va_gc> * const x = (fast_function_summary<ipa_fn_summary*,va_gc> *)x_p;
|
|
if (ggc_test_and_set_mark (x))
|
|
{
|
|
gt_ggc_mx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_ggc_mx (struct ipa_fn_summary *& x)
|
|
{
|
|
if (x)
|
|
gt_ggc_mx_ipa_fn_summary ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_line_maps (void *x_p)
|
|
{
|
|
struct line_maps * const x = (struct line_maps *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9line_maps))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x).info_ordinary).used);
|
|
if ((*x).info_ordinary.maps != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_pch_n_S ((*x).info_ordinary.maps[i0].to_file);
|
|
}
|
|
gt_pch_note_object ((*x).info_ordinary.maps, x, gt_pch_p_9line_maps);
|
|
}
|
|
}
|
|
{
|
|
size_t l1 = (size_t)(((*x).info_macro).used);
|
|
if ((*x).info_macro.maps != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1); i1++) {
|
|
{
|
|
union tree_node * const x2 =
|
|
((*x).info_macro.maps[i1].macro) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).info_macro.maps[i1].macro))) : NULL;
|
|
gt_pch_n_9tree_node (x2);
|
|
}
|
|
if ((*x).info_macro.maps[i1].macro_locations != NULL) {
|
|
gt_pch_note_object ((*x).info_macro.maps[i1].macro_locations, x, gt_pch_p_9line_maps);
|
|
}
|
|
}
|
|
gt_pch_note_object ((*x).info_macro.maps, x, gt_pch_p_9line_maps);
|
|
}
|
|
}
|
|
{
|
|
size_t l3 = (size_t)(((*x).location_adhoc_data_map).allocated);
|
|
if ((*x).location_adhoc_data_map.data != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3); i3++) {
|
|
}
|
|
gt_pch_note_object ((*x).location_adhoc_data_map.data, x, gt_pch_p_9line_maps);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cpp_token (void *x_p)
|
|
{
|
|
struct cpp_token * const x = (struct cpp_token *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9cpp_token))
|
|
{
|
|
switch ((int) (cpp_token_val_index (&((*x)))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * const x0 =
|
|
((*x).val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.node))) : NULL;
|
|
gt_pch_n_9tree_node (x0);
|
|
}
|
|
{
|
|
union tree_node * const x1 =
|
|
((*x).val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.spelling))) : NULL;
|
|
gt_pch_n_9tree_node (x1);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
gt_pch_n_9cpp_token ((*x).val.source);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
gt_pch_n_S ((*x).val.str.text);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * const x2 =
|
|
((*x).val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.macro_arg.spelling))) : NULL;
|
|
gt_pch_n_9tree_node (x2);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cpp_macro (void *x_p)
|
|
{
|
|
struct cpp_macro * const x = (struct cpp_macro *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9cpp_macro))
|
|
{
|
|
switch ((int) (((*x)).kind == cmk_assert))
|
|
{
|
|
case false:
|
|
if ((*x).parm.params != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(((*x)).paramc); i0++) {
|
|
{
|
|
union tree_node * const x1 =
|
|
((*x).parm.params[i0]) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).parm.params[i0]))) : NULL;
|
|
gt_pch_n_9tree_node (x1);
|
|
}
|
|
}
|
|
gt_pch_note_object ((*x).parm.params, x, gt_pch_p_9cpp_macro);
|
|
}
|
|
break;
|
|
case true:
|
|
gt_pch_n_9cpp_macro ((*x).parm.next);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x)).kind == cmk_traditional))
|
|
{
|
|
case false:
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(((*x)).count);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
switch ((int) (cpp_token_val_index (&((*x).exp.tokens[i2]))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * const x3 =
|
|
((*x).exp.tokens[i2].val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.node))) : NULL;
|
|
gt_pch_n_9tree_node (x3);
|
|
}
|
|
{
|
|
union tree_node * const x4 =
|
|
((*x).exp.tokens[i2].val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.spelling))) : NULL;
|
|
gt_pch_n_9tree_node (x4);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
gt_pch_n_9cpp_token ((*x).exp.tokens[i2].val.source);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
gt_pch_n_S ((*x).exp.tokens[i2].val.str.text);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * const x5 =
|
|
((*x).exp.tokens[i2].val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.macro_arg.spelling))) : NULL;
|
|
gt_pch_n_9tree_node (x5);
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case true:
|
|
gt_pch_n_S ((*x).exp.text);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_string_concat (void *x_p)
|
|
{
|
|
struct string_concat * const x = (struct string_concat *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_13string_concat))
|
|
{
|
|
if ((*x).m_locs != NULL) {
|
|
gt_pch_note_object ((*x).m_locs, x, gt_pch_p_13string_concat);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_string_concat_db (void *x_p)
|
|
{
|
|
struct string_concat_db * const x = (struct string_concat_db *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_16string_concat_db))
|
|
{
|
|
gt_pch_n_38hash_map_location_hash_string_concat__ ((*x).m_table);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_location_hash_string_concat__ (void *x_p)
|
|
{
|
|
hash_map<location_hash,string_concat*> * const x = (hash_map<location_hash,string_concat*> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_38hash_map_location_hash_string_concat__))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct string_concat *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_string_concat ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_bitmap_head (void *x_p)
|
|
{
|
|
struct bitmap_head * const x = (struct bitmap_head *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11bitmap_head))
|
|
{
|
|
gt_pch_n_14bitmap_element ((*x).first);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_rtx_def (void *x_p)
|
|
{
|
|
struct rtx_def * x = (struct rtx_def *)x_p;
|
|
struct rtx_def * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_7rtx_def))
|
|
xlimit = (RTX_NEXT (&(*xlimit)));
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct rtx_def * const xprev = (RTX_PREV (&(*x)));
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) gt_pch_note_object (xprev, xprev, gt_pch_p_7rtx_def);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
switch ((int) (GET_CODE (&(*x))))
|
|
{
|
|
case DEBUG_MARKER:
|
|
break;
|
|
case DEBUG_PARAMETER_REF:
|
|
gt_pch_n_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case ENTRY_VALUE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_IMPLICIT_PTR:
|
|
gt_pch_n_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case VAR_LOCATION:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case FMA:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_TRUNCATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_TRUNCATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_MINUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_ASHIFT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_ASHIFT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_ABS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_NEG:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_NEG:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_MINUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_PLUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_PLUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_SERIES:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_DUPLICATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_CONCAT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_SELECT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case VEC_MERGE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LO_SUM:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case HIGH:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ZERO_EXTRACT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SIGN_EXTRACT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PARITY:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POPCOUNT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CTZ:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLZ:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLRSB:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FFS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case BSWAP:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SQRT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ABS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_SAT_FRACT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SAT_FRACT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FRACT_CONVERT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FRACT_CONVERT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FIX:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNSIGNED_FLOAT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FIX:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT_TRUNCATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case FLOAT_EXTEND:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case TRUNCATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ZERO_EXTEND:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SIGN_EXTEND:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNLT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNLE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNGT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNGE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNEQ:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ORDERED:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UNORDERED:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LTU:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LEU:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GTU:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GEU:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LTGT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case GE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EQ:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_MODIFY:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_MODIFY:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_INC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case POST_DEC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_INC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PRE_DEC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMAX:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMIN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMAX:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMIN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ROTATERT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case LSHIFTRT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ASHIFTRT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ROTATE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ASHIFT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NOT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case XOR:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case IOR:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case AND:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMOD:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UDIV:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MOD:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_DIV:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_DIV:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DIV:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case UMUL_HIGHPART:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SMUL_HIGHPART:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case US_MULT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SS_MULT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MULT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NEG:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MINUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PLUS:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case COMPARE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case IF_THEN_ELSE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SYMBOL_REF:
|
|
switch ((int) (SYMBOL_REF_HAS_BLOCK_INFO_P (&(*x))))
|
|
{
|
|
case 1:
|
|
gt_pch_n_12object_block ((*x).u.block_sym.block);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (CONSTANT_POOL_ADDRESS_P (&(*x))))
|
|
{
|
|
case 1:
|
|
gt_pch_n_23constant_descriptor_rtx ((*x).u.fld[1].rt_constant);
|
|
break;
|
|
default:
|
|
gt_pch_n_9tree_node ((*x).u.fld[1].rt_tree);
|
|
break;
|
|
}
|
|
gt_pch_n_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case LABEL_REF:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case MEM:
|
|
gt_pch_n_9mem_attrs ((*x).u.fld[1].rt_mem);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CONCATN:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case CONCAT:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case STRICT_LOW_PART:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SUBREG:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SCRATCH:
|
|
break;
|
|
case REG:
|
|
gt_pch_n_9reg_attrs ((*x).u.reg.attrs);
|
|
break;
|
|
case PC:
|
|
break;
|
|
case CONST:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CONST_STRING:
|
|
gt_pch_n_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case CONST_VECTOR:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case CONST_DOUBLE:
|
|
break;
|
|
case CONST_FIXED:
|
|
break;
|
|
case CONST_POLY_INT:
|
|
break;
|
|
case CONST_WIDE_INT:
|
|
break;
|
|
case CONST_INT:
|
|
break;
|
|
case TRAP_IF:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EH_RETURN:
|
|
break;
|
|
case SIMPLE_RETURN:
|
|
break;
|
|
case RETURN:
|
|
break;
|
|
case CALL:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CLOBBER:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case USE:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case SET:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case PREFETCH:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDR_DIFF_VEC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[2].rt_rtx);
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[1].rt_rtvec);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDR_VEC:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case UNSPEC_VOLATILE:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case UNSPEC:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case ASM_OPERANDS:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[5].rt_rtvec);
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[4].rt_rtvec);
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[3].rt_rtvec);
|
|
gt_pch_n_S ((*x).u.fld[1].rt_str);
|
|
gt_pch_n_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case ASM_INPUT:
|
|
gt_pch_n_S ((*x).u.fld[0].rt_str);
|
|
break;
|
|
case PARALLEL:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case COND_EXEC:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case NOTE:
|
|
switch ((int) (NOTE_KIND (&(*x))))
|
|
{
|
|
default:
|
|
gt_pch_n_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
|
|
break;
|
|
case NOTE_INSN_CFI_LABEL:
|
|
break;
|
|
case NOTE_INSN_CFI:
|
|
break;
|
|
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
|
|
break;
|
|
case NOTE_INSN_BASIC_BLOCK:
|
|
break;
|
|
case NOTE_INSN_INLINE_ENTRY:
|
|
break;
|
|
case NOTE_INSN_BEGIN_STMT:
|
|
break;
|
|
case NOTE_INSN_VAR_LOCATION:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
break;
|
|
case NOTE_INSN_EH_REGION_END:
|
|
break;
|
|
case NOTE_INSN_EH_REGION_BEG:
|
|
break;
|
|
case NOTE_INSN_EPILOGUE_BEG:
|
|
break;
|
|
case NOTE_INSN_PROLOGUE_END:
|
|
break;
|
|
case NOTE_INSN_FUNCTION_BEG:
|
|
break;
|
|
case NOTE_INSN_BLOCK_END:
|
|
gt_pch_n_9tree_node ((*x).u.fld[3].rt_tree);
|
|
break;
|
|
case NOTE_INSN_BLOCK_BEG:
|
|
gt_pch_n_9tree_node ((*x).u.fld[3].rt_tree);
|
|
break;
|
|
case NOTE_INSN_DELETED_DEBUG_LABEL:
|
|
gt_pch_n_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_DELETED_LABEL:
|
|
gt_pch_n_S ((*x).u.fld[3].rt_str);
|
|
break;
|
|
case NOTE_INSN_DELETED:
|
|
break;
|
|
}
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CODE_LABEL:
|
|
gt_pch_n_S ((*x).u.fld[6].rt_str);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case BARRIER:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case JUMP_TABLE_DATA:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case CALL_INSN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[7].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case JUMP_INSN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[7].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case INSN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_INSN:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[6].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[3].rt_rtx);
|
|
gt_pch_n_15basic_block_def ((*x).u.fld[2].rt_bb);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case ADDRESS:
|
|
break;
|
|
case SEQUENCE:
|
|
gt_pch_n_9rtvec_def ((*x).u.fld[0].rt_rtvec);
|
|
break;
|
|
case INT_LIST:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
break;
|
|
case INSN_LIST:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case EXPR_LIST:
|
|
gt_pch_n_7rtx_def ((*x).u.fld[1].rt_rtx);
|
|
gt_pch_n_7rtx_def ((*x).u.fld[0].rt_rtx);
|
|
break;
|
|
case DEBUG_EXPR:
|
|
gt_pch_n_9tree_node ((*x).u.fld[0].rt_tree);
|
|
break;
|
|
case VALUE:
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = (RTX_NEXT (&(*x)));
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_rtvec_def (void *x_p)
|
|
{
|
|
struct rtvec_def * const x = (struct rtvec_def *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9rtvec_def))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x)).num_elem);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_7rtx_def ((*x).elem[i0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_gimple (void *x_p)
|
|
{
|
|
struct gimple * x = (struct gimple *)x_p;
|
|
struct gimple * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_6gimple))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (gimple_statement_structure (&((*x)))))
|
|
{
|
|
case GSS_BASE:
|
|
gt_pch_n_15basic_block_def ((*x).bb);
|
|
gt_pch_n_6gimple ((*x).next);
|
|
break;
|
|
case GSS_WCE:
|
|
{
|
|
gimple_statement_wce *sub = static_cast <gimple_statement_wce *> (x);
|
|
gt_pch_n_6gimple ((*sub).cleanup);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP:
|
|
{
|
|
gimple_statement_omp *sub = static_cast <gimple_statement_omp *> (x);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_SECTIONS:
|
|
{
|
|
gomp_sections *sub = static_cast <gomp_sections *> (x);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
gt_pch_n_9tree_node ((*sub).control);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_PARALLEL_LAYOUT:
|
|
{
|
|
gimple_statement_omp_parallel_layout *sub = static_cast <gimple_statement_omp_parallel_layout *> (x);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
gt_pch_n_9tree_node ((*sub).child_fn);
|
|
gt_pch_n_9tree_node ((*sub).data_arg);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_TASK:
|
|
{
|
|
gomp_task *sub = static_cast <gomp_task *> (x);
|
|
gt_pch_n_9tree_node ((*sub).copy_fn);
|
|
gt_pch_n_9tree_node ((*sub).arg_size);
|
|
gt_pch_n_9tree_node ((*sub).arg_align);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
gt_pch_n_9tree_node ((*sub).child_fn);
|
|
gt_pch_n_9tree_node ((*sub).data_arg);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_FOR:
|
|
{
|
|
gomp_for *sub = static_cast <gomp_for *> (x);
|
|
{
|
|
size_t l0 = (size_t)(((*sub)).collapse);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
if ((*sub).iter != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_pch_n_9tree_node ((*sub).iter[i0].index);
|
|
gt_pch_n_9tree_node ((*sub).iter[i0].initial);
|
|
gt_pch_n_9tree_node ((*sub).iter[i0].final);
|
|
gt_pch_n_9tree_node ((*sub).iter[i0].incr);
|
|
}
|
|
gt_pch_note_object ((*sub).iter, x, gt_pch_p_6gimple);
|
|
}
|
|
gt_pch_n_6gimple ((*sub).pre_body);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_OMP_SINGLE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_single_layout *sub = static_cast <gimple_statement_omp_single_layout *> (x);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_CRITICAL:
|
|
{
|
|
gomp_critical *sub = static_cast <gomp_critical *> (x);
|
|
gt_pch_n_9tree_node ((*sub).clauses);
|
|
gt_pch_n_9tree_node ((*sub).name);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_CONTINUE:
|
|
{
|
|
gomp_continue *sub = static_cast <gomp_continue *> (x);
|
|
gt_pch_n_9tree_node ((*sub).control_def);
|
|
gt_pch_n_9tree_node ((*sub).control_use);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_STORE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_atomic_store_layout *sub = static_cast <gimple_statement_omp_atomic_store_layout *> (x);
|
|
gt_pch_n_9tree_node ((*sub).val);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_LOAD:
|
|
{
|
|
gomp_atomic_load *sub = static_cast <gomp_atomic_load *> (x);
|
|
gt_pch_n_9tree_node ((*sub).rhs);
|
|
gt_pch_n_9tree_node ((*sub).lhs);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_TRY:
|
|
{
|
|
gtry *sub = static_cast <gtry *> (x);
|
|
gt_pch_n_6gimple ((*sub).eval);
|
|
gt_pch_n_6gimple ((*sub).cleanup);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_PHI:
|
|
{
|
|
gphi *sub = static_cast <gphi *> (x);
|
|
{
|
|
size_t l1 = (size_t)(((*sub)).nargs);
|
|
gt_pch_n_9tree_node ((*sub).result);
|
|
{
|
|
size_t i1;
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_pch_n_9tree_node ((*sub).args[i1].def);
|
|
}
|
|
}
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_EH_CTRL:
|
|
{
|
|
gimple_statement_eh_ctrl *sub = static_cast <gimple_statement_eh_ctrl *> (x);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_ELSE:
|
|
{
|
|
geh_else *sub = static_cast <geh_else *> (x);
|
|
gt_pch_n_6gimple ((*sub).n_body);
|
|
gt_pch_n_6gimple ((*sub).e_body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_MNT:
|
|
{
|
|
geh_mnt *sub = static_cast <geh_mnt *> (x);
|
|
gt_pch_n_9tree_node ((*sub).fndecl);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_EH_FILTER:
|
|
{
|
|
geh_filter *sub = static_cast <geh_filter *> (x);
|
|
gt_pch_n_9tree_node ((*sub).types);
|
|
gt_pch_n_6gimple ((*sub).failure);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_CATCH:
|
|
{
|
|
gcatch *sub = static_cast <gcatch *> (x);
|
|
gt_pch_n_9tree_node ((*sub).types);
|
|
gt_pch_n_6gimple ((*sub).handler);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_BIND:
|
|
{
|
|
gbind *sub = static_cast <gbind *> (x);
|
|
gt_pch_n_9tree_node ((*sub).vars);
|
|
gt_pch_n_9tree_node ((*sub).block);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS_BASE:
|
|
{
|
|
gimple_statement_with_memory_ops_base *sub = static_cast <gimple_statement_with_memory_ops_base *> (x);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_TRANSACTION:
|
|
{
|
|
gtransaction *sub = static_cast <gtransaction *> (x);
|
|
gt_pch_n_6gimple ((*sub).body);
|
|
gt_pch_n_9tree_node ((*sub).label_norm);
|
|
gt_pch_n_9tree_node ((*sub).label_uninst);
|
|
gt_pch_n_9tree_node ((*sub).label_over);
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
break;
|
|
case GSS_CALL:
|
|
{
|
|
gcall *sub = static_cast <gcall *> (x);
|
|
{
|
|
size_t l2 = (size_t)(((*sub)).num_ops);
|
|
gt_pch_n_11bitmap_head ((*sub).call_used.vars);
|
|
gt_pch_n_11bitmap_head ((*sub).call_clobbered.vars);
|
|
switch ((int) (((*sub)).subcode & GF_CALL_INTERNAL))
|
|
{
|
|
case 0:
|
|
gt_pch_n_9tree_node ((*sub).u.fntype);
|
|
break;
|
|
case GF_CALL_INTERNAL:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
{
|
|
size_t i2;
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
gt_pch_n_9tree_node ((*sub).op[i2]);
|
|
}
|
|
}
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_ASM:
|
|
{
|
|
gasm *sub = static_cast <gasm *> (x);
|
|
{
|
|
size_t l3 = (size_t)(((*sub)).num_ops);
|
|
gt_pch_n_S ((*sub).string);
|
|
{
|
|
size_t i3;
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
gt_pch_n_9tree_node ((*sub).op[i3]);
|
|
}
|
|
}
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS:
|
|
{
|
|
gimple_statement_with_memory_ops *sub = static_cast <gimple_statement_with_memory_ops *> (x);
|
|
{
|
|
size_t l4 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i4;
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
gt_pch_n_9tree_node ((*sub).op[i4]);
|
|
}
|
|
}
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_OPS:
|
|
{
|
|
gimple_statement_with_ops *sub = static_cast <gimple_statement_with_ops *> (x);
|
|
{
|
|
size_t l5 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i5;
|
|
for (i5 = 0; i5 != l5; i5++) {
|
|
gt_pch_n_9tree_node ((*sub).op[i5]);
|
|
}
|
|
}
|
|
gt_pch_n_15basic_block_def ((*sub).bb);
|
|
gt_pch_n_6gimple ((*sub).next);
|
|
}
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_symtab_node (void *x_p)
|
|
{
|
|
struct symtab_node * x = (struct symtab_node *)x_p;
|
|
struct symtab_node * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_11symtab_node))
|
|
xlimit = ((*xlimit).next);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct symtab_node * const xprev = ((*x).previous);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) gt_pch_note_object (xprev, xprev, gt_pch_p_11symtab_node);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case SYMTAB_SYMBOL:
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
gt_pch_n_11symtab_node ((*x).next);
|
|
gt_pch_n_11symtab_node ((*x).previous);
|
|
gt_pch_n_11symtab_node ((*x).next_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*x).previous_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*x).same_comdat_group);
|
|
gt_pch_n_9tree_node ((*x).alias_target);
|
|
gt_pch_n_18lto_file_decl_data ((*x).lto_file_data);
|
|
gt_pch_n_9tree_node ((*x).x_comdat_group);
|
|
gt_pch_n_18section_hash_entry ((*x).x_section);
|
|
break;
|
|
case SYMTAB_VARIABLE:
|
|
{
|
|
varpool_node *sub = static_cast <varpool_node *> (x);
|
|
gt_pch_n_9tree_node ((*sub).decl);
|
|
gt_pch_n_11symtab_node ((*sub).next);
|
|
gt_pch_n_11symtab_node ((*sub).previous);
|
|
gt_pch_n_11symtab_node ((*sub).next_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*sub).previous_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*sub).same_comdat_group);
|
|
gt_pch_n_9tree_node ((*sub).alias_target);
|
|
gt_pch_n_18lto_file_decl_data ((*sub).lto_file_data);
|
|
gt_pch_n_9tree_node ((*sub).x_comdat_group);
|
|
gt_pch_n_18section_hash_entry ((*sub).x_section);
|
|
}
|
|
break;
|
|
case SYMTAB_FUNCTION:
|
|
{
|
|
cgraph_node *sub = static_cast <cgraph_node *> (x);
|
|
gt_pch_n_11cgraph_edge ((*sub).callees);
|
|
gt_pch_n_11cgraph_edge ((*sub).callers);
|
|
gt_pch_n_11cgraph_edge ((*sub).indirect_calls);
|
|
gt_pch_n_11symtab_node ((*sub).next_sibling_clone);
|
|
gt_pch_n_11symtab_node ((*sub).prev_sibling_clone);
|
|
gt_pch_n_11symtab_node ((*sub).clones);
|
|
gt_pch_n_11symtab_node ((*sub).clone_of);
|
|
gt_pch_n_30hash_table_cgraph_edge_hasher_ ((*sub).call_site_hash);
|
|
gt_pch_n_9tree_node ((*sub).former_clone_of);
|
|
gt_pch_n_17cgraph_simd_clone ((*sub).simdclone);
|
|
gt_pch_n_11symtab_node ((*sub).simd_clones);
|
|
gt_pch_n_11symtab_node ((*sub).inlined_to);
|
|
gt_pch_n_15cgraph_rtl_info ((*sub).rtl);
|
|
gt_pch_n_9tree_node ((*sub).decl);
|
|
gt_pch_n_11symtab_node ((*sub).next);
|
|
gt_pch_n_11symtab_node ((*sub).previous);
|
|
gt_pch_n_11symtab_node ((*sub).next_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*sub).previous_sharing_asm_name);
|
|
gt_pch_n_11symtab_node ((*sub).same_comdat_group);
|
|
gt_pch_n_9tree_node ((*sub).alias_target);
|
|
gt_pch_n_18lto_file_decl_data ((*sub).lto_file_data);
|
|
gt_pch_n_9tree_node ((*sub).x_comdat_group);
|
|
gt_pch_n_18section_hash_entry ((*sub).x_section);
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cgraph_edge (void *x_p)
|
|
{
|
|
struct cgraph_edge * x = (struct cgraph_edge *)x_p;
|
|
struct cgraph_edge * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_11cgraph_edge))
|
|
xlimit = ((*xlimit).next_caller);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct cgraph_edge * const xprev = ((*x).prev_caller);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) gt_pch_note_object (xprev, xprev, gt_pch_p_11cgraph_edge);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_11symtab_node ((*x).caller);
|
|
gt_pch_n_11symtab_node ((*x).callee);
|
|
gt_pch_n_11cgraph_edge ((*x).prev_caller);
|
|
gt_pch_n_11cgraph_edge ((*x).next_caller);
|
|
gt_pch_n_11cgraph_edge ((*x).prev_callee);
|
|
gt_pch_n_11cgraph_edge ((*x).next_callee);
|
|
gt_pch_n_6gimple ((*x).call_stmt);
|
|
gt_pch_n_25cgraph_indirect_call_info ((*x).indirect_info);
|
|
x = ((*x).next_caller);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_edge& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_edge * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_11symtab_node ((*x).caller);
|
|
gt_pch_n_11symtab_node ((*x).callee);
|
|
gt_pch_n_11cgraph_edge ((*x).prev_caller);
|
|
gt_pch_n_11cgraph_edge ((*x).next_caller);
|
|
gt_pch_n_11cgraph_edge ((*x).prev_callee);
|
|
gt_pch_n_11cgraph_edge ((*x).next_callee);
|
|
gt_pch_n_6gimple ((*x).call_stmt);
|
|
gt_pch_n_25cgraph_indirect_call_info ((*x).indirect_info);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_edge *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_cgraph_edge ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_section (void *x_p)
|
|
{
|
|
union section * const x = (union section *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_7section))
|
|
{
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
gt_pch_n_S ((*x).named.name);
|
|
gt_pch_n_9tree_node ((*x).named.decl);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
gt_pch_n_S ((*x).unnamed.data);
|
|
gt_pch_n_7section ((*x).unnamed.next);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (union section& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
union section * ATTRIBUTE_UNUSED x = &x_r;
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
gt_pch_n_S ((*x).named.name);
|
|
gt_pch_n_9tree_node ((*x).named.decl);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
gt_pch_n_S ((*x).unnamed.data);
|
|
gt_pch_n_7section ((*x).unnamed.next);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (union section *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_section ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cl_target_option (void *x_p)
|
|
{
|
|
struct cl_target_option * const x = (struct cl_target_option *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_16cl_target_option))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cl_optimization (void *x_p)
|
|
{
|
|
struct cl_optimization * const x = (struct cl_optimization *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15cl_optimization))
|
|
{
|
|
gt_pch_n_S ((*x).x_str_align_functions);
|
|
gt_pch_n_S ((*x).x_str_align_jumps);
|
|
gt_pch_n_S ((*x).x_str_align_labels);
|
|
gt_pch_n_S ((*x).x_str_align_loops);
|
|
gt_pch_n_S ((*x).x_flag_patchable_function_entry);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_edge_def (void *x_p)
|
|
{
|
|
edge_def * const x = (edge_def *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_8edge_def))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_basic_block_def (void *x_p)
|
|
{
|
|
struct basic_block_def * x = (struct basic_block_def *)x_p;
|
|
struct basic_block_def * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_15basic_block_def))
|
|
xlimit = ((*xlimit).next_bb);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct basic_block_def * const xprev = ((*x).prev_bb);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) gt_pch_note_object (xprev, xprev, gt_pch_p_15basic_block_def);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_15vec_edge_va_gc_ ((*x).preds);
|
|
gt_pch_n_15vec_edge_va_gc_ ((*x).succs);
|
|
gt_pch_n_4loop ((*x).loop_father);
|
|
gt_pch_n_15basic_block_def ((*x).prev_bb);
|
|
gt_pch_n_15basic_block_def ((*x).next_bb);
|
|
switch ((int) (((((*x)).flags & BB_RTL) != 0)))
|
|
{
|
|
case 0:
|
|
gt_pch_n_6gimple ((*x).il.gimple.seq);
|
|
gt_pch_n_6gimple ((*x).il.gimple.phi_nodes);
|
|
break;
|
|
case 1:
|
|
gt_pch_n_7rtx_def ((*x).il.x.head_);
|
|
gt_pch_n_11rtl_bb_info ((*x).il.x.rtl);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
x = ((*x).next_bb);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_bitmap_element (void *x_p)
|
|
{
|
|
struct bitmap_element * x = (struct bitmap_element *)x_p;
|
|
struct bitmap_element * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_14bitmap_element))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_14bitmap_element ((*x).next);
|
|
gt_pch_n_14bitmap_element ((*x).prev);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_generic_wide_int_wide_int_storage_ (void *x_p)
|
|
{
|
|
generic_wide_int<wide_int_storage> * const x = (generic_wide_int<wide_int_storage> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_34generic_wide_int_wide_int_storage_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct wide_int_storage& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct wide_int_storage * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_mem_attrs (void *x_p)
|
|
{
|
|
struct mem_attrs * const x = (struct mem_attrs *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9mem_attrs))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).expr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_reg_attrs (void *x_p)
|
|
{
|
|
struct reg_attrs * const x = (struct reg_attrs *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9reg_attrs))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct reg_attrs& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct reg_attrs * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct reg_attrs *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_reg_attrs ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_object_block (void *x_p)
|
|
{
|
|
struct object_block * const x = (struct object_block *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12object_block))
|
|
{
|
|
gt_pch_n_7section ((*x).sect);
|
|
gt_pch_n_14vec_rtx_va_gc_ ((*x).objects);
|
|
gt_pch_n_14vec_rtx_va_gc_ ((*x).anchors);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct object_block& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct object_block * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_7section ((*x).sect);
|
|
gt_pch_n_14vec_rtx_va_gc_ ((*x).objects);
|
|
gt_pch_n_14vec_rtx_va_gc_ ((*x).anchors);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct object_block *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_object_block ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_rtx_va_gc_ (void *x_p)
|
|
{
|
|
vec<rtx,va_gc> * const x = (vec<rtx,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14vec_rtx_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct rtx_def *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_rtx_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_real_value (void *x_p)
|
|
{
|
|
struct real_value * const x = (struct real_value *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10real_value))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_fixed_value (void *x_p)
|
|
{
|
|
struct fixed_value * const x = (struct fixed_value *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11fixed_value))
|
|
{
|
|
gt_pch_nx (&((*x).mode));
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_function (void *x_p)
|
|
{
|
|
struct function * const x = (struct function *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_8function))
|
|
{
|
|
gt_pch_n_9eh_status ((*x).eh);
|
|
gt_pch_n_18control_flow_graph ((*x).cfg);
|
|
gt_pch_n_6gimple ((*x).gimple_body);
|
|
gt_pch_n_9gimple_df ((*x).gimple_df);
|
|
gt_pch_n_5loops ((*x).x_current_loops);
|
|
gt_pch_n_S ((*x).pass_startwith);
|
|
gt_pch_n_11stack_usage ((*x).su);
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
gt_pch_n_9tree_node ((*x).static_chain_decl);
|
|
gt_pch_n_9tree_node ((*x).nonlocal_goto_save_area);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).local_decls);
|
|
gt_pch_n_16machine_function ((*x).machine);
|
|
gt_pch_n_17language_function ((*x).language);
|
|
gt_pch_n_14hash_set_tree_ ((*x).used_types_hash);
|
|
gt_pch_n_11dw_fde_node ((*x).fde);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_target_rtl (void *x_p)
|
|
{
|
|
struct target_rtl * const x = (struct target_rtl *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10target_rtl))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(GR_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_7rtx_def ((*x).x_global_rtl[i0]);
|
|
}
|
|
}
|
|
gt_pch_n_7rtx_def ((*x).x_pic_offset_table_rtx);
|
|
gt_pch_n_7rtx_def ((*x).x_return_address_pointer_rtx);
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_pch_n_7rtx_def ((*x).x_initial_regno_reg_rtx[i1]);
|
|
}
|
|
}
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(MAX_MACHINE_MODE);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
gt_pch_n_7rtx_def ((*x).x_top_of_stack[i2]);
|
|
}
|
|
}
|
|
{
|
|
size_t i3;
|
|
size_t l3 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
gt_pch_n_7rtx_def ((*x).x_static_reg_base_value[i3]);
|
|
}
|
|
}
|
|
{
|
|
size_t i4;
|
|
size_t l4 = (size_t)((int) MAX_MACHINE_MODE);
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
gt_pch_n_9mem_attrs ((*x).x_mode_mem_attrs[i4]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cgraph_rtl_info (void *x_p)
|
|
{
|
|
struct cgraph_rtl_info * const x = (struct cgraph_rtl_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15cgraph_rtl_info))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_tree_tree_decl_tree_cache_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,decl_tree_cache_traits> * const x = (hash_map<tree,tree,decl_tree_cache_traits> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_42hash_map_tree_tree_decl_tree_cache_traits_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_tree_cache_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_tree_cache_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (union tree_node *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_lang_tree_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_tree_tree_type_tree_cache_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,type_tree_cache_traits> * const x = (hash_map<tree,tree,type_tree_cache_traits> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_42hash_map_tree_tree_type_tree_cache_traits_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct type_tree_cache_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct type_tree_cache_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_tree_tree_decl_tree_traits_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree,decl_tree_traits> * const x = (hash_map<tree,tree,decl_tree_traits> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_36hash_map_tree_tree_decl_tree_traits_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_tree_traits& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_tree_traits * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ptr_info_def (void *x_p)
|
|
{
|
|
struct ptr_info_def * const x = (struct ptr_info_def *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12ptr_info_def))
|
|
{
|
|
gt_pch_n_11bitmap_head ((*x).pt.vars);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_range_info_def (void *x_p)
|
|
{
|
|
struct range_info_def * const x = (struct range_info_def *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14range_info_def))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_constructor_elt_va_gc_ (void *x_p)
|
|
{
|
|
vec<constructor_elt,va_gc> * const x = (vec<constructor_elt,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26vec_constructor_elt_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct constructor_elt& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct constructor_elt * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).index);
|
|
gt_pch_n_9tree_node ((*x).value);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_tree_va_gc_ (void *x_p)
|
|
{
|
|
vec<tree,va_gc> * const x = (vec<tree,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15vec_tree_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tree_statement_list_node (void *x_p)
|
|
{
|
|
struct tree_statement_list_node * x = (struct tree_statement_list_node *)x_p;
|
|
struct tree_statement_list_node * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_24tree_statement_list_node))
|
|
xlimit = ((*xlimit).next);
|
|
if (x != xlimit)
|
|
for (;;)
|
|
{
|
|
struct tree_statement_list_node * const xprev = ((*x).prev);
|
|
if (xprev == NULL) break;
|
|
x = xprev;
|
|
(void) gt_pch_note_object (xprev, xprev, gt_pch_p_24tree_statement_list_node);
|
|
}
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_24tree_statement_list_node ((*x).prev);
|
|
gt_pch_n_24tree_statement_list_node ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).stmt);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_target_globals (void *x_p)
|
|
{
|
|
struct target_globals * const x = (struct target_globals *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14target_globals))
|
|
{
|
|
gt_pch_n_10target_rtl ((*x).rtl);
|
|
gt_pch_n_15target_libfuncs ((*x).libfuncs);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tree_map (void *x_p)
|
|
{
|
|
struct tree_map * const x = (struct tree_map *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_8tree_map))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_9tree_node ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_9tree_node ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_map *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_tree_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tree_decl_map (void *x_p)
|
|
{
|
|
struct tree_decl_map * const x = (struct tree_decl_map *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_13tree_decl_map))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_9tree_node ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_decl_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_decl_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_9tree_node ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_decl_map *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_tree_decl_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tree_int_map (void *x_p)
|
|
{
|
|
struct tree_int_map * const x = (struct tree_int_map *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12tree_int_map))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_int_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_int_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_int_map *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_tree_int_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tree_vec_map (void *x_p)
|
|
{
|
|
struct tree_vec_map * const x = (struct tree_vec_map *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12tree_vec_map))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).to);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_vec_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tree_vec_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).base.from);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).to);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_vec_map *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_tree_vec_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_alias_pair_va_gc_ (void *x_p)
|
|
{
|
|
vec<alias_pair,va_gc> * const x = (vec<alias_pair,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_21vec_alias_pair_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct alias_pair& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct alias_pair * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
gt_pch_n_9tree_node ((*x).target);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_libfunc_entry (void *x_p)
|
|
{
|
|
struct libfunc_entry * const x = (struct libfunc_entry *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_13libfunc_entry))
|
|
{
|
|
gt_pch_n_7rtx_def ((*x).libfunc);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct libfunc_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct libfunc_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_7rtx_def ((*x).libfunc);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct libfunc_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_libfunc_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_libfunc_hasher_ (void *x_p)
|
|
{
|
|
hash_table<libfunc_hasher> * const x = (hash_table<libfunc_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26hash_table_libfunc_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct libfunc_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct libfunc_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_target_libfuncs (void *x_p)
|
|
{
|
|
struct target_libfuncs * const x = (struct target_libfuncs *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15target_libfuncs))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTI_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_7rtx_def ((*x).x_libfunc_table[i0]);
|
|
}
|
|
}
|
|
gt_pch_n_26hash_table_libfunc_hasher_ ((*x).x_libfunc_hash);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_sequence_stack (void *x_p)
|
|
{
|
|
struct sequence_stack * const x = (struct sequence_stack *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14sequence_stack))
|
|
{
|
|
gt_pch_n_7rtx_def ((*x).first);
|
|
gt_pch_n_7rtx_def ((*x).last);
|
|
gt_pch_n_14sequence_stack ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_rtx_insn__va_gc_ (void *x_p)
|
|
{
|
|
vec<rtx_insn*,va_gc> * const x = (vec<rtx_insn*,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_20vec_rtx_insn__va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct rtx_insn *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_rtx_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_uchar_va_gc_ (void *x_p)
|
|
{
|
|
vec<uchar,va_gc> * const x = (vec<uchar,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_16vec_uchar_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_call_site_record_va_gc_ (void *x_p)
|
|
{
|
|
vec<call_site_record,va_gc> * const x = (vec<call_site_record,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27vec_call_site_record_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct call_site_record_d *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_call_site_record_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_gimple_df (void *x_p)
|
|
{
|
|
struct gimple_df * const x = (struct gimple_df *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9gimple_df))
|
|
{
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).ssa_names);
|
|
gt_pch_n_9tree_node ((*x).vop);
|
|
gt_pch_n_11bitmap_head ((*x).escaped.vars);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).free_ssanames);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).free_ssanames_queue);
|
|
gt_pch_n_27hash_table_ssa_name_hasher_ ((*x).default_defs);
|
|
gt_pch_n_20ssa_operand_memory_d ((*x).ssa_operands.operand_memory);
|
|
gt_pch_n_29hash_table_tm_restart_hasher_ ((*x).tm_restart);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_dw_fde_node (void *x_p)
|
|
{
|
|
struct dw_fde_node * const x = (struct dw_fde_node *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11dw_fde_node))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
gt_pch_n_S ((*x).dw_fde_begin);
|
|
gt_pch_n_S ((*x).dw_fde_current_label);
|
|
gt_pch_n_S ((*x).dw_fde_end);
|
|
gt_pch_n_S ((*x).dw_fde_vms_end_prologue);
|
|
gt_pch_n_S ((*x).dw_fde_vms_begin_epilogue);
|
|
gt_pch_n_S ((*x).dw_fde_second_begin);
|
|
gt_pch_n_S ((*x).dw_fde_second_end);
|
|
gt_pch_n_21vec_dw_cfi_ref_va_gc_ ((*x).dw_fde_cfi);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_frame_space (void *x_p)
|
|
{
|
|
struct frame_space * const x = (struct frame_space *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11frame_space))
|
|
{
|
|
gt_pch_n_11frame_space ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_callinfo_callee_va_gc_ (void *x_p)
|
|
{
|
|
vec<callinfo_callee,va_gc> * const x = (vec<callinfo_callee,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26vec_callinfo_callee_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct callinfo_callee& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct callinfo_callee * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).decl);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_callinfo_dalloc_va_gc_ (void *x_p)
|
|
{
|
|
vec<callinfo_dalloc,va_gc> * const x = (vec<callinfo_dalloc,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26vec_callinfo_dalloc_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct callinfo_dalloc& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct callinfo_dalloc * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_S ((*x).name);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_stack_usage (void *x_p)
|
|
{
|
|
struct stack_usage * const x = (struct stack_usage *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11stack_usage))
|
|
{
|
|
gt_pch_n_26vec_callinfo_callee_va_gc_ ((*x).callees);
|
|
gt_pch_n_26vec_callinfo_dalloc_va_gc_ ((*x).dallocs);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_eh_status (void *x_p)
|
|
{
|
|
struct eh_status * const x = (struct eh_status *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9eh_status))
|
|
{
|
|
gt_pch_n_11eh_region_d ((*x).region_tree);
|
|
gt_pch_n_20vec_eh_region_va_gc_ ((*x).region_array);
|
|
gt_pch_n_25vec_eh_landing_pad_va_gc_ ((*x).lp_array);
|
|
gt_pch_n_21hash_map_gimple__int_ ((*x).throw_stmt_table);
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).ttype_data);
|
|
switch ((int) (targetm.arm_eabi_unwinder))
|
|
{
|
|
case 1:
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).ehspec_data.arm_eabi);
|
|
break;
|
|
case 0:
|
|
gt_pch_n_16vec_uchar_va_gc_ ((*x).ehspec_data.other);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_control_flow_graph (void *x_p)
|
|
{
|
|
struct control_flow_graph * const x = (struct control_flow_graph *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_18control_flow_graph))
|
|
{
|
|
gt_pch_n_15basic_block_def ((*x).x_entry_block_ptr);
|
|
gt_pch_n_15basic_block_def ((*x).x_exit_block_ptr);
|
|
gt_pch_n_22vec_basic_block_va_gc_ ((*x).x_basic_block_info);
|
|
gt_pch_n_22vec_basic_block_va_gc_ ((*x).x_label_to_block_map);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_loops (void *x_p)
|
|
{
|
|
struct loops * const x = (struct loops *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_5loops))
|
|
{
|
|
gt_pch_n_17vec_loop_p_va_gc_ ((*x).larray);
|
|
gt_pch_n_28hash_table_loop_exit_hasher_ ((*x).exits);
|
|
gt_pch_n_4loop ((*x).tree_root);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_set_tree_ (void *x_p)
|
|
{
|
|
hash_set<tree> * const x = (hash_set<tree> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14hash_set_tree_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_types_used_by_vars_entry (void *x_p)
|
|
{
|
|
struct types_used_by_vars_entry * const x = (struct types_used_by_vars_entry *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_24types_used_by_vars_entry))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
gt_pch_n_9tree_node ((*x).var_decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct types_used_by_vars_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct types_used_by_vars_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
gt_pch_n_9tree_node ((*x).var_decl);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct types_used_by_vars_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_types_used_by_vars_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_used_type_hasher_ (void *x_p)
|
|
{
|
|
hash_table<used_type_hasher> * const x = (hash_table<used_type_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_28hash_table_used_type_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct used_type_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct used_type_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_nb_iter_bound (void *x_p)
|
|
{
|
|
struct nb_iter_bound * x = (struct nb_iter_bound *)x_p;
|
|
struct nb_iter_bound * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_13nb_iter_bound))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_6gimple ((*x).stmt);
|
|
gt_pch_n_13nb_iter_bound ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_loop_exit (void *x_p)
|
|
{
|
|
struct loop_exit * const x = (struct loop_exit *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9loop_exit))
|
|
{
|
|
gt_pch_n_8edge_def ((*x).e);
|
|
gt_pch_n_9loop_exit ((*x).prev);
|
|
gt_pch_n_9loop_exit ((*x).next);
|
|
gt_pch_n_9loop_exit ((*x).next_e);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop_exit& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct loop_exit * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_8edge_def ((*x).e);
|
|
gt_pch_n_9loop_exit ((*x).prev);
|
|
gt_pch_n_9loop_exit ((*x).next);
|
|
gt_pch_n_9loop_exit ((*x).next_e);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop_exit *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_loop_exit ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_loop (void *x_p)
|
|
{
|
|
struct loop * x = (struct loop *)x_p;
|
|
struct loop * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_4loop))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_15basic_block_def ((*x).header);
|
|
gt_pch_n_15basic_block_def ((*x).latch);
|
|
gt_pch_n_17vec_loop_p_va_gc_ ((*x).superloops);
|
|
gt_pch_n_4loop ((*x).inner);
|
|
gt_pch_n_4loop ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).nb_iterations);
|
|
gt_pch_n_9tree_node ((*x).simduid);
|
|
gt_pch_n_13nb_iter_bound ((*x).bounds);
|
|
gt_pch_n_10control_iv ((*x).control_ivs);
|
|
gt_pch_n_9loop_exit ((*x).exits);
|
|
gt_pch_n_10niter_desc ((*x).simple_loop_desc);
|
|
gt_pch_n_15basic_block_def ((*x).former_header);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_control_iv (void *x_p)
|
|
{
|
|
struct control_iv * x = (struct control_iv *)x_p;
|
|
struct control_iv * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_10control_iv))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_9tree_node ((*x).base);
|
|
gt_pch_n_9tree_node ((*x).step);
|
|
gt_pch_n_10control_iv ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_loop_p_va_gc_ (void *x_p)
|
|
{
|
|
vec<loop_p,va_gc> * const x = (vec<loop_p,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_17vec_loop_p_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_loop ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_niter_desc (void *x_p)
|
|
{
|
|
struct niter_desc * const x = (struct niter_desc *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10niter_desc))
|
|
{
|
|
gt_pch_n_8edge_def ((*x).out_edge);
|
|
gt_pch_n_8edge_def ((*x).in_edge);
|
|
gt_pch_n_7rtx_def ((*x).assumptions);
|
|
gt_pch_n_7rtx_def ((*x).noloop_assumptions);
|
|
gt_pch_n_7rtx_def ((*x).infinite);
|
|
gt_pch_n_7rtx_def ((*x).niter_expr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_loop_exit_hasher_ (void *x_p)
|
|
{
|
|
hash_table<loop_exit_hasher> * const x = (hash_table<loop_exit_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_28hash_table_loop_exit_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop_exit_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct loop_exit_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_basic_block_va_gc_ (void *x_p)
|
|
{
|
|
vec<basic_block,va_gc> * const x = (vec<basic_block,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_22vec_basic_block_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct basic_block_def *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_basic_block_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_rtl_bb_info (void *x_p)
|
|
{
|
|
struct rtl_bb_info * const x = (struct rtl_bb_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11rtl_bb_info))
|
|
{
|
|
gt_pch_n_7rtx_def ((*x).end_);
|
|
gt_pch_n_7rtx_def ((*x).header_);
|
|
gt_pch_n_7rtx_def ((*x).footer_);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_edge_va_gc_ (void *x_p)
|
|
{
|
|
vec<edge,va_gc> * const x = (vec<edge,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15vec_edge_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (edge_def *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_edge_def ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_section_hash_entry (void *x_p)
|
|
{
|
|
struct section_hash_entry * const x = (struct section_hash_entry *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_18section_hash_entry))
|
|
{
|
|
gt_pch_n_S ((*x).name);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct section_hash_entry& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct section_hash_entry * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_S ((*x).name);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct section_hash_entry *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_section_hash_entry ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_lto_file_decl_data (void *x_p)
|
|
{
|
|
struct lto_file_decl_data * const x = (struct lto_file_decl_data *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_18lto_file_decl_data))
|
|
{
|
|
gt_pch_n_17lto_in_decl_state ((*x).current_decl_state);
|
|
gt_pch_n_17lto_in_decl_state ((*x).global_decl_state);
|
|
gt_pch_n_29hash_table_decl_state_hasher_ ((*x).function_decl_states);
|
|
gt_pch_n_18lto_file_decl_data ((*x).next);
|
|
gt_pch_n_S ((*x).mode_table);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_replace_map (void *x_p)
|
|
{
|
|
struct ipa_replace_map * const x = (struct ipa_replace_map *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15ipa_replace_map))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).new_tree);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cgraph_simd_clone (void *x_p)
|
|
{
|
|
struct cgraph_simd_clone * const x = (struct cgraph_simd_clone *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_17cgraph_simd_clone))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(((*x)).nargs);
|
|
gt_pch_n_11symtab_node ((*x).prev_clone);
|
|
gt_pch_n_11symtab_node ((*x).next_clone);
|
|
gt_pch_n_11symtab_node ((*x).origin);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_9tree_node ((*x).args[i0].orig_arg);
|
|
gt_pch_n_9tree_node ((*x).args[i0].orig_type);
|
|
gt_pch_n_9tree_node ((*x).args[i0].vector_arg);
|
|
gt_pch_n_9tree_node ((*x).args[i0].vector_type);
|
|
gt_pch_n_9tree_node ((*x).args[i0].simd_array);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cgraph_function_version_info (void *x_p)
|
|
{
|
|
struct cgraph_function_version_info * const x = (struct cgraph_function_version_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_28cgraph_function_version_info))
|
|
{
|
|
gt_pch_n_11symtab_node ((*x).this_node);
|
|
gt_pch_n_28cgraph_function_version_info ((*x).prev);
|
|
gt_pch_n_28cgraph_function_version_info ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).dispatcher_resolver);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_function_version_info& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_function_version_info * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_11symtab_node ((*x).this_node);
|
|
gt_pch_n_28cgraph_function_version_info ((*x).prev);
|
|
gt_pch_n_28cgraph_function_version_info ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).dispatcher_resolver);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_function_version_info *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_cgraph_function_version_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_cgraph_edge_hasher_ (void *x_p)
|
|
{
|
|
hash_table<cgraph_edge_hasher> * const x = (hash_table<cgraph_edge_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_30hash_table_cgraph_edge_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_edge_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct cgraph_edge_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_cgraph_indirect_call_info (void *x_p)
|
|
{
|
|
struct cgraph_indirect_call_info * const x = (struct cgraph_indirect_call_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_25cgraph_indirect_call_info))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).context.outer_type);
|
|
gt_pch_n_9tree_node ((*x).context.speculative_outer_type);
|
|
gt_pch_n_9tree_node ((*x).otr_type);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_asm_node (void *x_p)
|
|
{
|
|
struct asm_node * const x = (struct asm_node *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_8asm_node))
|
|
{
|
|
gt_pch_n_8asm_node ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).asm_str);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_thunk_info (void *x_p)
|
|
{
|
|
struct thunk_info * const x = (struct thunk_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10thunk_info))
|
|
{
|
|
gt_pch_n_9tree_node ((*x).alias);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_function_summary_thunk_info__ (void *x_p)
|
|
{
|
|
function_summary<thunk_info*> * const x = (function_summary<thunk_info*> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_29function_summary_thunk_info__))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct thunk_info *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_thunk_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_clone_info (void *x_p)
|
|
{
|
|
struct clone_info * const x = (struct clone_info *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10clone_info))
|
|
{
|
|
gt_pch_n_27vec_ipa_replace_map__va_gc_ ((*x).tree_map);
|
|
gt_pch_n_21ipa_param_adjustments ((*x).param_adjustments);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_function_summary_clone_info__ (void *x_p)
|
|
{
|
|
function_summary<clone_info*> * const x = (function_summary<clone_info*> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_29function_summary_clone_info__))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct clone_info *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_clone_info ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_symbol_table (void *x_p)
|
|
{
|
|
struct symbol_table * const x = (struct symbol_table *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12symbol_table))
|
|
{
|
|
gt_pch_n_11symtab_node ((*x).nodes);
|
|
gt_pch_n_8asm_node ((*x).asmnodes);
|
|
gt_pch_n_8asm_node ((*x).asm_last_node);
|
|
gt_pch_n_31hash_table_section_name_hasher_ ((*x).section_hash);
|
|
gt_pch_n_26hash_table_asmname_hasher_ ((*x).assembler_name_hash);
|
|
gt_pch_n_42hash_map_symtab_node__symbol_priority_map_ ((*x).init_priority_hash);
|
|
gt_pch_n_29function_summary_thunk_info__ ((*x).m_thunks);
|
|
gt_pch_n_29function_summary_clone_info__ ((*x).m_clones);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_section_name_hasher_ (void *x_p)
|
|
{
|
|
hash_table<section_name_hasher> * const x = (hash_table<section_name_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_31hash_table_section_name_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct section_name_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct section_name_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_asmname_hasher_ (void *x_p)
|
|
{
|
|
hash_table<asmname_hasher> * const x = (hash_table<asmname_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26hash_table_asmname_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct asmname_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct asmname_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_symtab_node__symbol_priority_map_ (void *x_p)
|
|
{
|
|
hash_map<symtab_node*,symbol_priority_map> * const x = (hash_map<symtab_node*,symbol_priority_map> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_42hash_map_symtab_node__symbol_priority_map_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct symbol_priority_map& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct symbol_priority_map * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct symtab_node *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_symtab_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_constant_descriptor_tree (void *x_p)
|
|
{
|
|
struct constant_descriptor_tree * const x = (struct constant_descriptor_tree *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_24constant_descriptor_tree))
|
|
{
|
|
gt_pch_n_7rtx_def ((*x).rtl);
|
|
gt_pch_n_9tree_node ((*x).value);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct constant_descriptor_tree& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct constant_descriptor_tree * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_7rtx_def ((*x).rtl);
|
|
gt_pch_n_9tree_node ((*x).value);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct constant_descriptor_tree *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_constant_descriptor_tree ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_replace_map__va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_replace_map*,va_gc> * const x = (vec<ipa_replace_map*,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27vec_ipa_replace_map__va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_replace_map *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipa_replace_map ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_param_adjustments (void *x_p)
|
|
{
|
|
struct ipa_param_adjustments * const x = (struct ipa_param_adjustments *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_21ipa_param_adjustments))
|
|
{
|
|
gt_pch_n_29vec_ipa_adjusted_param_va_gc_ ((*x).m_adj_params);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_lto_in_decl_state (void *x_p)
|
|
{
|
|
struct lto_in_decl_state * const x = (struct lto_in_decl_state *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_17lto_in_decl_state))
|
|
{
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).streams[i0]);
|
|
}
|
|
}
|
|
gt_pch_n_9tree_node ((*x).fn_decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct lto_in_decl_state& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct lto_in_decl_state * ATTRIBUTE_UNUSED x = &x_r;
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
gt_pch_n_15vec_tree_va_gc_ ((*x).streams[i1]);
|
|
}
|
|
}
|
|
gt_pch_n_9tree_node ((*x).fn_decl);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct lto_in_decl_state *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_lto_in_decl_state ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_node_params (void *x_p)
|
|
{
|
|
struct ipa_node_params * const x = (struct ipa_node_params *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15ipa_node_params))
|
|
{
|
|
gt_pch_n_31vec_ipa_param_descriptor_va_gc_ ((*x).descriptors);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_node_params& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_node_params * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_31vec_ipa_param_descriptor_va_gc_ ((*x).descriptors);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_node_params *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipa_node_params ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_edge_args (void *x_p)
|
|
{
|
|
struct ipa_edge_args * const x = (struct ipa_edge_args *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_13ipa_edge_args))
|
|
{
|
|
gt_pch_n_24vec_ipa_jump_func_va_gc_ ((*x).jump_functions);
|
|
gt_pch_n_39vec_ipa_polymorphic_call_context_va_gc_ ((*x).polymorphic_call_contexts);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_edge_args& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_edge_args * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_24vec_ipa_jump_func_va_gc_ ((*x).jump_functions);
|
|
gt_pch_n_39vec_ipa_polymorphic_call_context_va_gc_ ((*x).polymorphic_call_contexts);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_edge_args *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipa_edge_args ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_agg_replacement_value (void *x_p)
|
|
{
|
|
struct ipa_agg_replacement_value * const x = (struct ipa_agg_replacement_value *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_25ipa_agg_replacement_value))
|
|
{
|
|
gt_pch_n_25ipa_agg_replacement_value ((*x).next);
|
|
gt_pch_n_9tree_node ((*x).value);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_fn_summary (void *x_p)
|
|
{
|
|
struct ipa_fn_summary * const x = (struct ipa_fn_summary *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14ipa_fn_summary))
|
|
{
|
|
gt_pch_n_20vec_condition_va_gc_ ((*x).conds);
|
|
gt_pch_n_37vec_ipa_freqcounting_predicate_va_gc_ ((*x).loop_iterations);
|
|
gt_pch_n_37vec_ipa_freqcounting_predicate_va_gc_ ((*x).loop_strides);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_adjusted_param_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_adjusted_param,va_gc> * const x = (vec<ipa_adjusted_param,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_29vec_ipa_adjusted_param_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_adjusted_param& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_adjusted_param * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
gt_pch_n_9tree_node ((*x).alias_ptr_type);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_modref_tree_alias_set_type_ (void *x_p)
|
|
{
|
|
modref_tree<alias_set_type> * const x = (modref_tree<alias_set_type> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27modref_tree_alias_set_type_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_modref_summary (void *x_p)
|
|
{
|
|
struct modref_summary * const x = (struct modref_summary *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_14modref_summary))
|
|
{
|
|
gt_pch_n_27modref_tree_alias_set_type_ ((*x).loads);
|
|
gt_pch_n_27modref_tree_alias_set_type_ ((*x).stores);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_location_hash_nowarn_spec_t_ (void *x_p)
|
|
{
|
|
hash_map<location_hash,nowarn_spec_t> * const x = (hash_map<location_hash,nowarn_spec_t> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_37hash_map_location_hash_nowarn_spec_t_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct nowarn_spec_t& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct nowarn_spec_t * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_dw_cfi_node (void *x_p)
|
|
{
|
|
struct dw_cfi_node * const x = (struct dw_cfi_node *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11dw_cfi_node))
|
|
{
|
|
switch ((int) (dw_cfi_oprnd1_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
gt_pch_n_S ((*x).dw_cfi_oprnd1.dw_cfi_addr);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
gt_pch_n_17dw_loc_descr_node ((*x).dw_cfi_oprnd1.dw_cfi_loc);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
gt_pch_n_15dw_cfa_location ((*x).dw_cfi_oprnd1.dw_cfi_cfa_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (dw_cfi_oprnd2_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
gt_pch_n_S ((*x).dw_cfi_oprnd2.dw_cfi_addr);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
gt_pch_n_17dw_loc_descr_node ((*x).dw_cfi_oprnd2.dw_cfi_loc);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
gt_pch_n_15dw_cfa_location ((*x).dw_cfi_oprnd2.dw_cfi_cfa_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_dw_loc_descr_node (void *x_p)
|
|
{
|
|
struct dw_loc_descr_node * x = (struct dw_loc_descr_node *)x_p;
|
|
struct dw_loc_descr_node * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_17dw_loc_descr_node))
|
|
xlimit = ((*xlimit).dw_loc_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_17dw_loc_descr_node ((*x).dw_loc_next);
|
|
gt_pch_n_16addr_table_entry ((*x).dw_loc_oprnd1.val_entry);
|
|
switch ((int) (((*x).dw_loc_oprnd1).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
gt_pch_n_7rtx_def ((*x).dw_loc_oprnd1.v.val_addr);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
gt_pch_n_18dw_loc_list_struct ((*x).dw_loc_oprnd1.v.val_loc_list);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
gt_pch_n_10die_struct ((*x).dw_loc_oprnd1.v.val_view_list);
|
|
break;
|
|
case dw_val_class_loc:
|
|
gt_pch_n_17dw_loc_descr_node ((*x).dw_loc_oprnd1.v.val_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
gt_pch_n_34generic_wide_int_wide_int_storage_ ((*x).dw_loc_oprnd1.v.val_wide);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd1.v.val_vec.array != NULL) {
|
|
gt_pch_note_object ((*x).dw_loc_oprnd1.v.val_vec.array, x, gt_pch_p_17dw_loc_descr_node);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
gt_pch_n_10die_struct ((*x).dw_loc_oprnd1.v.val_die_ref.die);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
gt_pch_n_20indirect_string_node ((*x).dw_loc_oprnd1.v.val_str);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd1.v.val_lbl_id);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
gt_pch_n_15dwarf_file_data ((*x).dw_loc_oprnd1.v.val_file);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
gt_pch_n_15dwarf_file_data ((*x).dw_loc_oprnd1.v.val_file_implicit);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
gt_pch_n_9tree_node ((*x).dw_loc_oprnd1.v.val_decl_ref);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd1.v.val_vms_delta.lbl1);
|
|
gt_pch_n_S ((*x).dw_loc_oprnd1.v.val_vms_delta.lbl2);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd1.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
gt_pch_n_18dw_discr_list_node ((*x).dw_loc_oprnd1.v.val_discr_list);
|
|
break;
|
|
case dw_val_class_symview:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd1.v.val_symbolic_view);
|
|
break;
|
|
}
|
|
gt_pch_n_16addr_table_entry ((*x).dw_loc_oprnd2.val_entry);
|
|
switch ((int) (((*x).dw_loc_oprnd2).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
gt_pch_n_7rtx_def ((*x).dw_loc_oprnd2.v.val_addr);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
gt_pch_n_18dw_loc_list_struct ((*x).dw_loc_oprnd2.v.val_loc_list);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
gt_pch_n_10die_struct ((*x).dw_loc_oprnd2.v.val_view_list);
|
|
break;
|
|
case dw_val_class_loc:
|
|
gt_pch_n_17dw_loc_descr_node ((*x).dw_loc_oprnd2.v.val_loc);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
gt_pch_n_34generic_wide_int_wide_int_storage_ ((*x).dw_loc_oprnd2.v.val_wide);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd2.v.val_vec.array != NULL) {
|
|
gt_pch_note_object ((*x).dw_loc_oprnd2.v.val_vec.array, x, gt_pch_p_17dw_loc_descr_node);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
gt_pch_n_10die_struct ((*x).dw_loc_oprnd2.v.val_die_ref.die);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
gt_pch_n_20indirect_string_node ((*x).dw_loc_oprnd2.v.val_str);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd2.v.val_lbl_id);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
gt_pch_n_15dwarf_file_data ((*x).dw_loc_oprnd2.v.val_file);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
gt_pch_n_15dwarf_file_data ((*x).dw_loc_oprnd2.v.val_file_implicit);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
gt_pch_n_9tree_node ((*x).dw_loc_oprnd2.v.val_decl_ref);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd2.v.val_vms_delta.lbl1);
|
|
gt_pch_n_S ((*x).dw_loc_oprnd2.v.val_vms_delta.lbl2);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd2.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
gt_pch_n_18dw_discr_list_node ((*x).dw_loc_oprnd2.v.val_discr_list);
|
|
break;
|
|
case dw_val_class_symview:
|
|
gt_pch_n_S ((*x).dw_loc_oprnd2.v.val_symbolic_view);
|
|
break;
|
|
}
|
|
x = ((*x).dw_loc_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_dw_discr_list_node (void *x_p)
|
|
{
|
|
struct dw_discr_list_node * const x = (struct dw_discr_list_node *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_18dw_discr_list_node))
|
|
{
|
|
gt_pch_n_18dw_discr_list_node ((*x).dw_discr_next);
|
|
switch ((int) (((*x).dw_discr_lower_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x).dw_discr_upper_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_dw_cfi_ref_va_gc_ (void *x_p)
|
|
{
|
|
vec<dw_cfi_ref,va_gc> * const x = (vec<dw_cfi_ref,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_21vec_dw_cfi_ref_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct dw_cfi_node *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_dw_cfi_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_dwarf_file_data (void *x_p)
|
|
{
|
|
struct dwarf_file_data * const x = (struct dwarf_file_data *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15dwarf_file_data))
|
|
{
|
|
gt_pch_n_S ((*x).key);
|
|
gt_pch_n_S ((*x).filename);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct dwarf_file_data& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct dwarf_file_data * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_S ((*x).key);
|
|
gt_pch_n_S ((*x).filename);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct dwarf_file_data *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_dwarf_file_data ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_string (void *x_p)
|
|
{
|
|
struct ctf_string * x = (struct ctf_string *)x_p;
|
|
struct ctf_string * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_10ctf_string))
|
|
xlimit = ((*xlimit).cts_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_S ((*x).cts_str);
|
|
gt_pch_n_10ctf_string ((*x).cts_next);
|
|
x = ((*x).cts_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_dmdef (void *x_p)
|
|
{
|
|
struct ctf_dmdef * x = (struct ctf_dmdef *)x_p;
|
|
struct ctf_dmdef * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_9ctf_dmdef))
|
|
xlimit = ((*xlimit).dmd_next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_S ((*x).dmd_name);
|
|
gt_pch_n_9ctf_dmdef ((*x).dmd_next);
|
|
x = ((*x).dmd_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_func_arg (void *x_p)
|
|
{
|
|
struct ctf_func_arg * const x = (struct ctf_func_arg *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12ctf_func_arg))
|
|
{
|
|
gt_pch_n_S ((*x).farg_name);
|
|
gt_pch_n_12ctf_func_arg ((*x).farg_next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_dtdef (void *x_p)
|
|
{
|
|
struct ctf_dtdef * const x = (struct ctf_dtdef *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9ctf_dtdef))
|
|
{
|
|
gt_pch_n_10die_struct ((*x).dtd_key);
|
|
gt_pch_n_S ((*x).dtd_name);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
gt_pch_n_9ctf_dmdef ((*x).dtd_u.dtu_members);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
gt_pch_n_12ctf_func_arg ((*x).dtd_u.dtu_argv);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dtdef& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctf_dtdef * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_10die_struct ((*x).dtd_key);
|
|
gt_pch_n_S ((*x).dtd_name);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
gt_pch_n_9ctf_dmdef ((*x).dtd_u.dtu_members);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
gt_pch_n_12ctf_func_arg ((*x).dtd_u.dtu_argv);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dtdef *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ctf_dtdef ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_dvdef (void *x_p)
|
|
{
|
|
struct ctf_dvdef * const x = (struct ctf_dvdef *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_9ctf_dvdef))
|
|
{
|
|
gt_pch_n_10die_struct ((*x).dvd_key);
|
|
gt_pch_n_S ((*x).dvd_name);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dvdef& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctf_dvdef * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_10die_struct ((*x).dvd_key);
|
|
gt_pch_n_S ((*x).dvd_name);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dvdef *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ctf_dvdef ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_ctfc_dtd_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ctfc_dtd_hasher> * const x = (hash_table<ctfc_dtd_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27hash_table_ctfc_dtd_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctfc_dtd_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctfc_dtd_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_ctfc_dvd_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ctfc_dvd_hasher> * const x = (hash_table<ctfc_dvd_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27hash_table_ctfc_dvd_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctfc_dvd_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ctfc_dvd_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ctf_container (void *x_p)
|
|
{
|
|
struct ctf_container * const x = (struct ctf_container *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_13ctf_container))
|
|
{
|
|
{
|
|
size_t l0 = (size_t)(0);
|
|
size_t l1 = (size_t)(0);
|
|
size_t l2 = (size_t)(0);
|
|
size_t l3 = (size_t)(0);
|
|
gt_pch_n_27hash_table_ctfc_dtd_hasher_ ((*x).ctfc_types);
|
|
gt_pch_n_27hash_table_ctfc_dvd_hasher_ ((*x).ctfc_vars);
|
|
gt_pch_n_27hash_table_ctfc_dvd_hasher_ ((*x).ctfc_ignore_vars);
|
|
gt_pch_n_10ctf_string ((*x).ctfc_strtable.ctstab_head);
|
|
gt_pch_n_10ctf_string ((*x).ctfc_strtable.ctstab_tail);
|
|
gt_pch_n_S ((*x).ctfc_strtable.ctstab_estr);
|
|
gt_pch_n_10ctf_string ((*x).ctfc_aux_strtable.ctstab_head);
|
|
gt_pch_n_10ctf_string ((*x).ctfc_aux_strtable.ctstab_tail);
|
|
gt_pch_n_S ((*x).ctfc_aux_strtable.ctstab_estr);
|
|
if ((*x).ctfc_vars_list != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0); i0++) {
|
|
gt_pch_n_9ctf_dvdef ((*x).ctfc_vars_list[i0]);
|
|
}
|
|
gt_pch_note_object ((*x).ctfc_vars_list, x, gt_pch_p_13ctf_container);
|
|
}
|
|
if ((*x).ctfc_types_list != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1); i1++) {
|
|
gt_pch_n_9ctf_dtdef ((*x).ctfc_types_list[i1]);
|
|
}
|
|
gt_pch_note_object ((*x).ctfc_types_list, x, gt_pch_p_13ctf_container);
|
|
}
|
|
if ((*x).ctfc_gfuncs_list != NULL) {
|
|
size_t i2;
|
|
for (i2 = 0; i2 != (size_t)(l2); i2++) {
|
|
gt_pch_n_9ctf_dtdef ((*x).ctfc_gfuncs_list[i2]);
|
|
}
|
|
gt_pch_note_object ((*x).ctfc_gfuncs_list, x, gt_pch_p_13ctf_container);
|
|
}
|
|
if ((*x).ctfc_gobjts_list != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3); i3++) {
|
|
gt_pch_n_9ctf_dvdef ((*x).ctfc_gobjts_list[i3]);
|
|
}
|
|
gt_pch_note_object ((*x).ctfc_gobjts_list, x, gt_pch_p_13ctf_container);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_temp_slot_p_va_gc_ (void *x_p)
|
|
{
|
|
vec<temp_slot_p,va_gc> * const x = (vec<temp_slot_p,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_22vec_temp_slot_p_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct temp_slot *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_temp_slot ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_eh_region_d (void *x_p)
|
|
{
|
|
struct eh_region_d * const x = (struct eh_region_d *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_11eh_region_d))
|
|
{
|
|
gt_pch_n_11eh_region_d ((*x).outer);
|
|
gt_pch_n_11eh_region_d ((*x).inner);
|
|
gt_pch_n_11eh_region_d ((*x).next_peer);
|
|
switch ((int) ((*x).type))
|
|
{
|
|
case ERT_TRY:
|
|
gt_pch_n_10eh_catch_d ((*x).u.eh_try.first_catch);
|
|
gt_pch_n_10eh_catch_d ((*x).u.eh_try.last_catch);
|
|
break;
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
|
gt_pch_n_9tree_node ((*x).u.allowed.type_list);
|
|
gt_pch_n_9tree_node ((*x).u.allowed.label);
|
|
break;
|
|
case ERT_MUST_NOT_THROW:
|
|
gt_pch_n_9tree_node ((*x).u.must_not_throw.failure_decl);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
gt_pch_n_16eh_landing_pad_d ((*x).landing_pads);
|
|
gt_pch_n_7rtx_def ((*x).exc_ptr_reg);
|
|
gt_pch_n_7rtx_def ((*x).filter_reg);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_eh_landing_pad_d (void *x_p)
|
|
{
|
|
struct eh_landing_pad_d * const x = (struct eh_landing_pad_d *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_16eh_landing_pad_d))
|
|
{
|
|
gt_pch_n_16eh_landing_pad_d ((*x).next_lp);
|
|
gt_pch_n_11eh_region_d ((*x).region);
|
|
gt_pch_n_9tree_node ((*x).post_landing_pad);
|
|
gt_pch_n_7rtx_def ((*x).landing_pad);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_eh_catch_d (void *x_p)
|
|
{
|
|
struct eh_catch_d * const x = (struct eh_catch_d *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_10eh_catch_d))
|
|
{
|
|
gt_pch_n_10eh_catch_d ((*x).next_catch);
|
|
gt_pch_n_10eh_catch_d ((*x).prev_catch);
|
|
gt_pch_n_9tree_node ((*x).type_list);
|
|
gt_pch_n_9tree_node ((*x).filter_list);
|
|
gt_pch_n_9tree_node ((*x).label);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_eh_region_va_gc_ (void *x_p)
|
|
{
|
|
vec<eh_region,va_gc> * const x = (vec<eh_region,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_20vec_eh_region_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct eh_region_d *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_eh_region_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_eh_landing_pad_va_gc_ (void *x_p)
|
|
{
|
|
vec<eh_landing_pad,va_gc> * const x = (vec<eh_landing_pad,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_25vec_eh_landing_pad_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct eh_landing_pad_d *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_eh_landing_pad_d ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_gimple__int_ (void *x_p)
|
|
{
|
|
hash_map<gimple*,int> * const x = (hash_map<gimple*,int> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_21hash_map_gimple__int_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct gimple *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_gimple ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_tm_restart_node (void *x_p)
|
|
{
|
|
struct tm_restart_node * const x = (struct tm_restart_node *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_15tm_restart_node))
|
|
{
|
|
gt_pch_n_6gimple ((*x).stmt);
|
|
gt_pch_n_9tree_node ((*x).label_or_list);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tm_restart_node& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tm_restart_node * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_6gimple ((*x).stmt);
|
|
gt_pch_n_9tree_node ((*x).label_or_list);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tm_restart_node *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_tm_restart_node ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_map_tree_tree_ (void *x_p)
|
|
{
|
|
hash_map<tree,tree> * const x = (hash_map<tree,tree> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_19hash_map_tree_tree_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_ssa_name_hasher_ (void *x_p)
|
|
{
|
|
hash_table<ssa_name_hasher> * const x = (hash_table<ssa_name_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_27hash_table_ssa_name_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ssa_name_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ssa_name_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_tm_restart_hasher_ (void *x_p)
|
|
{
|
|
hash_table<tm_restart_hasher> * const x = (hash_table<tm_restart_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_29hash_table_tm_restart_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tm_restart_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct tm_restart_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ssa_operand_memory_d (void *x_p)
|
|
{
|
|
struct ssa_operand_memory_d * x = (struct ssa_operand_memory_d *)x_p;
|
|
struct ssa_operand_memory_d * xlimit = x;
|
|
while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_20ssa_operand_memory_d))
|
|
xlimit = ((*xlimit).next);
|
|
while (x != xlimit)
|
|
{
|
|
gt_pch_n_20ssa_operand_memory_d ((*x).next);
|
|
x = ((*x).next);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_int_range_1_ (void *x_p)
|
|
{
|
|
int_range<1> * const x = (int_range<1> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_12int_range_1_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_agg_jf_item_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_agg_jf_item,va_gc> * const x = (vec<ipa_agg_jf_item,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_26vec_ipa_agg_jf_item_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_agg_jf_item& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_agg_jf_item * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
switch ((int) (((*x)).jftype))
|
|
{
|
|
case IPA_JF_CONST:
|
|
gt_pch_n_9tree_node ((*x).value.constant);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
gt_pch_n_9tree_node ((*x).value.pass_through.operand);
|
|
break;
|
|
case IPA_JF_LOAD_AGG:
|
|
gt_pch_n_9tree_node ((*x).value.load_agg.pass_through.operand);
|
|
gt_pch_n_9tree_node ((*x).value.load_agg.type);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_bits (void *x_p)
|
|
{
|
|
struct ipa_bits * const x = (struct ipa_bits *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_8ipa_bits))
|
|
{
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_param_descriptor_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_param_descriptor,va_gc> * const x = (vec<ipa_param_descriptor,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_31vec_ipa_param_descriptor_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_param_descriptor& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_param_descriptor * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).decl_or_type);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_bits__va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_bits*,va_gc> * const x = (vec<ipa_bits*,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_20vec_ipa_bits__va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_bits *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipa_bits ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_vr_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_vr,va_gc> * const x = (vec<ipa_vr,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_17vec_ipa_vr_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_vr& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_vr * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_nx (&((*x).min));
|
|
gt_pch_nx (&((*x).max));
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipcp_transformation (void *x_p)
|
|
{
|
|
struct ipcp_transformation * const x = (struct ipcp_transformation *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_19ipcp_transformation))
|
|
{
|
|
gt_pch_n_25ipa_agg_replacement_value ((*x).agg_values);
|
|
gt_pch_n_20vec_ipa_bits__va_gc_ ((*x).bits);
|
|
gt_pch_n_17vec_ipa_vr_va_gc_ ((*x).m_vr);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_jump_func_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_jump_func,va_gc> * const x = (vec<ipa_jump_func,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_24vec_ipa_jump_func_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_jump_func& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_jump_func * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_26vec_ipa_agg_jf_item_va_gc_ ((*x).agg.items);
|
|
gt_pch_n_8ipa_bits ((*x).bits);
|
|
gt_pch_n_12int_range_1_ ((*x).m_vr);
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case IPA_JF_CONST:
|
|
gt_pch_n_9tree_node ((*x).value.constant.value);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
gt_pch_n_9tree_node ((*x).value.pass_through.operand);
|
|
break;
|
|
case IPA_JF_ANCESTOR:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_polymorphic_call_context_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_polymorphic_call_context,va_gc> * const x = (vec<ipa_polymorphic_call_context,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_39vec_ipa_polymorphic_call_context_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_polymorphic_call_context& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_polymorphic_call_context * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).outer_type);
|
|
gt_pch_n_9tree_node ((*x).speculative_outer_type);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_node_params_t (void *x_p)
|
|
{
|
|
ipa_node_params_t * const x = (ipa_node_params_t *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_17ipa_node_params_t))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_ipa_edge_args_sum_t (void *x_p)
|
|
{
|
|
ipa_edge_args_sum_t * const x = (ipa_edge_args_sum_t *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_19ipa_edge_args_sum_t))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_function_summary_ipcp_transformation__ (void *x_p)
|
|
{
|
|
function_summary<ipcp_transformation*> * const x = (function_summary<ipcp_transformation*> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_38function_summary_ipcp_transformation__))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipcp_transformation *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipcp_transformation ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_hash_table_decl_state_hasher_ (void *x_p)
|
|
{
|
|
hash_table<decl_state_hasher> * const x = (hash_table<decl_state_hasher> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_29hash_table_decl_state_hasher_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_state_hasher& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct decl_state_hasher * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_expr_eval_op_va_gc_ (void *x_p)
|
|
{
|
|
vec<expr_eval_op,va_gc> * const x = (vec<expr_eval_op,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_23vec_expr_eval_op_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct expr_eval_op& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct expr_eval_op * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(2);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
gt_pch_n_9tree_node ((*x).val[i0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_condition_va_gc_ (void *x_p)
|
|
{
|
|
vec<condition,va_gc> * const x = (vec<condition,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_20vec_condition_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct condition& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct condition * ATTRIBUTE_UNUSED x = &x_r;
|
|
gt_pch_n_9tree_node ((*x).type);
|
|
gt_pch_n_9tree_node ((*x).val);
|
|
gt_pch_n_23vec_expr_eval_op_va_gc_ ((*x).param_ops);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_vec_ipa_freqcounting_predicate_va_gc_ (void *x_p)
|
|
{
|
|
vec<ipa_freqcounting_predicate,va_gc> * const x = (vec<ipa_freqcounting_predicate,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_37vec_ipa_freqcounting_predicate_va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_freqcounting_predicate& x_r ATTRIBUTE_UNUSED)
|
|
{
|
|
struct ipa_freqcounting_predicate * ATTRIBUTE_UNUSED x = &x_r;
|
|
}
|
|
|
|
void
|
|
gt_pch_nx_fast_function_summary_ipa_fn_summary__va_gc_ (void *x_p)
|
|
{
|
|
fast_function_summary<ipa_fn_summary*,va_gc> * const x = (fast_function_summary<ipa_fn_summary*,va_gc> *)x_p;
|
|
if (gt_pch_note_object (x, x, gt_pch_p_44fast_function_summary_ipa_fn_summary__va_gc_))
|
|
{
|
|
gt_pch_nx (x);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_fn_summary *& x)
|
|
{
|
|
if (x)
|
|
gt_pch_nx_ipa_fn_summary ((void *) x);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9line_maps (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct line_maps * x ATTRIBUTE_UNUSED = (struct line_maps *)x_p;
|
|
{
|
|
size_t l0 = (size_t)(((*x).info_ordinary).used);
|
|
if ((*x).info_ordinary.maps != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0) && ((void *)(*x).info_ordinary.maps == this_obj); i0++) {
|
|
if ((void *)((*x).info_ordinary.maps) == this_obj)
|
|
op (&((*x).info_ordinary.maps[i0].to_file), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).info_ordinary.maps), NULL, cookie);
|
|
}
|
|
}
|
|
{
|
|
size_t l1 = (size_t)(((*x).info_macro).used);
|
|
if ((*x).info_macro.maps != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1) && ((void *)(*x).info_macro.maps == this_obj); i1++) {
|
|
{
|
|
union tree_node * x2 =
|
|
((*x).info_macro.maps[i1].macro) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).info_macro.maps[i1].macro))) : NULL;
|
|
if ((void *)((*x).info_macro.maps) == this_obj)
|
|
op (&(x2), &((*x).info_macro.maps[i1].macro), cookie);
|
|
(*x).info_macro.maps[i1].macro = (x2) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x2))) : NULL;
|
|
}
|
|
if ((*x).info_macro.maps[i1].macro_locations != NULL) {
|
|
if ((void *)((*x).info_macro.maps) == this_obj)
|
|
op (&((*x).info_macro.maps[i1].macro_locations), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).info_macro.maps), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_note_callback (&((*x).reallocator), this_obj);
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_note_callback (&((*x).round_alloc_size), this_obj);
|
|
{
|
|
size_t l3 = (size_t)(((*x).location_adhoc_data_map).allocated);
|
|
if ((*x).location_adhoc_data_map.data != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3) && ((void *)(*x).location_adhoc_data_map.data == this_obj); i3++) {
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).location_adhoc_data_map.data), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9cpp_token (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cpp_token * x ATTRIBUTE_UNUSED = (struct cpp_token *)x_p;
|
|
switch ((int) (cpp_token_val_index (&((*x)))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * x0 =
|
|
((*x).val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.node))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x0), &((*x).val.node.node), cookie);
|
|
(*x).val.node.node = (x0) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x0))) : NULL;
|
|
}
|
|
{
|
|
union tree_node * x1 =
|
|
((*x).val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.node.spelling))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x1), &((*x).val.node.spelling), cookie);
|
|
(*x).val.node.spelling = (x1) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x1))) : NULL;
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).val.source), NULL, cookie);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).val.str.text), NULL, cookie);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * x2 =
|
|
((*x).val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).val.macro_arg.spelling))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x2), &((*x).val.macro_arg.spelling), cookie);
|
|
(*x).val.macro_arg.spelling = (x2) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x2))) : NULL;
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9cpp_macro (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cpp_macro * x ATTRIBUTE_UNUSED = (struct cpp_macro *)x_p;
|
|
switch ((int) (((*x)).kind == cmk_assert))
|
|
{
|
|
case false:
|
|
if ((*x).parm.params != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(((*x)).paramc) && ((void *)(*x).parm.params == this_obj); i0++) {
|
|
{
|
|
union tree_node * x1 =
|
|
((*x).parm.params[i0]) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).parm.params[i0]))) : NULL;
|
|
if ((void *)((*x).parm.params) == this_obj)
|
|
op (&(x1), &((*x).parm.params[i0]), cookie);
|
|
(*x).parm.params[i0] = (x1) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x1))) : NULL;
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).parm.params), NULL, cookie);
|
|
}
|
|
break;
|
|
case true:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).parm.next), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x)).kind == cmk_traditional))
|
|
{
|
|
case false:
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(((*x)).count);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
switch ((int) (cpp_token_val_index (&((*x).exp.tokens[i2]))))
|
|
{
|
|
case CPP_TOKEN_FLD_NODE:
|
|
{
|
|
union tree_node * x3 =
|
|
((*x).exp.tokens[i2].val.node.node) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.node))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x3), &((*x).exp.tokens[i2].val.node.node), cookie);
|
|
(*x).exp.tokens[i2].val.node.node = (x3) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x3))) : NULL;
|
|
}
|
|
{
|
|
union tree_node * x4 =
|
|
((*x).exp.tokens[i2].val.node.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.node.spelling))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x4), &((*x).exp.tokens[i2].val.node.spelling), cookie);
|
|
(*x).exp.tokens[i2].val.node.spelling = (x4) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x4))) : NULL;
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_SOURCE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exp.tokens[i2].val.source), NULL, cookie);
|
|
break;
|
|
case CPP_TOKEN_FLD_STR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exp.tokens[i2].val.str.text), NULL, cookie);
|
|
break;
|
|
case CPP_TOKEN_FLD_ARG_NO:
|
|
{
|
|
union tree_node * x5 =
|
|
((*x).exp.tokens[i2].val.macro_arg.spelling) ? HT_IDENT_TO_GCC_IDENT (HT_NODE (((*x).exp.tokens[i2].val.macro_arg.spelling))) : NULL;
|
|
if ((void *)(x) == this_obj)
|
|
op (&(x5), &((*x).exp.tokens[i2].val.macro_arg.spelling), cookie);
|
|
(*x).exp.tokens[i2].val.macro_arg.spelling = (x5) ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT ((x5))) : NULL;
|
|
}
|
|
break;
|
|
case CPP_TOKEN_FLD_TOKEN_NO:
|
|
break;
|
|
case CPP_TOKEN_FLD_PRAGMA:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case true:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exp.text), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13string_concat (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct string_concat * x ATTRIBUTE_UNUSED = (struct string_concat *)x_p;
|
|
if ((*x).m_locs != NULL) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_locs), NULL, cookie);
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_16string_concat_db (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct string_concat_db * x ATTRIBUTE_UNUSED = (struct string_concat_db *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_table), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_38hash_map_location_hash_string_concat__ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<location_hash,string_concat*> * x ATTRIBUTE_UNUSED = (struct hash_map<location_hash,string_concat*> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11bitmap_head (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct bitmap_head * x ATTRIBUTE_UNUSED = (struct bitmap_head *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).first), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_7rtx_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct rtx_def * x ATTRIBUTE_UNUSED = (struct rtx_def *)x_p;
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
switch ((int) (GET_CODE (&(*x))))
|
|
{
|
|
case DEBUG_MARKER:
|
|
break;
|
|
case DEBUG_PARAMETER_REF:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_tree), NULL, cookie);
|
|
break;
|
|
case ENTRY_VALUE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case DEBUG_IMPLICIT_PTR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_tree), NULL, cookie);
|
|
break;
|
|
case VAR_LOCATION:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_tree), NULL, cookie);
|
|
break;
|
|
case FMA:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_TRUNCATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_TRUNCATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_MINUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_ASHIFT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_ASHIFT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_ABS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_NEG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_NEG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_MINUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_PLUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_PLUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case VEC_SERIES:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case VEC_DUPLICATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case VEC_CONCAT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case VEC_SELECT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case VEC_MERGE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LO_SUM:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case HIGH:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ZERO_EXTRACT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SIGN_EXTRACT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PARITY:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case POPCOUNT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CTZ:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CLZ:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CLRSB:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FFS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case BSWAP:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SQRT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ABS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNSIGNED_SAT_FRACT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SAT_FRACT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNSIGNED_FRACT_CONVERT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FRACT_CONVERT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNSIGNED_FIX:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNSIGNED_FLOAT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FIX:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FLOAT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FLOAT_TRUNCATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case FLOAT_EXTEND:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case TRUNCATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ZERO_EXTEND:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SIGN_EXTEND:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNLT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNLE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNGT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNGE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNEQ:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ORDERED:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UNORDERED:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LTU:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LEU:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case GTU:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case GEU:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LTGT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case GT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case GE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case EQ:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case NE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case POST_MODIFY:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PRE_MODIFY:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case POST_INC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case POST_DEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PRE_INC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PRE_DEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UMAX:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UMIN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SMAX:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SMIN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ROTATERT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case LSHIFTRT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ASHIFTRT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ROTATE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ASHIFT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case NOT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case XOR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case IOR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case AND:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UMOD:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UDIV:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case MOD:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_DIV:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_DIV:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case DIV:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case UMUL_HIGHPART:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SMUL_HIGHPART:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case US_MULT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SS_MULT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case MULT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case NEG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case MINUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PLUS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case COMPARE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case IF_THEN_ELSE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SYMBOL_REF:
|
|
switch ((int) (SYMBOL_REF_HAS_BLOCK_INFO_P (&(*x))))
|
|
{
|
|
case 1:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.block_sym.block), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (CONSTANT_POOL_ADDRESS_P (&(*x))))
|
|
{
|
|
case 1:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_constant), NULL, cookie);
|
|
break;
|
|
default:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_tree), NULL, cookie);
|
|
break;
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_str), NULL, cookie);
|
|
break;
|
|
case LABEL_REF:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case MEM:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_mem), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CONCATN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case CONCAT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case STRICT_LOW_PART:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SUBREG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SCRATCH:
|
|
break;
|
|
case REG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.reg.attrs), NULL, cookie);
|
|
break;
|
|
case PC:
|
|
break;
|
|
case CONST:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CONST_STRING:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_str), NULL, cookie);
|
|
break;
|
|
case CONST_VECTOR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case CONST_DOUBLE:
|
|
break;
|
|
case CONST_FIXED:
|
|
break;
|
|
case CONST_POLY_INT:
|
|
break;
|
|
case CONST_WIDE_INT:
|
|
break;
|
|
case CONST_INT:
|
|
break;
|
|
case TRAP_IF:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case EH_RETURN:
|
|
break;
|
|
case SIMPLE_RETURN:
|
|
break;
|
|
case RETURN:
|
|
break;
|
|
case CALL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CLOBBER:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case USE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case SET:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case PREFETCH:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ADDR_DIFF_VEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtvec), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ADDR_VEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case UNSPEC_VOLATILE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case UNSPEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case ASM_OPERANDS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[5].rt_rtvec), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[4].rt_rtvec), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtvec), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_str), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_str), NULL, cookie);
|
|
break;
|
|
case ASM_INPUT:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_str), NULL, cookie);
|
|
break;
|
|
case PARALLEL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case COND_EXEC:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case NOTE:
|
|
switch ((int) (NOTE_KIND (&(*x))))
|
|
{
|
|
default:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_str), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
|
|
break;
|
|
case NOTE_INSN_CFI_LABEL:
|
|
break;
|
|
case NOTE_INSN_CFI:
|
|
break;
|
|
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
|
|
break;
|
|
case NOTE_INSN_BASIC_BLOCK:
|
|
break;
|
|
case NOTE_INSN_INLINE_ENTRY:
|
|
break;
|
|
case NOTE_INSN_BEGIN_STMT:
|
|
break;
|
|
case NOTE_INSN_VAR_LOCATION:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_EH_REGION_END:
|
|
break;
|
|
case NOTE_INSN_EH_REGION_BEG:
|
|
break;
|
|
case NOTE_INSN_EPILOGUE_BEG:
|
|
break;
|
|
case NOTE_INSN_PROLOGUE_END:
|
|
break;
|
|
case NOTE_INSN_FUNCTION_BEG:
|
|
break;
|
|
case NOTE_INSN_BLOCK_END:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_tree), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_BLOCK_BEG:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_tree), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_DELETED_DEBUG_LABEL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_str), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_DELETED_LABEL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_str), NULL, cookie);
|
|
break;
|
|
case NOTE_INSN_DELETED:
|
|
break;
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CODE_LABEL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[6].rt_str), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case BARRIER:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case JUMP_TABLE_DATA:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case CALL_INSN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[7].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[6].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case JUMP_INSN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[7].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[6].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case INSN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[6].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case DEBUG_INSN:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[6].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[3].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[2].rt_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case ADDRESS:
|
|
break;
|
|
case SEQUENCE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtvec), NULL, cookie);
|
|
break;
|
|
case INT_LIST:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
break;
|
|
case INSN_LIST:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case EXPR_LIST:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[1].rt_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_rtx), NULL, cookie);
|
|
break;
|
|
case DEBUG_EXPR:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.fld[0].rt_tree), NULL, cookie);
|
|
break;
|
|
case VALUE:
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9rtvec_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct rtvec_def * x ATTRIBUTE_UNUSED = (struct rtvec_def *)x_p;
|
|
{
|
|
size_t l0 = (size_t)(((*x)).num_elem);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).elem[i0]), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_6gimple (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct gimple * x ATTRIBUTE_UNUSED = (struct gimple *)x_p;
|
|
switch ((int) (gimple_statement_structure (&((*x)))))
|
|
{
|
|
case GSS_BASE:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
break;
|
|
case GSS_WCE:
|
|
{
|
|
gimple_statement_wce *sub = static_cast <gimple_statement_wce *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).cleanup), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP:
|
|
{
|
|
gimple_statement_omp *sub = static_cast <gimple_statement_omp *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_SECTIONS:
|
|
{
|
|
gomp_sections *sub = static_cast <gomp_sections *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).control), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_PARALLEL_LAYOUT:
|
|
{
|
|
gimple_statement_omp_parallel_layout *sub = static_cast <gimple_statement_omp_parallel_layout *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).child_fn), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).data_arg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_TASK:
|
|
{
|
|
gomp_task *sub = static_cast <gomp_task *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).copy_fn), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).arg_size), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).arg_align), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).child_fn), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).data_arg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_FOR:
|
|
{
|
|
gomp_for *sub = static_cast <gomp_for *> (x);
|
|
{
|
|
size_t l0 = (size_t)(((*sub)).collapse);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((*sub).iter != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0) && ((void *)(*sub).iter == this_obj); i0++) {
|
|
if ((void *)((*sub).iter) == this_obj)
|
|
op (&((*sub).iter[i0].index), NULL, cookie);
|
|
if ((void *)((*sub).iter) == this_obj)
|
|
op (&((*sub).iter[i0].initial), NULL, cookie);
|
|
if ((void *)((*sub).iter) == this_obj)
|
|
op (&((*sub).iter[i0].final), NULL, cookie);
|
|
if ((void *)((*sub).iter) == this_obj)
|
|
op (&((*sub).iter[i0].incr), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).iter), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).pre_body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_OMP_SINGLE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_single_layout *sub = static_cast <gimple_statement_omp_single_layout *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_CRITICAL:
|
|
{
|
|
gomp_critical *sub = static_cast <gomp_critical *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clauses), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_CONTINUE:
|
|
{
|
|
gomp_continue *sub = static_cast <gomp_continue *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).control_def), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).control_use), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_STORE_LAYOUT:
|
|
{
|
|
gimple_statement_omp_atomic_store_layout *sub = static_cast <gimple_statement_omp_atomic_store_layout *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).val), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_OMP_ATOMIC_LOAD:
|
|
{
|
|
gomp_atomic_load *sub = static_cast <gomp_atomic_load *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).rhs), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).lhs), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_TRY:
|
|
{
|
|
gtry *sub = static_cast <gtry *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).eval), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).cleanup), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_PHI:
|
|
{
|
|
gphi *sub = static_cast <gphi *> (x);
|
|
{
|
|
size_t l1 = (size_t)(((*sub)).nargs);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).result), NULL, cookie);
|
|
{
|
|
size_t i1;
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).args[i1].def), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_EH_CTRL:
|
|
{
|
|
gimple_statement_eh_ctrl *sub = static_cast <gimple_statement_eh_ctrl *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_EH_ELSE:
|
|
{
|
|
geh_else *sub = static_cast <geh_else *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).n_body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).e_body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_EH_MNT:
|
|
{
|
|
geh_mnt *sub = static_cast <geh_mnt *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).fndecl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_EH_FILTER:
|
|
{
|
|
geh_filter *sub = static_cast <geh_filter *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).types), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).failure), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_CATCH:
|
|
{
|
|
gcatch *sub = static_cast <gcatch *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).types), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).handler), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_BIND:
|
|
{
|
|
gbind *sub = static_cast <gbind *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).vars), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).block), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS_BASE:
|
|
{
|
|
gimple_statement_with_memory_ops_base *sub = static_cast <gimple_statement_with_memory_ops_base *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_TRANSACTION:
|
|
{
|
|
gtransaction *sub = static_cast <gtransaction *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).label_norm), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).label_uninst), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).label_over), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
break;
|
|
case GSS_CALL:
|
|
{
|
|
gcall *sub = static_cast <gcall *> (x);
|
|
{
|
|
size_t l2 = (size_t)(((*sub)).num_ops);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).call_used.vars), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).call_clobbered.vars), NULL, cookie);
|
|
switch ((int) (((*sub)).subcode & GF_CALL_INTERNAL))
|
|
{
|
|
case 0:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).u.fntype), NULL, cookie);
|
|
break;
|
|
case GF_CALL_INTERNAL:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
{
|
|
size_t i2;
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).op[i2]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_ASM:
|
|
{
|
|
gasm *sub = static_cast <gasm *> (x);
|
|
{
|
|
size_t l3 = (size_t)(((*sub)).num_ops);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).string), NULL, cookie);
|
|
{
|
|
size_t i3;
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).op[i3]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_MEM_OPS:
|
|
{
|
|
gimple_statement_with_memory_ops *sub = static_cast <gimple_statement_with_memory_ops *> (x);
|
|
{
|
|
size_t l4 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i4;
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).op[i4]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
case GSS_WITH_OPS:
|
|
{
|
|
gimple_statement_with_ops *sub = static_cast <gimple_statement_with_ops *> (x);
|
|
{
|
|
size_t l5 = (size_t)(((*sub)).num_ops);
|
|
{
|
|
size_t i5;
|
|
for (i5 = 0; i5 != l5; i5++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).op[i5]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
}
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11symtab_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct symtab_node * x ATTRIBUTE_UNUSED = (struct symtab_node *)x_p;
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case SYMTAB_SYMBOL:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).previous), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).previous_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).same_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).alias_target), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).lto_file_data), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_section), NULL, cookie);
|
|
break;
|
|
case SYMTAB_VARIABLE:
|
|
{
|
|
varpool_node *sub = static_cast <varpool_node *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).previous), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).previous_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).same_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).alias_target), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).lto_file_data), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).x_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).x_section), NULL, cookie);
|
|
}
|
|
break;
|
|
case SYMTAB_FUNCTION:
|
|
{
|
|
cgraph_node *sub = static_cast <cgraph_node *> (x);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).callees), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).callers), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).indirect_calls), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next_sibling_clone), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).prev_sibling_clone), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clones), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).clone_of), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).call_site_hash), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).former_clone_of), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).simdclone), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).simd_clones), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).inlined_to), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).rtl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).previous), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).next_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).previous_sharing_asm_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).same_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).alias_target), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).lto_file_data), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).x_comdat_group), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*sub).x_section), NULL, cookie);
|
|
}
|
|
break;
|
|
/* Unrecognized tag value. */
|
|
default: gcc_unreachable ();
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11cgraph_edge (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cgraph_edge * x ATTRIBUTE_UNUSED = (struct cgraph_edge *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).caller), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).callee), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev_caller), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_caller), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev_callee), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_callee), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).call_stmt), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).indirect_info), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_edge* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).caller), NULL, cookie);
|
|
op (&((*x).callee), NULL, cookie);
|
|
op (&((*x).prev_caller), NULL, cookie);
|
|
op (&((*x).next_caller), NULL, cookie);
|
|
op (&((*x).prev_callee), NULL, cookie);
|
|
op (&((*x).next_callee), NULL, cookie);
|
|
op (&((*x).call_stmt), NULL, cookie);
|
|
op (&((*x).indirect_info), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_7section (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
union section * x ATTRIBUTE_UNUSED = (union section *)x_p;
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).named.name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).named.decl), NULL, cookie);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_note_callback (&((*x).unnamed.callback), this_obj);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).unnamed.data), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).unnamed.next), NULL, cookie);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_note_callback (&((*x).noswitch.callback), this_obj);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (union section* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
switch ((int) (SECTION_STYLE (&(((*x))))))
|
|
{
|
|
case SECTION_NAMED:
|
|
op (&((*x).named.name), NULL, cookie);
|
|
op (&((*x).named.decl), NULL, cookie);
|
|
break;
|
|
case SECTION_UNNAMED:
|
|
op (&((*x).unnamed.data), NULL, cookie);
|
|
op (&((*x).unnamed.next), NULL, cookie);
|
|
break;
|
|
case SECTION_NOSWITCH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_16cl_target_option (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cl_target_option * x ATTRIBUTE_UNUSED = (struct cl_target_option *)x_p;
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15cl_optimization (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cl_optimization * x ATTRIBUTE_UNUSED = (struct cl_optimization *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_str_align_functions), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_str_align_jumps), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_str_align_labels), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_str_align_loops), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_flag_patchable_function_entry), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_8edge_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct edge_def * x ATTRIBUTE_UNUSED = (struct edge_def *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15basic_block_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct basic_block_def * x ATTRIBUTE_UNUSED = (struct basic_block_def *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).preds), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).succs), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).loop_father), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev_bb), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_bb), NULL, cookie);
|
|
switch ((int) (((((*x)).flags & BB_RTL) != 0)))
|
|
{
|
|
case 0:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).il.gimple.seq), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).il.gimple.phi_nodes), NULL, cookie);
|
|
break;
|
|
case 1:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).il.x.head_), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).il.x.rtl), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14bitmap_element (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct bitmap_element * x ATTRIBUTE_UNUSED = (struct bitmap_element *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_34generic_wide_int_wide_int_storage_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct generic_wide_int<wide_int_storage> * x ATTRIBUTE_UNUSED = (struct generic_wide_int<wide_int_storage> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct wide_int_storage* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9mem_attrs (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct mem_attrs * x ATTRIBUTE_UNUSED = (struct mem_attrs *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).expr), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9reg_attrs (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct reg_attrs * x ATTRIBUTE_UNUSED = (struct reg_attrs *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct reg_attrs* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12object_block (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct object_block * x ATTRIBUTE_UNUSED = (struct object_block *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).sect), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).objects), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).anchors), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct object_block* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).sect), NULL, cookie);
|
|
op (&((*x).objects), NULL, cookie);
|
|
op (&((*x).anchors), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14vec_rtx_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<rtx,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<rtx,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10real_value (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct real_value * x ATTRIBUTE_UNUSED = (struct real_value *)x_p;
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11fixed_value (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct fixed_value * x ATTRIBUTE_UNUSED = (struct fixed_value *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x).mode), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_8function (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct function * x ATTRIBUTE_UNUSED = (struct function *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).eh), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).cfg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).gimple_body), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).gimple_df), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_current_loops), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).pass_startwith), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).su), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).static_chain_decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).nonlocal_goto_save_area), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).local_decls), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).machine), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).language), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).used_types_hash), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).fde), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10target_rtl (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct target_rtl * x ATTRIBUTE_UNUSED = (struct target_rtl *)x_p;
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(GR_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_global_rtl[i0]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_pic_offset_table_rtx), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_return_address_pointer_rtx), NULL, cookie);
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_initial_regno_reg_rtx[i1]), NULL, cookie);
|
|
}
|
|
}
|
|
{
|
|
size_t i2;
|
|
size_t l2 = (size_t)(MAX_MACHINE_MODE);
|
|
for (i2 = 0; i2 != l2; i2++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_top_of_stack[i2]), NULL, cookie);
|
|
}
|
|
}
|
|
{
|
|
size_t i3;
|
|
size_t l3 = (size_t)(FIRST_PSEUDO_REGISTER);
|
|
for (i3 = 0; i3 != l3; i3++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_static_reg_base_value[i3]), NULL, cookie);
|
|
}
|
|
}
|
|
{
|
|
size_t i4;
|
|
size_t l4 = (size_t)((int) MAX_MACHINE_MODE);
|
|
for (i4 = 0; i4 != l4; i4++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_mode_mem_attrs[i4]), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15cgraph_rtl_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cgraph_rtl_info * x ATTRIBUTE_UNUSED = (struct cgraph_rtl_info *)x_p;
|
|
}
|
|
|
|
void
|
|
gt_pch_p_42hash_map_tree_tree_decl_tree_cache_traits_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<tree,tree,decl_tree_cache_traits> * x ATTRIBUTE_UNUSED = (struct hash_map<tree,tree,decl_tree_cache_traits> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_tree_cache_traits* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_42hash_map_tree_tree_type_tree_cache_traits_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<tree,tree,type_tree_cache_traits> * x ATTRIBUTE_UNUSED = (struct hash_map<tree,tree,type_tree_cache_traits> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct type_tree_cache_traits* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_36hash_map_tree_tree_decl_tree_traits_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<tree,tree,decl_tree_traits> * x ATTRIBUTE_UNUSED = (struct hash_map<tree,tree,decl_tree_traits> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_tree_traits* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12ptr_info_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ptr_info_def * x ATTRIBUTE_UNUSED = (struct ptr_info_def *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).pt.vars), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14range_info_def (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct range_info_def * x ATTRIBUTE_UNUSED = (struct range_info_def *)x_p;
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26vec_constructor_elt_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<constructor_elt,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<constructor_elt,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct constructor_elt* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).index), NULL, cookie);
|
|
op (&((*x).value), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15vec_tree_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<tree,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<tree,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_24tree_statement_list_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tree_statement_list_node * x ATTRIBUTE_UNUSED = (struct tree_statement_list_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).stmt), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14target_globals (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct target_globals * x ATTRIBUTE_UNUSED = (struct target_globals *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).rtl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).libfuncs), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_8tree_map (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tree_map * x ATTRIBUTE_UNUSED = (struct tree_map *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).base.from), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_map* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).base.from), NULL, cookie);
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13tree_decl_map (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tree_decl_map * x ATTRIBUTE_UNUSED = (struct tree_decl_map *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).base.from), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_decl_map* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).base.from), NULL, cookie);
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12tree_int_map (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tree_int_map * x ATTRIBUTE_UNUSED = (struct tree_int_map *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).base.from), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_int_map* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).base.from), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12tree_vec_map (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tree_vec_map * x ATTRIBUTE_UNUSED = (struct tree_vec_map *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).base.from), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tree_vec_map* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).base.from), NULL, cookie);
|
|
op (&((*x).to), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_21vec_alias_pair_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<alias_pair,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<alias_pair,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct alias_pair* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).decl), NULL, cookie);
|
|
op (&((*x).target), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13libfunc_entry (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct libfunc_entry * x ATTRIBUTE_UNUSED = (struct libfunc_entry *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).libfunc), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct libfunc_entry* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).libfunc), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26hash_table_libfunc_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<libfunc_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<libfunc_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct libfunc_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15target_libfuncs (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct target_libfuncs * x ATTRIBUTE_UNUSED = (struct target_libfuncs *)x_p;
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTI_MAX);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_libfunc_table[i0]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_libfunc_hash), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14sequence_stack (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct sequence_stack * x ATTRIBUTE_UNUSED = (struct sequence_stack *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).first), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).last), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_20vec_rtx_insn__va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<rtx_insn*,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<rtx_insn*,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_16vec_uchar_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<uchar,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<uchar,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27vec_call_site_record_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<call_site_record,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<call_site_record,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9gimple_df (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct gimple_df * x ATTRIBUTE_UNUSED = (struct gimple_df *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ssa_names), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).vop), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).escaped.vars), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).free_ssanames), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).free_ssanames_queue), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).default_defs), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ssa_operands.operand_memory), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).tm_restart), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11dw_fde_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct dw_fde_node * x ATTRIBUTE_UNUSED = (struct dw_fde_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).decl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_begin), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_current_label), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_end), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_vms_end_prologue), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_vms_begin_epilogue), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_second_begin), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_second_end), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_fde_cfi), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11frame_space (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct frame_space * x ATTRIBUTE_UNUSED = (struct frame_space *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26vec_callinfo_callee_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<callinfo_callee,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<callinfo_callee,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct callinfo_callee* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26vec_callinfo_dalloc_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<callinfo_dalloc,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<callinfo_dalloc,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct callinfo_dalloc* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).name), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11stack_usage (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct stack_usage * x ATTRIBUTE_UNUSED = (struct stack_usage *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).callees), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dallocs), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9eh_status (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct eh_status * x ATTRIBUTE_UNUSED = (struct eh_status *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).region_tree), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).region_array), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).lp_array), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).throw_stmt_table), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ttype_data), NULL, cookie);
|
|
switch ((int) (targetm.arm_eabi_unwinder))
|
|
{
|
|
case 1:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ehspec_data.arm_eabi), NULL, cookie);
|
|
break;
|
|
case 0:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ehspec_data.other), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_18control_flow_graph (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct control_flow_graph * x ATTRIBUTE_UNUSED = (struct control_flow_graph *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_entry_block_ptr), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_exit_block_ptr), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_basic_block_info), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).x_label_to_block_map), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_5loops (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct loops * x ATTRIBUTE_UNUSED = (struct loops *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).larray), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exits), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).tree_root), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14hash_set_tree_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_set<tree> * x ATTRIBUTE_UNUSED = (struct hash_set<tree> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_24types_used_by_vars_entry (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct types_used_by_vars_entry * x ATTRIBUTE_UNUSED = (struct types_used_by_vars_entry *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).type), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).var_decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct types_used_by_vars_entry* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).type), NULL, cookie);
|
|
op (&((*x).var_decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_28hash_table_used_type_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<used_type_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<used_type_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct used_type_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13nb_iter_bound (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct nb_iter_bound * x ATTRIBUTE_UNUSED = (struct nb_iter_bound *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).stmt), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9loop_exit (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct loop_exit * x ATTRIBUTE_UNUSED = (struct loop_exit *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).e), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_e), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop_exit* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).e), NULL, cookie);
|
|
op (&((*x).prev), NULL, cookie);
|
|
op (&((*x).next), NULL, cookie);
|
|
op (&((*x).next_e), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_4loop (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct loop * x ATTRIBUTE_UNUSED = (struct loop *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).header), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).latch), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).superloops), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).inner), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).nb_iterations), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).simduid), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).bounds), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).control_ivs), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exits), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).simple_loop_desc), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).former_header), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10control_iv (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct control_iv * x ATTRIBUTE_UNUSED = (struct control_iv *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).base), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).step), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17vec_loop_p_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<loop_p,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<loop_p,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10niter_desc (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct niter_desc * x ATTRIBUTE_UNUSED = (struct niter_desc *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).out_edge), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).in_edge), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).assumptions), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).noloop_assumptions), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).infinite), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).niter_expr), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_28hash_table_loop_exit_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<loop_exit_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<loop_exit_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct loop_exit_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_22vec_basic_block_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<basic_block,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<basic_block,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11rtl_bb_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct rtl_bb_info * x ATTRIBUTE_UNUSED = (struct rtl_bb_info *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).end_), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).header_), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).footer_), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15vec_edge_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<edge,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<edge,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_18section_hash_entry (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct section_hash_entry * x ATTRIBUTE_UNUSED = (struct section_hash_entry *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).name), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct section_hash_entry* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).name), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_18lto_file_decl_data (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct lto_file_decl_data * x ATTRIBUTE_UNUSED = (struct lto_file_decl_data *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).current_decl_state), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).global_decl_state), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).function_decl_states), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).mode_table), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15ipa_replace_map (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_replace_map * x ATTRIBUTE_UNUSED = (struct ipa_replace_map *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).new_tree), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17cgraph_simd_clone (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cgraph_simd_clone * x ATTRIBUTE_UNUSED = (struct cgraph_simd_clone *)x_p;
|
|
{
|
|
size_t l0 = (size_t)(((*x)).nargs);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev_clone), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_clone), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).origin), NULL, cookie);
|
|
{
|
|
size_t i0;
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).args[i0].orig_arg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).args[i0].orig_type), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).args[i0].vector_arg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).args[i0].vector_type), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).args[i0].simd_array), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_28cgraph_function_version_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cgraph_function_version_info * x ATTRIBUTE_UNUSED = (struct cgraph_function_version_info *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).this_node), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dispatcher_resolver), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_function_version_info* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).this_node), NULL, cookie);
|
|
op (&((*x).prev), NULL, cookie);
|
|
op (&((*x).next), NULL, cookie);
|
|
op (&((*x).dispatcher_resolver), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_30hash_table_cgraph_edge_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<cgraph_edge_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<cgraph_edge_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct cgraph_edge_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_25cgraph_indirect_call_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct cgraph_indirect_call_info * x ATTRIBUTE_UNUSED = (struct cgraph_indirect_call_info *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).context.outer_type), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).context.speculative_outer_type), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).otr_type), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_8asm_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct asm_node * x ATTRIBUTE_UNUSED = (struct asm_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).asm_str), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10thunk_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct thunk_info * x ATTRIBUTE_UNUSED = (struct thunk_info *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).alias), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_29function_summary_thunk_info__ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct function_summary<thunk_info*> * x ATTRIBUTE_UNUSED = (struct function_summary<thunk_info*> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10clone_info (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct clone_info * x ATTRIBUTE_UNUSED = (struct clone_info *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).tree_map), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).param_adjustments), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_29function_summary_clone_info__ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct function_summary<clone_info*> * x ATTRIBUTE_UNUSED = (struct function_summary<clone_info*> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12symbol_table (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct symbol_table * x ATTRIBUTE_UNUSED = (struct symbol_table *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).nodes), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).asmnodes), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).asm_last_node), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).section_hash), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).assembler_name_hash), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).init_priority_hash), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_thunks), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_clones), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_31hash_table_section_name_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<section_name_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<section_name_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct section_name_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26hash_table_asmname_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<asmname_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<asmname_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct asmname_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_42hash_map_symtab_node__symbol_priority_map_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<symtab_node*,symbol_priority_map> * x ATTRIBUTE_UNUSED = (struct hash_map<symtab_node*,symbol_priority_map> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct symbol_priority_map* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_24constant_descriptor_tree (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct constant_descriptor_tree * x ATTRIBUTE_UNUSED = (struct constant_descriptor_tree *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).rtl), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).value), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct constant_descriptor_tree* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).rtl), NULL, cookie);
|
|
op (&((*x).value), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27vec_ipa_replace_map__va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_replace_map*,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_replace_map*,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_21ipa_param_adjustments (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_param_adjustments * x ATTRIBUTE_UNUSED = (struct ipa_param_adjustments *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_adj_params), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17lto_in_decl_state (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct lto_in_decl_state * x ATTRIBUTE_UNUSED = (struct lto_in_decl_state *)x_p;
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).streams[i0]), NULL, cookie);
|
|
}
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).fn_decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct lto_in_decl_state* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
{
|
|
size_t i1;
|
|
size_t l1 = (size_t)(LTO_N_DECL_STREAMS);
|
|
for (i1 = 0; i1 != l1; i1++) {
|
|
op (&((*x).streams[i1]), NULL, cookie);
|
|
}
|
|
}
|
|
op (&((*x).fn_decl), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15ipa_node_params (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_node_params * x ATTRIBUTE_UNUSED = (struct ipa_node_params *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).descriptors), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_node_params* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).descriptors), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13ipa_edge_args (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_edge_args * x ATTRIBUTE_UNUSED = (struct ipa_edge_args *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).jump_functions), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).polymorphic_call_contexts), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_edge_args* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).jump_functions), NULL, cookie);
|
|
op (&((*x).polymorphic_call_contexts), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_25ipa_agg_replacement_value (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_agg_replacement_value * x ATTRIBUTE_UNUSED = (struct ipa_agg_replacement_value *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).value), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14ipa_fn_summary (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_fn_summary * x ATTRIBUTE_UNUSED = (struct ipa_fn_summary *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).conds), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).loop_iterations), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).loop_strides), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_29vec_ipa_adjusted_param_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_adjusted_param,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_adjusted_param,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_adjusted_param* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).type), NULL, cookie);
|
|
op (&((*x).alias_ptr_type), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27modref_tree_alias_set_type_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct modref_tree<alias_set_type> * x ATTRIBUTE_UNUSED = (struct modref_tree<alias_set_type> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_14modref_summary (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct modref_summary * x ATTRIBUTE_UNUSED = (struct modref_summary *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).loads), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).stores), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_37hash_map_location_hash_nowarn_spec_t_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<location_hash,nowarn_spec_t> * x ATTRIBUTE_UNUSED = (struct hash_map<location_hash,nowarn_spec_t> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct nowarn_spec_t* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11dw_cfi_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct dw_cfi_node * x ATTRIBUTE_UNUSED = (struct dw_cfi_node *)x_p;
|
|
switch ((int) (dw_cfi_oprnd1_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd1.dw_cfi_addr), NULL, cookie);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd1.dw_cfi_loc), NULL, cookie);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd1.dw_cfi_cfa_loc), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (dw_cfi_oprnd2_desc (((*x)).dw_cfi_opc)))
|
|
{
|
|
case dw_cfi_oprnd_reg_num:
|
|
break;
|
|
case dw_cfi_oprnd_offset:
|
|
break;
|
|
case dw_cfi_oprnd_addr:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd2.dw_cfi_addr), NULL, cookie);
|
|
break;
|
|
case dw_cfi_oprnd_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd2.dw_cfi_loc), NULL, cookie);
|
|
break;
|
|
case dw_cfi_oprnd_cfa_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_cfi_oprnd2.dw_cfi_cfa_loc), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17dw_loc_descr_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct dw_loc_descr_node * x ATTRIBUTE_UNUSED = (struct dw_loc_descr_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_next), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.val_entry), NULL, cookie);
|
|
switch ((int) (((*x).dw_loc_oprnd1).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_addr), NULL, cookie);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_loc_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_view_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_loc), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_wide), NULL, cookie);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd1.v.val_vec.array != NULL) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_vec.array), NULL, cookie);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_die_ref.die), NULL, cookie);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_str), NULL, cookie);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_lbl_id), NULL, cookie);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_file), NULL, cookie);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_file_implicit), NULL, cookie);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_decl_ref), NULL, cookie);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_vms_delta.lbl1), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_vms_delta.lbl2), NULL, cookie);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd1.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_discr_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_symview:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd1.v.val_symbolic_view), NULL, cookie);
|
|
break;
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.val_entry), NULL, cookie);
|
|
switch ((int) (((*x).dw_loc_oprnd2).val_class))
|
|
{
|
|
case dw_val_class_addr:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_addr), NULL, cookie);
|
|
break;
|
|
case dw_val_class_offset:
|
|
break;
|
|
case dw_val_class_loc_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_loc_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_view_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_view_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_loc:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_loc), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
case dw_val_class_unsigned_const:
|
|
break;
|
|
case dw_val_class_const_double:
|
|
break;
|
|
case dw_val_class_wide_int:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_wide), NULL, cookie);
|
|
break;
|
|
case dw_val_class_vec:
|
|
if ((*x).dw_loc_oprnd2.v.val_vec.array != NULL) {
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_vec.array), NULL, cookie);
|
|
}
|
|
break;
|
|
case dw_val_class_die_ref:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_die_ref.die), NULL, cookie);
|
|
break;
|
|
case dw_val_class_fde_ref:
|
|
break;
|
|
case dw_val_class_str:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_str), NULL, cookie);
|
|
break;
|
|
case dw_val_class_lbl_id:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_lbl_id), NULL, cookie);
|
|
break;
|
|
case dw_val_class_flag:
|
|
break;
|
|
case dw_val_class_file:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_file), NULL, cookie);
|
|
break;
|
|
case dw_val_class_file_implicit:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_file_implicit), NULL, cookie);
|
|
break;
|
|
case dw_val_class_data8:
|
|
break;
|
|
case dw_val_class_decl_ref:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_decl_ref), NULL, cookie);
|
|
break;
|
|
case dw_val_class_vms_delta:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_vms_delta.lbl1), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_vms_delta.lbl2), NULL, cookie);
|
|
break;
|
|
case dw_val_class_discr_value:
|
|
switch ((int) (((*x).dw_loc_oprnd2.v.val_discr_value).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case dw_val_class_discr_list:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_discr_list), NULL, cookie);
|
|
break;
|
|
case dw_val_class_symview:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_loc_oprnd2.v.val_symbolic_view), NULL, cookie);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_18dw_discr_list_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct dw_discr_list_node * x ATTRIBUTE_UNUSED = (struct dw_discr_list_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dw_discr_next), NULL, cookie);
|
|
switch ((int) (((*x).dw_discr_lower_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (((*x).dw_discr_upper_bound).pos))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_21vec_dw_cfi_ref_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<dw_cfi_ref,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<dw_cfi_ref,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15dwarf_file_data (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct dwarf_file_data * x ATTRIBUTE_UNUSED = (struct dwarf_file_data *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).key), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).filename), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct dwarf_file_data* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).key), NULL, cookie);
|
|
op (&((*x).filename), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10ctf_string (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_string * x ATTRIBUTE_UNUSED = (struct ctf_string *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).cts_str), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).cts_next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9ctf_dmdef (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_dmdef * x ATTRIBUTE_UNUSED = (struct ctf_dmdef *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dmd_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dmd_next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12ctf_func_arg (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_func_arg * x ATTRIBUTE_UNUSED = (struct ctf_func_arg *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).farg_name), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).farg_next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9ctf_dtdef (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_dtdef * x ATTRIBUTE_UNUSED = (struct ctf_dtdef *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dtd_key), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dtd_name), NULL, cookie);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dtd_u.dtu_members), NULL, cookie);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dtd_u.dtu_argv), NULL, cookie);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dtdef* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).dtd_key), NULL, cookie);
|
|
op (&((*x).dtd_name), NULL, cookie);
|
|
switch ((int) (0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch ((int) (ctf_dtu_d_union_selector (&((*x)))))
|
|
{
|
|
case CTF_DTU_D_MEMBERS:
|
|
op (&((*x).dtd_u.dtu_members), NULL, cookie);
|
|
break;
|
|
case CTF_DTU_D_ARRAY:
|
|
break;
|
|
case CTF_DTU_D_ENCODING:
|
|
break;
|
|
case CTF_DTU_D_ARGUMENTS:
|
|
op (&((*x).dtd_u.dtu_argv), NULL, cookie);
|
|
break;
|
|
case CTF_DTU_D_SLICE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_9ctf_dvdef (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_dvdef * x ATTRIBUTE_UNUSED = (struct ctf_dvdef *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dvd_key), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).dvd_name), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctf_dvdef* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).dvd_key), NULL, cookie);
|
|
op (&((*x).dvd_name), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27hash_table_ctfc_dtd_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<ctfc_dtd_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<ctfc_dtd_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctfc_dtd_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27hash_table_ctfc_dvd_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<ctfc_dvd_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<ctfc_dvd_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ctfc_dvd_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_13ctf_container (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ctf_container * x ATTRIBUTE_UNUSED = (struct ctf_container *)x_p;
|
|
{
|
|
size_t l0 = (size_t)(0);
|
|
size_t l1 = (size_t)(0);
|
|
size_t l2 = (size_t)(0);
|
|
size_t l3 = (size_t)(0);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_types), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_vars), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_ignore_vars), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_strtable.ctstab_head), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_strtable.ctstab_tail), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_strtable.ctstab_estr), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_aux_strtable.ctstab_head), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_aux_strtable.ctstab_tail), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_aux_strtable.ctstab_estr), NULL, cookie);
|
|
if ((*x).ctfc_vars_list != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(l0) && ((void *)(*x).ctfc_vars_list == this_obj); i0++) {
|
|
if ((void *)((*x).ctfc_vars_list) == this_obj)
|
|
op (&((*x).ctfc_vars_list[i0]), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_vars_list), NULL, cookie);
|
|
}
|
|
if ((*x).ctfc_types_list != NULL) {
|
|
size_t i1;
|
|
for (i1 = 0; i1 != (size_t)(l1) && ((void *)(*x).ctfc_types_list == this_obj); i1++) {
|
|
if ((void *)((*x).ctfc_types_list) == this_obj)
|
|
op (&((*x).ctfc_types_list[i1]), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_types_list), NULL, cookie);
|
|
}
|
|
if ((*x).ctfc_gfuncs_list != NULL) {
|
|
size_t i2;
|
|
for (i2 = 0; i2 != (size_t)(l2) && ((void *)(*x).ctfc_gfuncs_list == this_obj); i2++) {
|
|
if ((void *)((*x).ctfc_gfuncs_list) == this_obj)
|
|
op (&((*x).ctfc_gfuncs_list[i2]), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_gfuncs_list), NULL, cookie);
|
|
}
|
|
if ((*x).ctfc_gobjts_list != NULL) {
|
|
size_t i3;
|
|
for (i3 = 0; i3 != (size_t)(l3) && ((void *)(*x).ctfc_gobjts_list == this_obj); i3++) {
|
|
if ((void *)((*x).ctfc_gobjts_list) == this_obj)
|
|
op (&((*x).ctfc_gobjts_list[i3]), NULL, cookie);
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).ctfc_gobjts_list), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_22vec_temp_slot_p_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<temp_slot_p,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<temp_slot_p,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_11eh_region_d (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct eh_region_d * x ATTRIBUTE_UNUSED = (struct eh_region_d *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).outer), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).inner), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_peer), NULL, cookie);
|
|
switch ((int) ((*x).type))
|
|
{
|
|
case ERT_TRY:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.eh_try.first_catch), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.eh_try.last_catch), NULL, cookie);
|
|
break;
|
|
case ERT_ALLOWED_EXCEPTIONS:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.allowed.type_list), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.allowed.label), NULL, cookie);
|
|
break;
|
|
case ERT_MUST_NOT_THROW:
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).u.must_not_throw.failure_decl), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).landing_pads), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).exc_ptr_reg), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).filter_reg), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_16eh_landing_pad_d (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct eh_landing_pad_d * x ATTRIBUTE_UNUSED = (struct eh_landing_pad_d *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_lp), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).region), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).post_landing_pad), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).landing_pad), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_10eh_catch_d (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct eh_catch_d * x ATTRIBUTE_UNUSED = (struct eh_catch_d *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next_catch), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).prev_catch), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).type_list), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).filter_list), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).label), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_20vec_eh_region_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<eh_region,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<eh_region,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_25vec_eh_landing_pad_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<eh_landing_pad,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<eh_landing_pad,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_21hash_map_gimple__int_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<gimple*,int> * x ATTRIBUTE_UNUSED = (struct hash_map<gimple*,int> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_15tm_restart_node (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct tm_restart_node * x ATTRIBUTE_UNUSED = (struct tm_restart_node *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).stmt), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).label_or_list), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tm_restart_node* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).stmt), NULL, cookie);
|
|
op (&((*x).label_or_list), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_19hash_map_tree_tree_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_map<tree,tree> * x ATTRIBUTE_UNUSED = (struct hash_map<tree,tree> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_27hash_table_ssa_name_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<ssa_name_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<ssa_name_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ssa_name_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_29hash_table_tm_restart_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<tm_restart_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<tm_restart_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct tm_restart_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_20ssa_operand_memory_d (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ssa_operand_memory_d * x ATTRIBUTE_UNUSED = (struct ssa_operand_memory_d *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).next), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_12int_range_1_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct int_range<1> * x ATTRIBUTE_UNUSED = (struct int_range<1> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_26vec_ipa_agg_jf_item_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_agg_jf_item,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_agg_jf_item,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_agg_jf_item* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).type), NULL, cookie);
|
|
switch ((int) (((*x)).jftype))
|
|
{
|
|
case IPA_JF_CONST:
|
|
op (&((*x).value.constant), NULL, cookie);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
op (&((*x).value.pass_through.operand), NULL, cookie);
|
|
break;
|
|
case IPA_JF_LOAD_AGG:
|
|
op (&((*x).value.load_agg.pass_through.operand), NULL, cookie);
|
|
op (&((*x).value.load_agg.type), NULL, cookie);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_8ipa_bits (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_bits * x ATTRIBUTE_UNUSED = (struct ipa_bits *)x_p;
|
|
}
|
|
|
|
void
|
|
gt_pch_p_31vec_ipa_param_descriptor_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_param_descriptor,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_param_descriptor,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_param_descriptor* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).decl_or_type), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_20vec_ipa_bits__va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_bits*,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_bits*,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17vec_ipa_vr_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_vr,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_vr,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_vr* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
gt_pch_nx (&((*x).min), op, cookie);
|
|
gt_pch_nx (&((*x).max), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_19ipcp_transformation (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipcp_transformation * x ATTRIBUTE_UNUSED = (struct ipcp_transformation *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).agg_values), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).bits), NULL, cookie);
|
|
if ((void *)(x) == this_obj)
|
|
op (&((*x).m_vr), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_24vec_ipa_jump_func_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_jump_func,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_jump_func,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_jump_func* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).agg.items), NULL, cookie);
|
|
op (&((*x).bits), NULL, cookie);
|
|
op (&((*x).m_vr), NULL, cookie);
|
|
switch ((int) (((*x)).type))
|
|
{
|
|
case IPA_JF_CONST:
|
|
op (&((*x).value.constant.value), NULL, cookie);
|
|
break;
|
|
case IPA_JF_PASS_THROUGH:
|
|
op (&((*x).value.pass_through.operand), NULL, cookie);
|
|
break;
|
|
case IPA_JF_ANCESTOR:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_39vec_ipa_polymorphic_call_context_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_polymorphic_call_context,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_polymorphic_call_context,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_polymorphic_call_context* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).outer_type), NULL, cookie);
|
|
op (&((*x).speculative_outer_type), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_17ipa_node_params_t (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_node_params_t * x ATTRIBUTE_UNUSED = (struct ipa_node_params_t *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_19ipa_edge_args_sum_t (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct ipa_edge_args_sum_t * x ATTRIBUTE_UNUSED = (struct ipa_edge_args_sum_t *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_38function_summary_ipcp_transformation__ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct function_summary<ipcp_transformation*> * x ATTRIBUTE_UNUSED = (struct function_summary<ipcp_transformation*> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_29hash_table_decl_state_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct hash_table<decl_state_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<decl_state_hasher> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct decl_state_hasher* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_23vec_expr_eval_op_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<expr_eval_op,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<expr_eval_op,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct expr_eval_op* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).type), NULL, cookie);
|
|
{
|
|
size_t i0;
|
|
size_t l0 = (size_t)(2);
|
|
for (i0 = 0; i0 != l0; i0++) {
|
|
op (&((*x).val[i0]), NULL, cookie);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gt_pch_p_20vec_condition_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<condition,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<condition,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct condition* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
op (&((*x).type), NULL, cookie);
|
|
op (&((*x).val), NULL, cookie);
|
|
op (&((*x).param_ops), NULL, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_p_37vec_ipa_freqcounting_predicate_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct vec<ipa_freqcounting_predicate,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<ipa_freqcounting_predicate,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
void
|
|
gt_pch_nx (struct ipa_freqcounting_predicate* x ATTRIBUTE_UNUSED,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
}
|
|
|
|
void
|
|
gt_pch_p_44fast_function_summary_ipa_fn_summary__va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
|
|
void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void *cookie)
|
|
{
|
|
struct fast_function_summary<ipa_fn_summary*,va_gc> * x ATTRIBUTE_UNUSED = (struct fast_function_summary<ipa_fn_summary*,va_gc> *)x_p;
|
|
if ((void *)(x) == this_obj)
|
|
gt_pch_nx (&((*x)), op, cookie);
|
|
}
|
|
|
|
/* GC roots. */
|
|
|
|
static void gt_ggc_ma_regno_reg_rtx (void *);
|
|
static void
|
|
gt_ggc_ma_regno_reg_rtx (ATTRIBUTE_UNUSED void *x_p)
|
|
{
|
|
if (regno_reg_rtx != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(crtl->emit.x_reg_rtx_no); i0++) {
|
|
gt_ggc_m_7rtx_def (regno_reg_rtx[i0]);
|
|
}
|
|
ggc_mark (regno_reg_rtx);
|
|
}
|
|
}
|
|
|
|
static void gt_pch_pa_regno_reg_rtx
|
|
(void *, void *, gt_pointer_operator, void *);
|
|
static void gt_pch_pa_regno_reg_rtx (ATTRIBUTE_UNUSED void *this_obj,
|
|
ATTRIBUTE_UNUSED void *x_p,
|
|
ATTRIBUTE_UNUSED gt_pointer_operator op,
|
|
ATTRIBUTE_UNUSED void * cookie)
|
|
{
|
|
if (regno_reg_rtx != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(crtl->emit.x_reg_rtx_no) && ((void *)regno_reg_rtx == this_obj); i0++) {
|
|
if ((void *)(regno_reg_rtx) == this_obj)
|
|
op (&(regno_reg_rtx[i0]), NULL, cookie);
|
|
}
|
|
if ((void *)(®no_reg_rtx) == this_obj)
|
|
op (&(regno_reg_rtx), NULL, cookie);
|
|
}
|
|
}
|
|
|
|
static void gt_pch_na_regno_reg_rtx (void *);
|
|
static void
|
|
gt_pch_na_regno_reg_rtx (ATTRIBUTE_UNUSED void *x_p)
|
|
{
|
|
if (regno_reg_rtx != NULL) {
|
|
size_t i0;
|
|
for (i0 = 0; i0 != (size_t)(crtl->emit.x_reg_rtx_no); i0++) {
|
|
gt_pch_n_7rtx_def (regno_reg_rtx[i0]);
|
|
}
|
|
gt_pch_note_object (regno_reg_rtx, ®no_reg_rtx, gt_pch_pa_regno_reg_rtx);
|
|
}
|
|
}
|
|
|
|
EXPORTED_CONST struct ggc_root_tab gt_ggc_r_gtype_desc_cc[] = {
|
|
{
|
|
&internal_fn_fnspec_array[0],
|
|
1 * (IFN_LAST + 1),
|
|
sizeof (internal_fn_fnspec_array[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&ipa_fn_summaries,
|
|
1,
|
|
sizeof (ipa_fn_summaries),
|
|
>_ggc_mx_fast_function_summary_ipa_fn_summary__va_gc_,
|
|
>_pch_nx_fast_function_summary_ipa_fn_summary__va_gc_
|
|
},
|
|
{
|
|
&ipcp_transformation_sum,
|
|
1,
|
|
sizeof (ipcp_transformation_sum),
|
|
>_ggc_mx_function_summary_ipcp_transformation__,
|
|
>_pch_nx_function_summary_ipcp_transformation__
|
|
},
|
|
{
|
|
&ipa_edge_args_sum,
|
|
1,
|
|
sizeof (ipa_edge_args_sum),
|
|
>_ggc_mx_ipa_edge_args_sum_t,
|
|
>_pch_nx_ipa_edge_args_sum_t
|
|
},
|
|
{
|
|
&ipa_node_params_sum,
|
|
1,
|
|
sizeof (ipa_node_params_sum),
|
|
>_ggc_mx_ipa_node_params_t,
|
|
>_pch_nx_ipa_node_params_t
|
|
},
|
|
{
|
|
&ipa_escaped_pt.vars,
|
|
1,
|
|
sizeof (ipa_escaped_pt.vars),
|
|
>_ggc_mx_bitmap_head,
|
|
>_pch_nx_bitmap_head
|
|
},
|
|
{
|
|
&offload_vars,
|
|
1,
|
|
sizeof (offload_vars),
|
|
>_ggc_mx_vec_tree_va_gc_,
|
|
>_pch_nx_vec_tree_va_gc_
|
|
},
|
|
{
|
|
&offload_funcs,
|
|
1,
|
|
sizeof (offload_funcs),
|
|
>_ggc_mx_vec_tree_va_gc_,
|
|
>_pch_nx_vec_tree_va_gc_
|
|
},
|
|
{
|
|
&x_rtl.expr.x_saveregs_value,
|
|
1,
|
|
sizeof (x_rtl.expr.x_saveregs_value),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.expr.x_apply_args_value,
|
|
1,
|
|
sizeof (x_rtl.expr.x_apply_args_value),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.expr.x_forced_labels,
|
|
1,
|
|
sizeof (x_rtl.expr.x_forced_labels),
|
|
>_ggc_mx_vec_rtx_insn__va_gc_,
|
|
>_pch_nx_vec_rtx_insn__va_gc_
|
|
},
|
|
{
|
|
&x_rtl.emit.seq.first,
|
|
1,
|
|
sizeof (x_rtl.emit.seq.first),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.emit.seq.last,
|
|
1,
|
|
sizeof (x_rtl.emit.seq.last),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.emit.seq.next,
|
|
1,
|
|
sizeof (x_rtl.emit.seq.next),
|
|
>_ggc_mx_sequence_stack,
|
|
>_pch_nx_sequence_stack
|
|
},
|
|
{
|
|
&x_rtl.varasm.pool,
|
|
1,
|
|
sizeof (x_rtl.varasm.pool),
|
|
>_ggc_mx_rtx_constant_pool,
|
|
>_pch_nx_rtx_constant_pool
|
|
},
|
|
{
|
|
&x_rtl.args.arg_offset_rtx,
|
|
1,
|
|
sizeof (x_rtl.args.arg_offset_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.args.internal_arg_pointer,
|
|
1,
|
|
sizeof (x_rtl.args.internal_arg_pointer),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.subsections.hot_section_label,
|
|
1,
|
|
sizeof (x_rtl.subsections.hot_section_label),
|
|
(gt_pointer_walker) >_ggc_m_S,
|
|
(gt_pointer_walker) >_pch_n_S
|
|
},
|
|
{
|
|
&x_rtl.subsections.cold_section_label,
|
|
1,
|
|
sizeof (x_rtl.subsections.cold_section_label),
|
|
(gt_pointer_walker) >_ggc_m_S,
|
|
(gt_pointer_walker) >_pch_n_S
|
|
},
|
|
{
|
|
&x_rtl.subsections.hot_section_end_label,
|
|
1,
|
|
sizeof (x_rtl.subsections.hot_section_end_label),
|
|
(gt_pointer_walker) >_ggc_m_S,
|
|
(gt_pointer_walker) >_pch_n_S
|
|
},
|
|
{
|
|
&x_rtl.subsections.cold_section_end_label,
|
|
1,
|
|
sizeof (x_rtl.subsections.cold_section_end_label),
|
|
(gt_pointer_walker) >_ggc_m_S,
|
|
(gt_pointer_walker) >_pch_n_S
|
|
},
|
|
{
|
|
&x_rtl.eh.ehr_stackadj,
|
|
1,
|
|
sizeof (x_rtl.eh.ehr_stackadj),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.eh.ehr_handler,
|
|
1,
|
|
sizeof (x_rtl.eh.ehr_handler),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.eh.ehr_label,
|
|
1,
|
|
sizeof (x_rtl.eh.ehr_label),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.eh.sjlj_fc,
|
|
1,
|
|
sizeof (x_rtl.eh.sjlj_fc),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.eh.sjlj_exit_after,
|
|
1,
|
|
sizeof (x_rtl.eh.sjlj_exit_after),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.eh.action_record_data,
|
|
1,
|
|
sizeof (x_rtl.eh.action_record_data),
|
|
>_ggc_mx_vec_uchar_va_gc_,
|
|
>_pch_nx_vec_uchar_va_gc_
|
|
},
|
|
{
|
|
&x_rtl.eh.call_site_record_v[0],
|
|
1 * (2),
|
|
sizeof (x_rtl.eh.call_site_record_v[0]),
|
|
>_ggc_mx_vec_call_site_record_va_gc_,
|
|
>_pch_nx_vec_call_site_record_va_gc_
|
|
},
|
|
{
|
|
&x_rtl.return_rtx,
|
|
1,
|
|
sizeof (x_rtl.return_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.hard_reg_initial_vals,
|
|
1,
|
|
sizeof (x_rtl.hard_reg_initial_vals),
|
|
>_ggc_mx_initial_value_struct,
|
|
>_pch_nx_initial_value_struct
|
|
},
|
|
{
|
|
&x_rtl.stack_protect_guard,
|
|
1,
|
|
sizeof (x_rtl.stack_protect_guard),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&x_rtl.stack_protect_guard_decl,
|
|
1,
|
|
sizeof (x_rtl.stack_protect_guard_decl),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&x_rtl.x_nonlocal_goto_handler_labels,
|
|
1,
|
|
sizeof (x_rtl.x_nonlocal_goto_handler_labels),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_return_label,
|
|
1,
|
|
sizeof (x_rtl.x_return_label),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_naked_return_label,
|
|
1,
|
|
sizeof (x_rtl.x_naked_return_label),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_stack_slot_list,
|
|
1,
|
|
sizeof (x_rtl.x_stack_slot_list),
|
|
>_ggc_mx_vec_rtx_va_gc_,
|
|
>_pch_nx_vec_rtx_va_gc_
|
|
},
|
|
{
|
|
&x_rtl.frame_space_list,
|
|
1,
|
|
sizeof (x_rtl.frame_space_list),
|
|
>_ggc_mx_frame_space,
|
|
>_pch_nx_frame_space
|
|
},
|
|
{
|
|
&x_rtl.x_stack_check_probe_note,
|
|
1,
|
|
sizeof (x_rtl.x_stack_check_probe_note),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_arg_pointer_save_area,
|
|
1,
|
|
sizeof (x_rtl.x_arg_pointer_save_area),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.drap_reg,
|
|
1,
|
|
sizeof (x_rtl.drap_reg),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_parm_birth_insn,
|
|
1,
|
|
sizeof (x_rtl.x_parm_birth_insn),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&x_rtl.x_used_temp_slots,
|
|
1,
|
|
sizeof (x_rtl.x_used_temp_slots),
|
|
>_ggc_mx_vec_temp_slot_p_va_gc_,
|
|
>_pch_nx_vec_temp_slot_p_va_gc_
|
|
},
|
|
{
|
|
&x_rtl.x_avail_temp_slots,
|
|
1,
|
|
sizeof (x_rtl.x_avail_temp_slots),
|
|
>_ggc_mx_temp_slot,
|
|
>_pch_nx_temp_slot
|
|
},
|
|
{
|
|
&tu_ctfc,
|
|
1,
|
|
sizeof (tu_ctfc),
|
|
>_ggc_mx_ctf_container,
|
|
>_pch_nx_ctf_container
|
|
},
|
|
{
|
|
&cie_cfi_vec,
|
|
1,
|
|
sizeof (cie_cfi_vec),
|
|
>_ggc_mx_vec_dw_cfi_ref_va_gc_,
|
|
>_pch_nx_vec_dw_cfi_ref_va_gc_
|
|
},
|
|
{
|
|
&nowarn_map,
|
|
1,
|
|
sizeof (nowarn_map),
|
|
>_ggc_mx_hash_map_location_hash_nowarn_spec_t_,
|
|
>_pch_nx_hash_map_location_hash_nowarn_spec_t_
|
|
},
|
|
{
|
|
&saved_symtab,
|
|
1,
|
|
sizeof (saved_symtab),
|
|
>_ggc_mx_symbol_table,
|
|
>_pch_nx_symbol_table
|
|
},
|
|
{
|
|
&symtab,
|
|
1,
|
|
sizeof (symtab),
|
|
>_ggc_mx_symbol_table,
|
|
>_pch_nx_symbol_table
|
|
},
|
|
{
|
|
&in_section,
|
|
1,
|
|
sizeof (in_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&bss_noswitch_section,
|
|
1,
|
|
sizeof (bss_noswitch_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&lcomm_section,
|
|
1,
|
|
sizeof (lcomm_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&comm_section,
|
|
1,
|
|
sizeof (comm_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&tls_comm_section,
|
|
1,
|
|
sizeof (tls_comm_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&eh_frame_section,
|
|
1,
|
|
sizeof (eh_frame_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&exception_section,
|
|
1,
|
|
sizeof (exception_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&sbss_section,
|
|
1,
|
|
sizeof (sbss_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&bss_section,
|
|
1,
|
|
sizeof (bss_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&dtors_section,
|
|
1,
|
|
sizeof (dtors_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&ctors_section,
|
|
1,
|
|
sizeof (ctors_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&sdata_section,
|
|
1,
|
|
sizeof (sdata_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&readonly_data_section,
|
|
1,
|
|
sizeof (readonly_data_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&data_section,
|
|
1,
|
|
sizeof (data_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&text_section,
|
|
1,
|
|
sizeof (text_section),
|
|
>_ggc_mx_section,
|
|
>_pch_nx_section
|
|
},
|
|
{
|
|
&types_used_by_cur_var_decl,
|
|
1,
|
|
sizeof (types_used_by_cur_var_decl),
|
|
>_ggc_mx_vec_tree_va_gc_,
|
|
>_pch_nx_vec_tree_va_gc_
|
|
},
|
|
{
|
|
&types_used_by_vars_hash,
|
|
1,
|
|
sizeof (types_used_by_vars_hash),
|
|
>_ggc_mx_hash_table_used_type_hasher_,
|
|
>_pch_nx_hash_table_used_type_hasher_
|
|
},
|
|
{
|
|
&cfun,
|
|
1,
|
|
sizeof (cfun),
|
|
>_ggc_mx_function,
|
|
>_pch_nx_function
|
|
},
|
|
{
|
|
®no_reg_rtx,
|
|
1,
|
|
sizeof (regno_reg_rtx),
|
|
>_ggc_ma_regno_reg_rtx,
|
|
>_pch_na_regno_reg_rtx
|
|
},
|
|
{
|
|
&default_target_libfuncs.x_libfunc_table[0],
|
|
1 * (LTI_MAX),
|
|
sizeof (default_target_libfuncs.x_libfunc_table[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_libfuncs.x_libfunc_hash,
|
|
1,
|
|
sizeof (default_target_libfuncs.x_libfunc_hash),
|
|
>_ggc_mx_hash_table_libfunc_hasher_,
|
|
>_pch_nx_hash_table_libfunc_hasher_
|
|
},
|
|
{
|
|
¤t_function_func_begin_label,
|
|
1,
|
|
sizeof (current_function_func_begin_label),
|
|
(gt_pointer_walker) >_ggc_m_S,
|
|
(gt_pointer_walker) >_pch_n_S
|
|
},
|
|
{
|
|
¤t_function_decl,
|
|
1,
|
|
sizeof (current_function_decl),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&builtin_info[0].decl,
|
|
1 * ((int)END_BUILTINS),
|
|
sizeof (builtin_info[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&sizetype_tab[0],
|
|
1 * ((int) stk_type_kind_last),
|
|
sizeof (sizetype_tab[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&integer_types[0],
|
|
1 * (itk_none),
|
|
sizeof (integer_types[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&global_trees[0],
|
|
1 * (TI_MAX),
|
|
sizeof (global_trees[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&all_translation_units,
|
|
1,
|
|
sizeof (all_translation_units),
|
|
>_ggc_mx_vec_tree_va_gc_,
|
|
>_pch_nx_vec_tree_va_gc_
|
|
},
|
|
{
|
|
&alias_pairs,
|
|
1,
|
|
sizeof (alias_pairs),
|
|
>_ggc_mx_vec_alias_pair_va_gc_,
|
|
>_pch_nx_vec_alias_pair_va_gc_
|
|
},
|
|
{
|
|
&int_n_trees[0].signed_type,
|
|
1 * (NUM_INT_N_ENTS),
|
|
sizeof (int_n_trees[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&int_n_trees[0].unsigned_type,
|
|
1 * (NUM_INT_N_ENTS),
|
|
sizeof (int_n_trees[0]),
|
|
>_ggc_mx_tree_node,
|
|
>_pch_nx_tree_node
|
|
},
|
|
{
|
|
&stack_limit_rtx,
|
|
1,
|
|
sizeof (stack_limit_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_global_rtl[0],
|
|
1 * (GR_MAX),
|
|
sizeof (default_target_rtl.x_global_rtl[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_pic_offset_table_rtx,
|
|
1,
|
|
sizeof (default_target_rtl.x_pic_offset_table_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_return_address_pointer_rtx,
|
|
1,
|
|
sizeof (default_target_rtl.x_return_address_pointer_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_initial_regno_reg_rtx[0],
|
|
1 * (FIRST_PSEUDO_REGISTER),
|
|
sizeof (default_target_rtl.x_initial_regno_reg_rtx[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_top_of_stack[0],
|
|
1 * (MAX_MACHINE_MODE),
|
|
sizeof (default_target_rtl.x_top_of_stack[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_static_reg_base_value[0],
|
|
1 * (FIRST_PSEUDO_REGISTER),
|
|
sizeof (default_target_rtl.x_static_reg_base_value[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&default_target_rtl.x_mode_mem_attrs[0],
|
|
1 * ((int) MAX_MACHINE_MODE),
|
|
sizeof (default_target_rtl.x_mode_mem_attrs[0]),
|
|
>_ggc_mx_mem_attrs,
|
|
>_pch_nx_mem_attrs
|
|
},
|
|
{
|
|
&invalid_insn_rtx,
|
|
1,
|
|
sizeof (invalid_insn_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&simple_return_rtx,
|
|
1,
|
|
sizeof (simple_return_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&ret_rtx,
|
|
1,
|
|
sizeof (ret_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&pc_rtx,
|
|
1,
|
|
sizeof (pc_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&const_tiny_rtx[0][0],
|
|
1 * (4) * ((int) MAX_MACHINE_MODE),
|
|
sizeof (const_tiny_rtx[0][0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&const_true_rtx,
|
|
1,
|
|
sizeof (const_true_rtx),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&const_int_rtx[0],
|
|
1 * (MAX_SAVED_CONST_INT * 2 + 1),
|
|
sizeof (const_int_rtx[0]),
|
|
>_ggc_mx_rtx_def,
|
|
>_pch_nx_rtx_def
|
|
},
|
|
{
|
|
&saved_line_table,
|
|
1,
|
|
sizeof (saved_line_table),
|
|
>_ggc_mx_line_maps,
|
|
>_pch_nx_line_maps
|
|
},
|
|
{
|
|
&line_table,
|
|
1,
|
|
sizeof (line_table),
|
|
>_ggc_mx_line_maps,
|
|
>_pch_nx_line_maps
|
|
},
|
|
LAST_GGC_ROOT_TAB
|
|
};
|
|
|
|
EXPORTED_CONST struct ggc_root_tab gt_pch_rs_gtype_desc_cc[] = {
|
|
{ &omp_requires_mask, 1, sizeof (omp_requires_mask), NULL, NULL },
|
|
{ &ipa_escaped_pt, 1, sizeof (ipa_escaped_pt), NULL, NULL },
|
|
{ &x_rtl, 1, sizeof (x_rtl), NULL, NULL },
|
|
{ &in_cold_section_p, 1, sizeof (in_cold_section_p), NULL, NULL },
|
|
{ &default_target_libfuncs, 1, sizeof (default_target_libfuncs), NULL, NULL },
|
|
{ &builtin_info, 1, sizeof (builtin_info), NULL, NULL },
|
|
{ &int_n_trees, 1, sizeof (int_n_trees), NULL, NULL },
|
|
{ &default_target_rtl, 1, sizeof (default_target_rtl), NULL, NULL },
|
|
LAST_GGC_ROOT_TAB
|
|
};
|
|
|
|
|
|
/* Used to implement the RTX_NEXT macro. */
|
|
EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {
|
|
0,
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
0,
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 0 * sizeof (rtunion),
|
|
RTX_HDR_SIZE + 1 * sizeof (rtunion),
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|