Line data    Source code

       1             : /* Type information for cp/module.cc.
       2             :    Copyright (C) 2004-2023 Free Software Foundation, Inc.
       3             : 
       4             : This file is part of GCC.
       5             : 
       6             : GCC is free software; you can redistribute it and/or modify it under
       7             : the terms of the GNU General Public License as published by the Free
       8             : Software Foundation; either version 3, or (at your option) any later
       9             : version.
      10             : 
      11             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14             : for more details.
      15             : 
      16             : You should have received a copy of the GNU General Public License
      17             : along with GCC; see the file COPYING3.  If not see
      18             : <http://www.gnu.org/licenses/>.  */
      19             : 
      20             : /* This file is machine generated.  Do not edit.  */
      21             : 
      22             : void
      23       28511 : gt_ggc_mx_module_state (void *x_p)
      24             : {
      25       28511 :   struct module_state * x = (struct module_state *)x_p;
      26       28511 :   struct module_state * xlimit = x;
      27       43159 :   while (ggc_test_and_set_mark (xlimit))
      28       14648 :    xlimit = ((*xlimit).parent);
      29       43159 :   while (x != xlimit)
      30             :     {
      31       14648 :       gt_ggc_m_11bitmap_head ((*x).imports);
      32       14648 :       gt_ggc_m_11bitmap_head ((*x).exports);
      33       14648 :       gt_ggc_m_12module_state ((*x).parent);
      34       14648 :       gt_ggc_m_9tree_node ((*x).name);
      35       14648 :       gt_ggc_m_8slurping ((*x).slurp);
      36       14648 :       gt_ggc_m_S ((*x).flatname);
      37       14648 :       gt_ggc_m_S ((*x).filename);
      38       14648 :       x = ((*x).parent);
      39             :     }
      40       28511 : }
      41             : 
      42             : void
      43           0 : gt_ggc_mx (struct module_state& x_r ATTRIBUTE_UNUSED)
      44             : {
      45           0 :   struct module_state * ATTRIBUTE_UNUSED x = &x_r;
      46           0 :   gt_ggc_m_11bitmap_head ((*x).imports);
      47           0 :   gt_ggc_m_11bitmap_head ((*x).exports);
      48           0 :   gt_ggc_m_12module_state ((*x).parent);
      49           0 :   gt_ggc_m_9tree_node ((*x).name);
      50           0 :   gt_ggc_m_8slurping ((*x).slurp);
      51           0 :   gt_ggc_m_S ((*x).flatname);
      52           0 :   gt_ggc_m_S ((*x).filename);
      53           0 : }
      54             : 
      55             : void
      56       28508 : gt_ggc_mx (struct module_state *& x)
      57             : {
      58       14503 :   if (x)
      59       28508 :     gt_ggc_mx_module_state ((void *) x);
      60           0 : }
      61             : 
      62             : void
      63        6896 : gt_ggc_mx_slurping (void *x_p)
      64             : {
      65        6896 :   struct slurping * const x = (struct slurping *)x_p;
      66        6896 :   if (ggc_test_and_set_mark (x))
      67             :     {
      68        6896 :       gt_ggc_m_11bitmap_head ((*x).headers);
      69             :     }
      70        6896 : }
      71             : 
      72             : void
      73       95241 : gt_ggc_mx_vec_module_state__va_gc_ (void *x_p)
      74             : {
      75       95241 :   vec<module_state*,va_gc> * const x = (vec<module_state*,va_gc> *)x_p;
      76       95241 :   if (ggc_test_and_set_mark (x))
      77             :     {
      78        7583 :       gt_ggc_mx (x);
      79             :     }
      80       95241 : }
      81             : 
      82             : void
      83       95241 : gt_ggc_mx_hash_table_module_state_hash_ (void *x_p)
      84             : {
      85       95241 :   hash_table<module_state_hash> * const x = (hash_table<module_state_hash> *)x_p;
      86       95241 :   if (ggc_test_and_set_mark (x))
      87             :     {
      88        7362 :       gt_ggc_mx (x);
      89             :     }
      90       95241 : }
      91             : 
      92             : void
      93           0 : gt_ggc_mx (struct module_state_hash& x_r ATTRIBUTE_UNUSED)
      94             : {
      95           0 :   struct module_state_hash * ATTRIBUTE_UNUSED x = &x_r;
      96           0 : }
      97             : 
      98             : void
      99       95241 : gt_ggc_mx_hash_table_note_def_cache_hasher_ (void *x_p)
     100             : {
     101       95241 :   hash_table<note_def_cache_hasher> * const x = (hash_table<note_def_cache_hasher> *)x_p;
     102       95241 :   if (ggc_test_and_set_mark (x))
     103             :     {
     104        7362 :       gt_ggc_mx (x);
     105             :     }
     106       95241 : }
     107             : 
     108             : void
     109           0 : gt_ggc_mx (struct note_def_cache_hasher& x_r ATTRIBUTE_UNUSED)
     110             : {
     111           0 :   struct note_def_cache_hasher * ATTRIBUTE_UNUSED x = &x_r;
     112           0 : }
     113             : 
     114             : void
     115       95241 : gt_ggc_mx_vec_macro_export_va_gc_ (void *x_p)
     116             : {
     117       95241 :   vec<macro_export,va_gc> * const x = (vec<macro_export,va_gc> *)x_p;
     118       95241 :   if (ggc_test_and_set_mark (x))
     119             :     {
     120        6849 :       gt_ggc_mx (x);
     121             :     }
     122       95241 : }
     123             : 
     124             : void
     125     3951403 : gt_ggc_mx (struct macro_export& x_r ATTRIBUTE_UNUSED)
     126             : {
     127     3951403 :   struct macro_export * ATTRIBUTE_UNUSED x = &x_r;
     128     3951403 :   gt_ggc_m_9cpp_macro ((*x).def);
     129           0 : }
     130             : 
     131             : void
     132           0 : gt_pch_nx_module_state (void *x_p)
     133             : {
     134           0 :   struct module_state * x = (struct module_state *)x_p;
     135           0 :   struct module_state * xlimit = x;
     136           0 :   while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_12module_state))
     137           0 :    xlimit = ((*xlimit).parent);
     138           0 :   while (x != xlimit)
     139             :     {
     140           0 :       gt_pch_n_11bitmap_head ((*x).imports);
     141           0 :       gt_pch_n_11bitmap_head ((*x).exports);
     142           0 :       gt_pch_n_12module_state ((*x).parent);
     143           0 :       gt_pch_n_9tree_node ((*x).name);
     144           0 :       gt_pch_n_8slurping ((*x).slurp);
     145           0 :       gt_pch_n_S ((*x).flatname);
     146           0 :       gt_pch_n_S ((*x).filename);
     147           0 :       x = ((*x).parent);
     148             :     }
     149           0 : }
     150             : 
     151             : void
     152           0 : gt_pch_nx (struct module_state& x_r ATTRIBUTE_UNUSED)
     153             : {
     154           0 :   struct module_state * ATTRIBUTE_UNUSED x = &x_r;
     155           0 :   gt_pch_n_11bitmap_head ((*x).imports);
     156           0 :   gt_pch_n_11bitmap_head ((*x).exports);
     157           0 :   gt_pch_n_12module_state ((*x).parent);
     158           0 :   gt_pch_n_9tree_node ((*x).name);
     159           0 :   gt_pch_n_8slurping ((*x).slurp);
     160           0 :   gt_pch_n_S ((*x).flatname);
     161           0 :   gt_pch_n_S ((*x).filename);
     162           0 : }
     163             : 
     164             : void
     165           0 : gt_pch_nx (struct module_state *& x)
     166             : {
     167           0 :   if (x)
     168           0 :     gt_pch_nx_module_state ((void *) x);
     169           0 : }
     170             : 
     171             : void
     172           0 : gt_pch_nx_slurping (void *x_p)
     173             : {
     174           0 :   struct slurping * const x = (struct slurping *)x_p;
     175           0 :   if (gt_pch_note_object (x, x, gt_pch_p_8slurping))
     176             :     {
     177           0 :       gt_pch_n_11bitmap_head ((*x).headers);
     178             :     }
     179           0 : }
     180             : 
     181             : void
     182          68 : gt_pch_nx_vec_module_state__va_gc_ (void *x_p)
     183             : {
     184          68 :   vec<module_state*,va_gc> * const x = (vec<module_state*,va_gc> *)x_p;
     185          68 :   if (gt_pch_note_object (x, x, gt_pch_p_24vec_module_state__va_gc_))
     186             :     {
     187           0 :       gt_pch_nx (x);
     188             :     }
     189          68 : }
     190             : 
     191             : void
     192          68 : gt_pch_nx_hash_table_module_state_hash_ (void *x_p)
     193             : {
     194          68 :   hash_table<module_state_hash> * const x = (hash_table<module_state_hash> *)x_p;
     195          68 :   if (gt_pch_note_object (x, x, gt_pch_p_29hash_table_module_state_hash_))
     196             :     {
     197           0 :       gt_pch_nx (x);
     198             :     }
     199          68 : }
     200             : 
     201             : void
     202           0 : gt_pch_nx (struct module_state_hash& x_r ATTRIBUTE_UNUSED)
     203             : {
     204           0 :   struct module_state_hash * ATTRIBUTE_UNUSED x = &x_r;
     205           0 : }
     206             : 
     207             : void
     208          68 : gt_pch_nx_hash_table_note_def_cache_hasher_ (void *x_p)
     209             : {
     210          68 :   hash_table<note_def_cache_hasher> * const x = (hash_table<note_def_cache_hasher> *)x_p;
     211          68 :   if (gt_pch_note_object (x, x, gt_pch_p_33hash_table_note_def_cache_hasher_))
     212             :     {
     213           0 :       gt_pch_nx (x);
     214             :     }
     215          68 : }
     216             : 
     217             : void
     218           0 : gt_pch_nx (struct note_def_cache_hasher& x_r ATTRIBUTE_UNUSED)
     219             : {
     220           0 :   struct note_def_cache_hasher * ATTRIBUTE_UNUSED x = &x_r;
     221           0 : }
     222             : 
     223             : void
     224          68 : gt_pch_nx_vec_macro_export_va_gc_ (void *x_p)
     225             : {
     226          68 :   vec<macro_export,va_gc> * const x = (vec<macro_export,va_gc> *)x_p;
     227          68 :   if (gt_pch_note_object (x, x, gt_pch_p_23vec_macro_export_va_gc_))
     228             :     {
     229           0 :       gt_pch_nx (x);
     230             :     }
     231          68 : }
     232             : 
     233             : void
     234           0 : gt_pch_nx (struct macro_export& x_r ATTRIBUTE_UNUSED)
     235             : {
     236           0 :   struct macro_export * ATTRIBUTE_UNUSED x = &x_r;
     237           0 :   gt_pch_n_9cpp_macro ((*x).def);
     238           0 : }
     239             : 
     240             : void
     241           0 : gt_pch_p_12module_state (ATTRIBUTE_UNUSED void *this_obj,
     242             :         void *x_p,
     243             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     244             :         ATTRIBUTE_UNUSED void *cookie)
     245             : {
     246           0 :   struct module_state * x ATTRIBUTE_UNUSED = (struct module_state *)x_p;
     247           0 :   if ((void *)(x) == this_obj)
     248           0 :     op (&((*x).imports), NULL, cookie);
     249           0 :   if ((void *)(x) == this_obj)
     250           0 :     op (&((*x).exports), NULL, cookie);
     251           0 :   if ((void *)(x) == this_obj)
     252           0 :     op (&((*x).parent), NULL, cookie);
     253           0 :   if ((void *)(x) == this_obj)
     254           0 :     op (&((*x).name), NULL, cookie);
     255           0 :   if ((void *)(x) == this_obj)
     256           0 :     op (&((*x).slurp), NULL, cookie);
     257           0 :   if ((void *)(x) == this_obj)
     258           0 :     op (&((*x).flatname), NULL, cookie);
     259           0 :   if ((void *)(x) == this_obj)
     260           0 :     op (&((*x).filename), NULL, cookie);
     261           0 : }
     262             : 
     263             : void
     264           0 : gt_pch_nx (struct module_state* x ATTRIBUTE_UNUSED,
     265             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     266             :         ATTRIBUTE_UNUSED void *cookie)
     267             : {
     268           0 :     op (&((*x).imports), NULL, cookie);
     269           0 :     op (&((*x).exports), NULL, cookie);
     270           0 :     op (&((*x).parent), NULL, cookie);
     271           0 :     op (&((*x).name), NULL, cookie);
     272           0 :     op (&((*x).slurp), NULL, cookie);
     273           0 :     op (&((*x).flatname), NULL, cookie);
     274           0 :     op (&((*x).filename), NULL, cookie);
     275           0 : }
     276             : 
     277             : void
     278           0 : gt_pch_p_8slurping (ATTRIBUTE_UNUSED void *this_obj,
     279             :         void *x_p,
     280             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     281             :         ATTRIBUTE_UNUSED void *cookie)
     282             : {
     283           0 :   struct slurping * x ATTRIBUTE_UNUSED = (struct slurping *)x_p;
     284           0 :   if ((void *)(x) == this_obj)
     285           0 :     op (&((*x).headers), NULL, cookie);
     286           0 : }
     287             : 
     288             : void
     289           0 : gt_pch_p_24vec_module_state__va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
     290             :         void *x_p,
     291             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     292             :         ATTRIBUTE_UNUSED void *cookie)
     293             : {
     294           0 :   struct vec<module_state*,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<module_state*,va_gc> *)x_p;
     295           0 :   if ((void *)(x) == this_obj)
     296           0 :     gt_pch_nx (&((*x)), op, cookie);
     297           0 : }
     298             : 
     299             : void
     300           0 : gt_pch_p_29hash_table_module_state_hash_ (ATTRIBUTE_UNUSED void *this_obj,
     301             :         void *x_p,
     302             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     303             :         ATTRIBUTE_UNUSED void *cookie)
     304             : {
     305           0 :   struct hash_table<module_state_hash> * x ATTRIBUTE_UNUSED = (struct hash_table<module_state_hash> *)x_p;
     306           0 :   if ((void *)(x) == this_obj)
     307           0 :     gt_pch_nx (&((*x)), op, cookie);
     308           0 : }
     309             : 
     310             : void
     311           0 : gt_pch_nx (struct module_state_hash* x ATTRIBUTE_UNUSED,
     312             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     313             :         ATTRIBUTE_UNUSED void *cookie)
     314             : {
     315           0 : }
     316             : 
     317             : void
     318           0 : gt_pch_p_33hash_table_note_def_cache_hasher_ (ATTRIBUTE_UNUSED void *this_obj,
     319             :         void *x_p,
     320             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     321             :         ATTRIBUTE_UNUSED void *cookie)
     322             : {
     323           0 :   struct hash_table<note_def_cache_hasher> * x ATTRIBUTE_UNUSED = (struct hash_table<note_def_cache_hasher> *)x_p;
     324           0 :   if ((void *)(x) == this_obj)
     325           0 :     gt_pch_nx (&((*x)), op, cookie);
     326           0 : }
     327             : 
     328             : void
     329           0 : gt_pch_nx (struct note_def_cache_hasher* x ATTRIBUTE_UNUSED,
     330             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     331             :         ATTRIBUTE_UNUSED void *cookie)
     332             : {
     333           0 : }
     334             : 
     335             : void
     336           0 : gt_pch_p_23vec_macro_export_va_gc_ (ATTRIBUTE_UNUSED void *this_obj,
     337             :         void *x_p,
     338             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     339             :         ATTRIBUTE_UNUSED void *cookie)
     340             : {
     341           0 :   struct vec<macro_export,va_gc> * x ATTRIBUTE_UNUSED = (struct vec<macro_export,va_gc> *)x_p;
     342           0 :   if ((void *)(x) == this_obj)
     343           0 :     gt_pch_nx (&((*x)), op, cookie);
     344           0 : }
     345             : 
     346             : void
     347           0 : gt_pch_nx (struct macro_export* x ATTRIBUTE_UNUSED,
     348             :         ATTRIBUTE_UNUSED gt_pointer_operator op,
     349             :         ATTRIBUTE_UNUSED void *cookie)
     350             : {
     351           0 :     op (&((*x).def), NULL, cookie);
     352           0 : }
     353             : 
     354             : /* GC roots.  */
     355             : 
     356             : EXPORTED_CONST struct ggc_root_tab gt_ggc_r_gt_cp_module_h[] = {
     357             :   {
     358             :     &headers,
     359             :     1,
     360             :     sizeof (headers),
     361             :     &gt_ggc_mx_bitmap_head,
     362             :     &gt_pch_nx_bitmap_head
     363             :   },
     364             :   {
     365             :     &macro_exports,
     366             :     1,
     367             :     sizeof (macro_exports),
     368             :     &gt_ggc_mx_vec_macro_export_va_gc_,
     369             :     &gt_pch_nx_vec_macro_export_va_gc_
     370             :   },
     371             :   {
     372             :     &note_defs,
     373             :     1,
     374             :     sizeof (note_defs),
     375             :     &gt_ggc_mx_hash_table_note_def_cache_hasher_,
     376             :     &gt_pch_nx_hash_table_note_def_cache_hasher_
     377             :   },
     378             :   {
     379             :     &partial_specializations,
     380             :     1,
     381             :     sizeof (partial_specializations),
     382             :     &gt_ggc_mx_vec_tree_va_gc_,
     383             :     &gt_pch_nx_vec_tree_va_gc_
     384             :   },
     385             :   {
     386             :     &class_members,
     387             :     1,
     388             :     sizeof (class_members),
     389             :     &gt_ggc_mx_vec_tree_va_gc_,
     390             :     &gt_pch_nx_vec_tree_va_gc_
     391             :   },
     392             :   {
     393             :     &modules_hash,
     394             :     1,
     395             :     sizeof (modules_hash),
     396             :     &gt_ggc_mx_hash_table_module_state_hash_,
     397             :     &gt_pch_nx_hash_table_module_state_hash_
     398             :   },
     399             :   {
     400             :     &modules,
     401             :     1,
     402             :     sizeof (modules),
     403             :     &gt_ggc_mx_vec_module_state__va_gc_,
     404             :     &gt_pch_nx_vec_module_state__va_gc_
     405             :   },
     406             :   {
     407             :     &fixed_trees,
     408             :     1,
     409             :     sizeof (fixed_trees),
     410             :     &gt_ggc_mx_vec_tree_va_gc_,
     411             :     &gt_pch_nx_vec_tree_va_gc_
     412             :   },
     413             :   LAST_GGC_ROOT_TAB
     414             : };
     415             : 
     416             : void
     417       95241 : gt_clear_caches_gt_cp_module_h ()
     418             : {
     419       95241 :   gt_cleare_cache (note_defs);
     420       95241 : }
     421             :