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