sdcc/support/cpp/gcc/ggc.h

   1 /* Garbage collection for the GNU compiler.
   2
   3    Copyright (C) 1998-2022 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_GGC_H
  22 #define GCC_GGC_H
  23
  24 /* Symbols are marked with `ggc' for `gcc gc' so as not to interfere with
  25    an external gc library that might be linked in.  */
  26
  27 /* Internal functions and data structures used by the GTY
  28    machinery, including the generated gt*.[hc] files.  */
  29
  30 // sdcpp #include "gtype-desc.h"
  31
  32 /* One of these applies its third parameter (with cookie in the fourth
  33    parameter) to each pointer in the object pointed to by the first
  34    parameter, using the second parameter.  */
  35 typedef void (*gt_note_pointers) (void *, void *, gt_pointer_operator,
  36                                   void *);
  37
  38 /* One of these is called before objects are re-ordered in memory.
  39    The first parameter is the original object, the second is the
  40    subobject that has had its pointers reordered, the third parameter
  41    can compute the new values of a pointer when given the cookie in
  42    the fourth parameter.  */
  43 typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator,
  44                                    void *);
  45
  46 /* Used by the gt_pch_n_* routines.  Register an object in the hash table.  */
  47 extern int gt_pch_note_object (void *, void *, gt_note_pointers);
  48
  49 /* Used by the gt_pch_p_* routines.  Register address of a callback
  50    pointer.  */
  51 extern void gt_pch_note_callback (void *, void *);
  52
  53 /* Used by the gt_pch_n_* routines.  Register that an object has a reorder
  54    function.  */
  55 extern void gt_pch_note_reorder (void *, void *, gt_handle_reorder);
  56
  57 /* generated function to clear caches in gc memory.  */
  58 extern void gt_clear_caches ();
  59
  60 /* Mark the object in the first parameter and anything it points to.  */
  61 typedef void (*gt_pointer_walker) (void *);
  62
  63 /* Structures for the easy way to mark roots.
  64    In an array, terminated by having base == NULL.  */
  65 struct ggc_root_tab {
  66   void *base;
  67   size_t nelt;
  68   size_t stride;
  69   gt_pointer_walker cb;
  70   gt_pointer_walker pchw;
  71 };
  72 #define LAST_GGC_ROOT_TAB { NULL, 0, 0, NULL, NULL }
  73 /* Pointers to arrays of ggc_root_tab, terminated by NULL.  */
  74 extern const struct ggc_root_tab * const gt_ggc_rtab[];
  75 extern const struct ggc_root_tab * const gt_ggc_deletable_rtab[];
  76 extern const struct ggc_root_tab * const gt_pch_scalar_rtab[];
  77
  78 /* If EXPR is not NULL and previously unmarked, mark it and evaluate
  79    to true.  Otherwise evaluate to false.  */
  80 #define ggc_test_and_set_mark(EXPR) \
  81   ((EXPR) != NULL && ((void *) (EXPR)) != (void *) 1 && ! ggc_set_mark (EXPR))
  82
  83 #define ggc_mark(EXPR)                          \
  84   do {                                          \
  85     const void *const a__ = (EXPR);             \
  86     if (a__ != NULL && a__ != (void *) 1)       \
  87       ggc_set_mark (a__);                       \
  88   } while (0)
  89
  90 /* Actually set the mark on a particular region of memory, but don't
  91    follow pointers.  This function is called by ggc_mark_*.  It
  92    returns zero if the object was not previously marked; nonzero if
  93    the object was already marked, or if, for any other reason,
  94    pointers in this data structure should not be traversed.  */
  95 extern int ggc_set_mark (const void *);
  96
  97 /* Return 1 if P has been marked, zero otherwise.
  98    P must have been allocated by the GC allocator; it mustn't point to
  99    static objects, stack variables, or memory allocated with malloc.  */
 100 extern int ggc_marked_p (const void *);
 101
 102 /* PCH and GGC handling for strings, mostly trivial.  */
 103 extern void gt_pch_n_S (const void *);
 104 extern void gt_ggc_m_S (const void *);
 105
 106 /* End of GTY machinery API.  */
 107
 108 /* Initialize the string pool.  */
 109 extern void init_stringpool (void);
 110
 111 /* Initialize the garbage collector.  */
 112 extern void init_ggc (void);
 113
 114 /* When true, identifier nodes are considered as GC roots.  When
 115    false, identifier nodes are treated like any other GC-allocated
 116    object, and the identifier hash table is treated as a weak
 117    hash.  */
 118 extern bool ggc_protect_identifiers;
 119
 120 /* Write out all GCed objects to F.  */
 121 extern void gt_pch_save (FILE *f);
 122
 123 \f
 124 /* Allocation.  */
 125
 126 /* The internal primitive.  */
 127 extern void *ggc_internal_alloc (size_t, void (*)(void *), size_t,
 128                                  size_t CXX_MEM_STAT_INFO)
 129      ATTRIBUTE_MALLOC;
 130
 131 inline void *
 132 ggc_internal_alloc (size_t s CXX_MEM_STAT_INFO)
 133 {
 134   return ggc_internal_alloc (s, NULL, 0, 1 PASS_MEM_STAT);
 135 }
 136
 137 extern size_t ggc_round_alloc_size (size_t requested_size);
 138
 139 /* Allocates cleared memory.  */
 140 extern void *ggc_internal_cleared_alloc (size_t, void (*)(void *),
 141                                          size_t, size_t
 142                                          CXX_MEM_STAT_INFO) ATTRIBUTE_MALLOC;
 143
 144 inline void *
 145 ggc_internal_cleared_alloc (size_t s CXX_MEM_STAT_INFO)
 146 {
 147   return ggc_internal_cleared_alloc (s, NULL, 0, 1 PASS_MEM_STAT);
 148 }
 149
 150 /* Resize a block.  */
 151 extern void *ggc_realloc (void *, size_t CXX_MEM_STAT_INFO);
 152
 153 /* Free a block.  To be used when known for certain it's not reachable.  */
 154 extern void ggc_free (void *);
 155
 156 extern void dump_ggc_loc_statistics ();
 157
 158 /* Reallocator.  */
 159 #define GGC_RESIZEVEC(T, P, N) \
 160     ((T *) ggc_realloc ((P), (N) * sizeof (T) MEM_STAT_INFO))
 161
 162 template<typename T>
 163 void
 164 finalize (void *p)
 165 {
 166   static_cast<T *> (p)->~T ();
 167 }
 168
 169 template<typename T>
 170 inline bool
 171 need_finalization_p ()
 172 {
 173 #if GCC_VERSION >= 4003
 174   return !__has_trivial_destructor (T);
 175 #else
 176   return true;
 177 #endif
 178 }
 179
 180 template<typename T>
 181 inline T *
 182 ggc_alloc (ALONE_CXX_MEM_STAT_INFO)
 183 {
 184   if (need_finalization_p<T> ())
 185     return static_cast<T *> (ggc_internal_alloc (sizeof (T), finalize<T>, 0, 1
 186                                                  PASS_MEM_STAT));
 187   else
 188     return static_cast<T *> (ggc_internal_alloc (sizeof (T), NULL, 0, 1
 189                                                  PASS_MEM_STAT));
 190 }
 191
 192 /* GGC allocation function that does not call finalizer for type
 193    that have need_finalization_p equal to true.  User is responsible
 194    for calling of the destructor.  */
 195
 196 template<typename T>
 197 inline T *
 198 ggc_alloc_no_dtor (ALONE_CXX_MEM_STAT_INFO)
 199 {
 200   return static_cast<T *> (ggc_internal_alloc (sizeof (T), NULL, 0, 1
 201                                                PASS_MEM_STAT));
 202 }
 203
 204 template<typename T>
 205 inline T *
 206 ggc_cleared_alloc (ALONE_CXX_MEM_STAT_INFO)
 207 {
 208   if (need_finalization_p<T> ())
 209     return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T),
 210                                                          finalize<T>, 0, 1
 211                                                          PASS_MEM_STAT));
 212   else
 213     return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T), NULL, 0, 1
 214                                                          PASS_MEM_STAT));
 215 }
 216
 217 template<typename T>
 218 inline T *
 219 ggc_vec_alloc (size_t c CXX_MEM_STAT_INFO)
 220 {
 221   if (need_finalization_p<T> ())
 222     return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), finalize<T>,
 223                                                  sizeof (T), c PASS_MEM_STAT));
 224   else
 225     return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), NULL, 0, 0
 226                                                  PASS_MEM_STAT));
 227 }
 228
 229 template<typename T>
 230 inline T *
 231 ggc_cleared_vec_alloc (size_t c CXX_MEM_STAT_INFO)
 232 {
 233   if (need_finalization_p<T> ())
 234     return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T),
 235                                                          finalize<T>,
 236                                                          sizeof (T), c
 237                                                          PASS_MEM_STAT));
 238   else
 239     return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T), NULL,
 240                                                          0, 0 PASS_MEM_STAT));
 241 }
 242
 243 inline void *
 244 ggc_alloc_atomic (size_t s CXX_MEM_STAT_INFO)
 245 {
 246     return ggc_internal_alloc (s PASS_MEM_STAT);
 247 }
 248
 249 /* Call destructor and free the garbage collected memory.  */
 250
 251 template <typename T>
 252 inline void
 253 ggc_delete (T *ptr)
 254 {
 255   ptr->~T ();
 256   ggc_free (ptr);
 257 }
 258
 259 /* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
 260    If LENGTH is -1, then CONTENTS is assumed to be a
 261    null-terminated string and the memory sized accordingly.  */
 262 extern const char *ggc_alloc_string (const char *contents, int length
 263                                      CXX_MEM_STAT_INFO);
 264
 265 /* Make a copy of S, in GC-able memory.  */
 266 #define ggc_strdup(S) ggc_alloc_string ((S), -1 MEM_STAT_INFO)
 267
 268 /* Invoke the collector.  Garbage collection occurs only when this
 269    function is called, not during allocations.  */
 270 enum ggc_collect {
 271   GGC_COLLECT_HEURISTIC,
 272   GGC_COLLECT_FORCE
 273 };
 274 extern void ggc_collect (enum ggc_collect mode = GGC_COLLECT_HEURISTIC);
 275
 276 /* Return unused memory pages to the system.  */
 277 extern void ggc_trim (void);
 278
 279 /* Assume that all GGC memory is reachable and grow the limits for next collection. */
 280 extern void ggc_grow (void);
 281
 282 /* Register an additional root table.  This can be useful for some
 283    plugins.  Does nothing if the passed pointer is NULL. */
 284 extern void ggc_register_root_tab (const struct ggc_root_tab *);
 285
 286 /* Read objects previously saved with gt_pch_save from F.  */
 287 extern void gt_pch_restore (FILE *f);
 288 \f
 289 /* Statistics.  */
 290
 291 /* Print allocation statistics.  */
 292 extern void ggc_print_statistics (void);
 293
 294 extern void stringpool_statistics (void);
 295
 296 /* Heuristics.  */
 297 extern void init_ggc_heuristics (void);
 298
 299 /* Report current heap memory use to stderr.  */
 300 extern void report_heap_memory_use (void);
 301
 302 #define ggc_alloc_rtvec_sized(NELT)                             \
 303   (rtvec_def *) ggc_internal_alloc (sizeof (struct rtvec_def)           \
 304                        + ((NELT) - 1) * sizeof (rtx))           \
 305
 306 /* Memory statistics passing versions of some allocators.  Too few of them to
 307    make gengtype produce them, so just define the needed ones here.  */
 308 inline struct rtx_def *
 309 ggc_alloc_rtx_def_stat (size_t s CXX_MEM_STAT_INFO)
 310 {
 311   return (struct rtx_def *) ggc_internal_alloc (s PASS_MEM_STAT);
 312 }
 313
 314 inline union tree_node *
 315 ggc_alloc_tree_node_stat (size_t s CXX_MEM_STAT_INFO)
 316 {
 317   return (union tree_node *) ggc_internal_alloc (s PASS_MEM_STAT);
 318 }
 319
 320 inline union tree_node *
 321 ggc_alloc_cleared_tree_node_stat (size_t s CXX_MEM_STAT_INFO)
 322 {
 323   return (union tree_node *) ggc_internal_cleared_alloc (s PASS_MEM_STAT);
 324 }
 325
 326 inline gimple *
 327 ggc_alloc_cleared_gimple_statement_stat (size_t s CXX_MEM_STAT_INFO)
 328 {
 329   return (gimple *) ggc_internal_cleared_alloc (s PASS_MEM_STAT);
 330 }
 331
 332 inline void
 333 gt_ggc_mx (const char *s)
 334 {
 335   ggc_test_and_set_mark (const_cast<char *> (s));
 336 }
 337
 338 inline void
 339 gt_pch_nx (const char *)
 340 {
 341 }
 342
 343 inline void gt_pch_nx (bool) { }
 344 inline void gt_pch_nx (char) { }
 345 inline void gt_pch_nx (signed char) { }
 346 inline void gt_pch_nx (unsigned char) { }
 347 inline void gt_pch_nx (short) { }
 348 inline void gt_pch_nx (unsigned short) { }
 349 inline void gt_pch_nx (int) { }
 350 inline void gt_pch_nx (unsigned int) { }
 351 inline void gt_pch_nx (long int) { }
 352 inline void gt_pch_nx (unsigned long int) { }
 353 inline void gt_pch_nx (long long int) { }
 354 inline void gt_pch_nx (unsigned long long int) { }
 355
 356 inline void gt_ggc_mx (bool) { }
 357 inline void gt_ggc_mx (char) { }
 358 inline void gt_ggc_mx (signed char) { }
 359 inline void gt_ggc_mx (unsigned char) { }
 360 inline void gt_ggc_mx (short) { }
 361 inline void gt_ggc_mx (unsigned short) { }
 362 inline void gt_ggc_mx (int) { }
 363 inline void gt_ggc_mx (unsigned int) { }
 364 inline void gt_ggc_mx (long int) { }
 365 inline void gt_ggc_mx (unsigned long int) { }
 366 inline void gt_ggc_mx (long long int) { }
 367 inline void gt_ggc_mx (unsigned long long int) { }
 368
 369 #endif