Branch data Line data Source code
1 : : /* Generate CTF.
2 : : Copyright (C) 2019-2025 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 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "target.h"
24 : : #include "toplev.h"
25 : : #include "ctfc.h"
26 : : #include "diagnostic-core.h"
27 : :
28 : : /* A CTF container object - one per translation unit. */
29 : :
30 : : ctf_container_ref tu_ctfc;
31 : :
32 : : ctf_container_ref
33 : 3244 : ctf_get_tu_ctfc (void)
34 : : {
35 : 3244 : return tu_ctfc;
36 : : }
37 : :
38 : : /* If the next ctf type id is still set to the init value, no ctf records to
39 : : report. */
40 : : bool
41 : 428 : ctfc_is_empty_container (ctf_container_ref ctfc)
42 : : {
43 : 428 : return ((ctfc)->ctfc_nextid == CTF_INIT_TYPEID);
44 : : }
45 : :
46 : : /* Get the total number of CTF types in the container. */
47 : :
48 : : unsigned int
49 : 318 : ctfc_get_num_ctf_types (ctf_container_ref ctfc)
50 : : {
51 : 318 : return ctfc->ctfc_types->elements ();
52 : : }
53 : :
54 : : /* Get the total number of CTF variables in the container. */
55 : :
56 : 318 : unsigned int ctfc_get_num_ctf_vars (ctf_container_ref ctfc)
57 : : {
58 : 318 : return ctfc->ctfc_vars->elements ();
59 : : }
60 : :
61 : : /* Get reference to the CTF string table or the CTF auxilliary
62 : : string table. */
63 : :
64 : : ctf_strtable_t *
65 : 3314 : ctfc_get_strtab (ctf_container_ref ctfc, int aux)
66 : : {
67 : 3314 : return aux ? &(ctfc)->ctfc_aux_strtable : &(ctfc->ctfc_strtable);
68 : : }
69 : :
70 : : /* Get the length of the specified string table of the CTF container. */
71 : :
72 : : size_t
73 : 481 : ctfc_get_strtab_len (ctf_container_ref ctfc, int aux)
74 : : {
75 : 481 : ctf_strtable_t * strtab = ctfc_get_strtab (ctfc, aux);
76 : 481 : return strtab->ctstab_len;
77 : : }
78 : :
79 : : /* Get the number of bytes to represent the variable length portion of all CTF
80 : : types in the CTF container. */
81 : :
82 : 318 : size_t ctfc_get_num_vlen_bytes (ctf_container_ref ctfc)
83 : : {
84 : 318 : return ctfc->ctfc_num_vlen_bytes;
85 : : }
86 : :
87 : : /* Return which member of the union is used in CTFTYPE. Used for garbage
88 : : collection. */
89 : :
90 : : enum ctf_dtu_d_union_enum
91 : 0 : ctf_dtu_d_union_selector (ctf_dtdef_ref ctftype)
92 : : {
93 : 0 : uint32_t kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info);
94 : 0 : switch (kind)
95 : : {
96 : : case CTF_K_UNKNOWN:
97 : : case CTF_K_INTEGER:
98 : : case CTF_K_FLOAT:
99 : : return CTF_DTU_D_ENCODING;
100 : : case CTF_K_STRUCT:
101 : : case CTF_K_UNION:
102 : : case CTF_K_ENUM:
103 : : return CTF_DTU_D_MEMBERS;
104 : : case CTF_K_ARRAY:
105 : : return CTF_DTU_D_ARRAY;
106 : : case CTF_K_FUNCTION:
107 : : return CTF_DTU_D_ARGUMENTS;
108 : : case CTF_K_SLICE:
109 : : return CTF_DTU_D_SLICE;
110 : : case CTF_K_DECL_TAG:
111 : : case CTF_K_TYPE_TAG:
112 : : return CTF_DTU_D_TAG;
113 : : default:
114 : : /* The largest member as default. */
115 : : return CTF_DTU_D_ARRAY;
116 : : }
117 : : }
118 : :
119 : : /* Insert CTF type into the CTF container. */
120 : :
121 : : static void
122 : 1653 : ctf_dtd_insert (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
123 : : {
124 : 1653 : bool existed = false;
125 : 1653 : ctf_dtdef_ref entry = dtd;
126 : :
127 : 1653 : ctf_dtdef_ref * item = ctfc->ctfc_types->find_slot (entry, INSERT);
128 : 1653 : if (*item == NULL)
129 : 1653 : *item = dtd;
130 : : else
131 : : existed = true;
132 : : /* Duplicate CTF type records not expected to be inserted. */
133 : 1653 : gcc_assert (!existed);
134 : 1653 : }
135 : :
136 : : /* Lookup CTF type given a DWARF die for the type. */
137 : :
138 : : ctf_dtdef_ref
139 : 5409 : ctf_dtd_lookup (const ctf_container_ref ctfc, const dw_die_ref type)
140 : : {
141 : 5409 : ctf_dtdef_t entry;
142 : 5409 : entry.dtd_key = type;
143 : :
144 : 5409 : ctf_dtdef_ref * slot = ctfc->ctfc_types->find_slot (&entry, NO_INSERT);
145 : :
146 : 5409 : if (slot)
147 : 2079 : return (ctf_dtdef_ref)*slot;
148 : :
149 : : return NULL;
150 : : }
151 : :
152 : : /* Insert CTF variable into the CTF container. */
153 : :
154 : : static void
155 : 275 : ctf_dvd_insert (ctf_container_ref ctfc, ctf_dvdef_ref dvd)
156 : : {
157 : 275 : bool existed = false;
158 : 275 : ctf_dvdef_ref entry = dvd;
159 : :
160 : 275 : ctf_dvdef_ref * item = ctfc->ctfc_vars->find_slot (entry, INSERT);
161 : 275 : if (*item == NULL)
162 : 275 : *item = dvd;
163 : : else
164 : : existed = true;
165 : : /* Duplicate variable records not expected to be inserted. */
166 : 275 : gcc_assert (!existed);
167 : 275 : }
168 : :
169 : : /* Lookup CTF variable given a DWARF die for the decl. */
170 : :
171 : : ctf_dvdef_ref
172 : 378 : ctf_dvd_lookup (const ctf_container_ref ctfc, dw_die_ref die)
173 : : {
174 : 378 : ctf_dvdef_t entry;
175 : 378 : entry.dvd_key = die;
176 : :
177 : 378 : ctf_dvdef_ref * slot = ctfc->ctfc_vars->find_slot (&entry, NO_INSERT);
178 : :
179 : 378 : if (slot)
180 : 103 : return (ctf_dvdef_ref)*slot;
181 : :
182 : : return NULL;
183 : : }
184 : :
185 : : /* Insert a dummy CTF variable into the list of variables to be ignored. */
186 : :
187 : : static void
188 : 2 : ctf_dvd_ignore_insert (ctf_container_ref ctfc, ctf_dvdef_ref dvd)
189 : : {
190 : 2 : bool existed = false;
191 : 2 : ctf_dvdef_ref entry = dvd;
192 : :
193 : 2 : ctf_dvdef_ref * item = ctfc->ctfc_ignore_vars->find_slot (entry, INSERT);
194 : 2 : if (*item == NULL)
195 : 2 : *item = dvd;
196 : : else
197 : : existed = true;
198 : : /* Duplicate variable records not expected to be inserted. */
199 : 2 : gcc_assert (!existed);
200 : 2 : }
201 : :
202 : : /* Lookup the dummy CTF variable given the DWARF die for the non-defining
203 : : decl to be ignored. */
204 : :
205 : : bool
206 : 549 : ctf_dvd_ignore_lookup (const ctf_container_ref ctfc, dw_die_ref die)
207 : : {
208 : 549 : ctf_dvdef_t entry;
209 : 549 : entry.dvd_key = die;
210 : :
211 : 549 : ctf_dvdef_ref * slot = ctfc->ctfc_ignore_vars->find_slot (&entry, NO_INSERT);
212 : :
213 : 549 : if (slot)
214 : 1 : return true;
215 : :
216 : : return false;
217 : : }
218 : :
219 : : /* Append member definition to the list. Member list is a singly-linked list
220 : : with list start pointing to the head. */
221 : :
222 : : static void
223 : 282 : ctf_dmd_list_append (ctf_dmdef_t ** dmd, ctf_dmdef_t * elem)
224 : : {
225 : 282 : ctf_dmdef_t * tail = (dmd && *dmd) ? *dmd : NULL;
226 : : if (tail)
227 : : {
228 : 251 : while (tail->dmd_next)
229 : : tail = tail->dmd_next;
230 : :
231 : 159 : tail->dmd_next = elem;
232 : : }
233 : : else
234 : 123 : *dmd = elem;
235 : :
236 : 282 : elem->dmd_next = NULL;
237 : 282 : }
238 : :
239 : : /* Append function argument to the list. Member list is a singly-linked list
240 : : with list start pointing to the head. */
241 : :
242 : : static void
243 : 144 : ctf_farg_list_append (ctf_func_arg_t ** farg, ctf_func_arg_t * elem)
244 : : {
245 : 144 : ctf_func_arg_t * tail = (farg && *farg) ? *farg : NULL;
246 : : if (tail)
247 : : {
248 : 60 : while (tail->farg_next)
249 : : tail = tail->farg_next;
250 : :
251 : 51 : tail->farg_next = elem;
252 : : }
253 : : else
254 : 93 : *farg = elem;
255 : :
256 : 144 : elem->farg_next = NULL;
257 : 144 : }
258 : :
259 : : /* Append str to the CTF string table. */
260 : :
261 : : static void
262 : 3273 : ctfc_strtable_append_str (ctf_strtable_t * str_table, const char * str)
263 : : {
264 : 3273 : ctf_string_t * ctf_string = ggc_cleared_alloc<ctf_string_t> ();
265 : : /* Keep a reference to the input STR. */
266 : 3273 : ctf_string->cts_str = str;
267 : 3273 : ctf_string->cts_next = NULL;
268 : :
269 : 3273 : if (!str_table->ctstab_head)
270 : 861 : str_table->ctstab_head = ctf_string;
271 : :
272 : : /* Append to the end of the list. */
273 : 3273 : if (str_table->ctstab_tail)
274 : 2412 : str_table->ctstab_tail->cts_next = ctf_string;
275 : :
276 : 3273 : str_table->ctstab_tail = ctf_string;
277 : 3273 : }
278 : :
279 : : /* Wrapper function to add str to the CTF string table. No de-duplication of
280 : : CTF strings is done by the compiler. */
281 : :
282 : : static const char *
283 : 3694 : ctfc_strtable_add_str (ctf_strtable_t * str_table, const char * name,
284 : : uint32_t * name_offset)
285 : : {
286 : 3694 : size_t len;
287 : 3694 : char * ctf_string;
288 : : /* Return value is the offset to the string in the string table. */
289 : 3694 : uint32_t str_offset = str_table->ctstab_len;
290 : :
291 : : /* Add empty string only once at the beginning of the string table. Also, do
292 : : not add null strings, return the offset to the empty string for them. */
293 : 3694 : if ((!name || (name != NULL && !strcmp (name, ""))) && str_offset)
294 : : {
295 : 421 : ctf_string = CONST_CAST (char *, str_table->ctstab_estr);
296 : 421 : str_offset = 0;
297 : : }
298 : : else
299 : : {
300 : 861 : gcc_assert (name);
301 : : /* Add null-terminated strings to the string table. */
302 : 3273 : len = strlen (name) + 1;
303 : 3273 : ctf_string = CONST_CAST (char *, ggc_strdup (name));
304 : :
305 : 3273 : ctfc_strtable_append_str (str_table, ctf_string);
306 : : /* Add string to the string table. Keep number of strings updated. */
307 : 3273 : str_table->ctstab_num++;
308 : : /* Keep the number of bytes contained in the string table updated. */
309 : 3273 : str_table->ctstab_len += len;
310 : : }
311 : :
312 : 3694 : *name_offset = str_offset;
313 : :
314 : 3694 : return (const char *) ctf_string;
315 : :
316 : : }
317 : :
318 : : /* Add string to the appropriate string table in the CTF container. */
319 : :
320 : : const char *
321 : 2833 : ctf_add_string (ctf_container_ref ctfc, const char * name,
322 : : uint32_t * name_offset, int aux_str = CTF_STRTAB)
323 : : {
324 : : /* Get the CTF string table or the CTF auxilliary string table,
325 : : as applicable. */
326 : 2833 : ctf_strtable_t *str_table = ctfc_get_strtab (ctfc, aux_str);
327 : 2833 : return ctfc_strtable_add_str (str_table, name, name_offset);
328 : : }
329 : :
330 : : /* Add the compilation unit (CU) name string to the CTF string table. The
331 : : CU name has a prepended pwd string if it is a relative path. Also set the
332 : : CU name offset in the CTF container. */
333 : :
334 : : void
335 : 318 : ctf_add_cuname (ctf_container_ref ctfc, const char * filename)
336 : : {
337 : 318 : char * cuname = NULL;
338 : :
339 : : /* (filename at this point of compilation cannot be null). */
340 : :
341 : 318 : if (!IS_DIR_SEPARATOR (filename[0]))
342 : : {
343 : : /* Filename is a relative path. */
344 : 0 : const char * cu_pwd = get_src_pwd ();
345 : 0 : const int cu_pwd_len = strlen (cu_pwd);
346 : :
347 : : /* Add a DIR_SEPARATOR char before the filename. */
348 : 0 : const int len = cu_pwd_len + 2 + strlen (filename);
349 : :
350 : 0 : cuname = (char *) ggc_alloc_atomic (len);
351 : 0 : memset (cuname, 0, len);
352 : :
353 : 0 : strcpy (cuname, cu_pwd);
354 : 0 : cuname[cu_pwd_len] = DIR_SEPARATOR;
355 : 0 : cuname[cu_pwd_len+1] = 0;
356 : 0 : strcat (cuname, filename);
357 : : }
358 : : else
359 : : /* Filename is an absolute path. */
360 : 318 : cuname = CONST_CAST (char *, ggc_strdup (filename));
361 : :
362 : 318 : ctf_add_string (ctfc, cuname, &(ctfc->ctfc_cuname_offset));
363 : : /* Add 1 as CTF strings in the CTF string table are null-terminated
364 : : strings. */
365 : 318 : ctfc->ctfc_strlen += strlen (cuname) + 1;
366 : :
367 : : /* Mark cuname for garbage collection. */
368 : 318 : cuname = NULL;
369 : 318 : }
370 : :
371 : : /* Functions to create CTF types.
372 : :
373 : : These functions perform the task of adding CTF types to the CTF container.
374 : : No de-duplication is done by them; the onus is on the calling function to do
375 : : so. The caller must first do a lookup via ctf_dtd_lookup or
376 : : ctf_dvd_lookup, as applicable, to ascertain that the CTF type or the CTF
377 : : variable respectively does not already exist, and then add it. */
378 : :
379 : : static ctf_dtdef_ref
380 : 1653 : ctf_add_generic (ctf_container_ref ctfc, uint32_t flag, const char * name,
381 : : dw_die_ref die)
382 : : {
383 : 1653 : ctf_dtdef_ref dtd;
384 : 1653 : ctf_id_t type;
385 : :
386 : 1653 : gcc_assert (flag == CTF_ADD_NONROOT || flag == CTF_ADD_ROOT);
387 : :
388 : 1653 : dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
389 : :
390 : 1653 : type = ctfc->ctfc_nextid++;
391 : 1653 : gcc_assert (type < CTF_MAX_TYPE); /* CTF type ID overflow. */
392 : :
393 : : /* Buffer the strings in the CTF string table. */
394 : 1653 : dtd->dtd_name = ctf_add_string (ctfc, name, &(dtd->dtd_data.ctti_name));
395 : 1653 : dtd->dtd_type = type;
396 : 1653 : dtd->dtd_key = die;
397 : :
398 : 1653 : if ((name != NULL) && strcmp (name, ""))
399 : 1288 : ctfc->ctfc_strlen += strlen (name) + 1;
400 : :
401 : 1653 : ctf_dtd_insert (ctfc, dtd);
402 : :
403 : 1653 : return dtd;
404 : : }
405 : :
406 : : static ctf_dtdef_ref
407 : 678 : ctf_add_encoded (ctf_container_ref ctfc, uint32_t flag, const char * name,
408 : : const ctf_encoding_t * ep, uint32_t kind, dw_die_ref die)
409 : : {
410 : 678 : ctf_dtdef_ref dtd;
411 : :
412 : 678 : dtd = ctf_add_generic (ctfc, flag, name, die);
413 : :
414 : 678 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
415 : :
416 : 678 : uint32_t roundup_nbytes = (ROUND_UP (ep->cte_bits, BITS_PER_UNIT)
417 : : / BITS_PER_UNIT);
418 : :
419 : : /* FIXME, stay close to what libctf does. But by getting next power of two,
420 : : aren't we conveying less precise information. E.g. floating point mode
421 : : XF has a size of 12 bytes. */
422 : 1212 : dtd->dtd_data.ctti_size = roundup_nbytes ? (1 << ceil_log2 (roundup_nbytes))
423 : : : roundup_nbytes;
424 : 678 : dtd->dtd_u.dtu_enc = *ep;
425 : :
426 : 678 : ctfc->ctfc_num_stypes++;
427 : :
428 : 678 : return dtd;
429 : : }
430 : :
431 : : ctf_dtdef_ref
432 : 216 : ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
433 : : uint32_t kind, dw_die_ref die)
434 : : {
435 : 216 : ctf_dtdef_ref dtd;
436 : :
437 : 216 : gcc_assert (ref != NULL);
438 : :
439 : 216 : dtd = ctf_add_generic (ctfc, flag, NULL, die);
440 : 216 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
441 : : /* Caller of this API must guarantee that a CTF type with id = ref already
442 : : exists. This will also be validated for us at link-time. */
443 : 216 : dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type;
444 : 216 : dtd->ref_type = ref;
445 : :
446 : 216 : ctfc->ctfc_num_stypes++;
447 : :
448 : 216 : return dtd;
449 : : }
450 : :
451 : : ctf_dtdef_ref
452 : 13 : ctf_add_type_tag (ctf_container_ref ctfc, uint32_t flag, const char *value,
453 : : ctf_dtdef_ref ref_dtd)
454 : : {
455 : 13 : ctf_dtdef_ref dtd;
456 : : /* Create a DTD for the tag, but do not place it in the regular types list;
457 : : CTF format does not (yet) encode tags. */
458 : 13 : dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
459 : :
460 : 13 : dtd->dtd_name = ctf_add_string (ctfc, value, &(dtd->dtd_data.ctti_name),
461 : : CTF_AUX_STRTAB);
462 : : /* A single DW_TAG_GNU_annotation DIE may be referenced by multiple DIEs,
463 : : e.g. when multiple distinct types specify the same type tag. We will
464 : : synthesize multiple CTF DTD records in that case, so we cannot tie them
465 : : all to the same key (the DW_TAG_GNU_annotation DIE) in ctfc_types. */
466 : 13 : dtd->dtd_key = NULL;
467 : 13 : dtd->ref_type = ref_dtd;
468 : 13 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_TYPE_TAG, flag, 0);
469 : 13 : dtd->dtd_u.dtu_tag.ref_var = NULL; /* Not used for type tags. */
470 : 13 : dtd->dtd_u.dtu_tag.component_idx = 0; /* Not used for type tags. */
471 : :
472 : : /* Insert tag directly into the tag list. Type ID will be assigned later. */
473 : 13 : vec_safe_push (ctfc->ctfc_tags, dtd);
474 : :
475 : : /* Keep ctfc_aux_strlen updated. */
476 : 13 : if ((value != NULL) && strcmp (value, ""))
477 : 13 : ctfc->ctfc_aux_strlen += strlen (value) + 1;
478 : :
479 : 13 : return dtd;
480 : : }
481 : :
482 : : ctf_dtdef_ref
483 : 19 : ctf_add_decl_tag (ctf_container_ref ctfc, uint32_t flag, const char *value,
484 : : ctf_dtdef_ref ref_dtd, uint32_t comp_idx)
485 : : {
486 : 19 : ctf_dtdef_ref dtd;
487 : : /* Create a DTD for the tag, but do not place it in the regular types list;
488 : : ctf format does not (yet) encode tags. */
489 : 19 : dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
490 : :
491 : 19 : dtd->dtd_name = ctf_add_string (ctfc, value, &(dtd->dtd_data.ctti_name),
492 : : CTF_AUX_STRTAB);
493 : : /* A single DW_TAG_GNU_annotation DIE may be referenced by multiple DIEs,
494 : : e.g. when multiple distinct declarations specify the same decl tag.
495 : : We will synthesize multiple CTF DTD records in that case, so we cannot tie
496 : : them all to the same key (the DW_TAG_GNU_annotation DIE) in ctfc_types. */
497 : 19 : dtd->dtd_key = NULL;
498 : 19 : dtd->ref_type = ref_dtd;
499 : 19 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_DECL_TAG, flag, 0);
500 : 19 : dtd->dtd_u.dtu_tag.ref_var = NULL;
501 : 19 : dtd->dtd_u.dtu_tag.component_idx = comp_idx;
502 : :
503 : : /* Insert tag directly into the tag list. Type ID will be assigned later. */
504 : 19 : vec_safe_push (ctfc->ctfc_tags, dtd);
505 : :
506 : : /* Keep ctfc_aux_strlen updated. */
507 : 19 : if ((value != NULL) && strcmp (value, ""))
508 : 19 : ctfc->ctfc_aux_strlen += strlen (value) + 1;
509 : :
510 : 19 : return dtd;
511 : : }
512 : :
513 : : ctf_dtdef_ref
514 : 12 : ctf_add_forward (ctf_container_ref ctfc, uint32_t flag, const char * name,
515 : : uint32_t kind, dw_die_ref die)
516 : : {
517 : 12 : ctf_dtdef_ref dtd;
518 : :
519 : 12 : dtd = ctf_add_generic (ctfc, flag, name, die);
520 : :
521 : 12 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
522 : 12 : dtd->dtd_data.ctti_type = kind;
523 : :
524 : 12 : ctfc->ctfc_num_stypes++;
525 : :
526 : 12 : return dtd;
527 : : }
528 : :
529 : : ctf_dtdef_ref
530 : 58 : ctf_add_typedef (ctf_container_ref ctfc, uint32_t flag, const char * name,
531 : : ctf_dtdef_ref ref, dw_die_ref die)
532 : : {
533 : 58 : ctf_dtdef_ref dtd;
534 : :
535 : 58 : gcc_assert (ref != NULL);
536 : : /* Nameless Typedefs are not expected. */
537 : 58 : gcc_assert ((name != NULL) && strcmp (name, ""));
538 : :
539 : 58 : dtd = ctf_add_generic (ctfc, flag, name, die);
540 : 58 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
541 : 58 : dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type;
542 : 58 : dtd->ref_type = ref;
543 : :
544 : 58 : gcc_assert (dtd->dtd_type != dtd->dtd_data.ctti_type);
545 : :
546 : 58 : ctfc->ctfc_num_stypes++;
547 : :
548 : 58 : return dtd;
549 : : }
550 : :
551 : : ctf_dtdef_ref
552 : 22 : ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
553 : : uint32_t bit_offset, uint32_t bit_size, dw_die_ref die)
554 : : {
555 : 22 : ctf_dtdef_ref dtd;
556 : 22 : uint32_t roundup_nbytes;
557 : :
558 : 22 : gcc_assert ((bit_size <= 255) && (bit_offset <= 255));
559 : :
560 : 22 : gcc_assert (ref != NULL);
561 : :
562 : 22 : dtd = ctf_add_generic (ctfc, flag, NULL, die);
563 : :
564 : 22 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
565 : :
566 : 22 : roundup_nbytes = (ROUND_UP (bit_size, BITS_PER_UNIT) / BITS_PER_UNIT);
567 : : /* FIXME, stay close to what libctf does. But by getting next power of two,
568 : : aren't we conveying less precise information, especially for bitfields.
569 : : For example, cte_bits = 33, roundup_nbytes = 5, ctti_size = 8 in the
570 : : implementation below. */
571 : 33 : dtd->dtd_data.ctti_size = roundup_nbytes ? (1 << ceil_log2 (roundup_nbytes))
572 : : : 0;
573 : :
574 : 22 : dtd->dtd_u.dtu_slice.cts_type = ref;
575 : 22 : dtd->dtd_u.dtu_slice.cts_bits = bit_size;
576 : 22 : dtd->dtd_u.dtu_slice.cts_offset = bit_offset;
577 : :
578 : 22 : ctfc->ctfc_num_stypes++;
579 : :
580 : 22 : return dtd;
581 : : }
582 : :
583 : : ctf_dtdef_ref
584 : 34 : ctf_add_float (ctf_container_ref ctfc, uint32_t flag,
585 : : const char * name, const ctf_encoding_t * ep, dw_die_ref die)
586 : : {
587 : 34 : return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_FLOAT, die));
588 : : }
589 : :
590 : : ctf_dtdef_ref
591 : 633 : ctf_add_integer (ctf_container_ref ctfc, uint32_t flag,
592 : : const char * name, const ctf_encoding_t * ep, dw_die_ref die)
593 : : {
594 : 633 : return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_INTEGER, die));
595 : : }
596 : :
597 : : ctf_dtdef_ref
598 : 11 : ctf_add_unknown (ctf_container_ref ctfc, uint32_t flag,
599 : : const char * name, const ctf_encoding_t * ep, dw_die_ref die)
600 : : {
601 : 11 : return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_UNKNOWN, die));
602 : : }
603 : :
604 : : ctf_dtdef_ref
605 : 149 : ctf_add_pointer (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
606 : : dw_die_ref die)
607 : : {
608 : 149 : return (ctf_add_reftype (ctfc, flag, ref, CTF_K_POINTER, die));
609 : : }
610 : :
611 : : ctf_dtdef_ref
612 : 92 : ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp,
613 : : dw_die_ref die)
614 : : {
615 : 92 : ctf_dtdef_ref dtd;
616 : :
617 : 92 : gcc_assert (arp);
618 : :
619 : : /* Caller of this API must make sure CTF type for arp->ctr_contents and
620 : : arp->ctr_index are already added. This will also be validated for us at
621 : : link-time. */
622 : :
623 : 92 : dtd = ctf_add_generic (ctfc, flag, NULL, die);
624 : :
625 : 92 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
626 : 92 : dtd->dtd_data.ctti_size = 0;
627 : 92 : dtd->dtd_u.dtu_arr = *arp;
628 : :
629 : 92 : ctfc->ctfc_num_stypes++;
630 : :
631 : 92 : return dtd;
632 : : }
633 : :
634 : : ctf_dtdef_ref
635 : 14 : ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name,
636 : : HOST_WIDE_INT size, bool eunsigned, dw_die_ref die)
637 : : {
638 : 14 : ctf_dtdef_ref dtd;
639 : :
640 : : /* In the compiler, no need to handle the case of promoting forwards to
641 : : enums. This comment is simply to note a divergence from libctf. */
642 : :
643 : : /* The compiler does, however, update any previously existing forward types
644 : : to non-root. CTF does not allow existence of two root types with the same
645 : : name. */
646 : 14 : ctf_dtdef_ref enum_fwd_type = ctf_dtd_lookup (ctfc, die);
647 : 14 : if (enum_fwd_type)
648 : : {
649 : 0 : enum_fwd_type->dtd_data.ctti_info
650 : 0 : = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0);
651 : : }
652 : :
653 : 14 : dtd = ctf_add_generic (ctfc, flag, name, die);
654 : :
655 : 14 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
656 : :
657 : : /* Size in bytes should always fit, of course.
658 : : TBD WARN - warn instead? */
659 : 14 : gcc_assert (size <= CTF_MAX_SIZE);
660 : :
661 : 14 : dtd->dtd_data.ctti_size = size;
662 : 14 : dtd->dtd_enum_unsigned = eunsigned;
663 : :
664 : 14 : ctfc->ctfc_num_stypes++;
665 : :
666 : 14 : return dtd;
667 : : }
668 : :
669 : : int
670 : 45 : ctf_add_enumerator (ctf_container_ref ctfc, ctf_dtdef_ref enum_dtd,
671 : : const char * name, HOST_WIDE_INT value, dw_die_ref die)
672 : : {
673 : 45 : ctf_dmdef_t * dmd;
674 : 45 : uint32_t kind, vlen, root;
675 : :
676 : : /* The associated CTF type of kind CTF_K_ENUM must already exist.
677 : : This will also be validated for us at link-time. */
678 : 45 : ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die);
679 : 45 : gcc_assert (dtd);
680 : 45 : gcc_assert (dtd == enum_dtd);
681 : 45 : gcc_assert (name);
682 : :
683 : 45 : kind = CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info);
684 : 45 : root = CTF_V2_INFO_ISROOT (dtd->dtd_data.ctti_info);
685 : 45 : vlen = CTF_V2_INFO_VLEN (dtd->dtd_data.ctti_info);
686 : :
687 : 45 : gcc_assert (kind == CTF_K_ENUM && vlen < CTF_MAX_VLEN);
688 : :
689 : : /* Enum value is of type HOST_WIDE_INT in the compiler, CTF enumerators
690 : : values in ctf_enum_t is limited to int32_t, BTF supports signed and
691 : : unsigned enumerators values of 32 and 64 bits, for both debug formats
692 : : we use ctf_dmdef_t.dmd_value entry of HOST_WIDE_INT type. So check
693 : : CTF bounds and skip adding this enum value if out of bounds. */
694 : 45 : if (!btf_debuginfo_p() && ((value > INT_MAX) || (value < INT_MIN)))
695 : : {
696 : : /* FIXME - Note this TBD_CTF_REPRESENTATION_LIMIT. */
697 : : return (1);
698 : : }
699 : :
700 : 43 : dmd = ggc_cleared_alloc<ctf_dmdef_t> ();
701 : :
702 : : /* Buffer the strings in the CTF string table. */
703 : 43 : dmd->dmd_name = ctf_add_string (ctfc, name, &(dmd->dmd_name_offset));
704 : 43 : dmd->dmd_type = NULL;
705 : 43 : dmd->dmd_offset = 0;
706 : :
707 : 43 : dmd->dmd_value = value;
708 : :
709 : 43 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, root, vlen + 1);
710 : 43 : ctf_dmd_list_append (&dtd->dtd_u.dtu_members, dmd);
711 : :
712 : 43 : if ((name != NULL) && strcmp (name, ""))
713 : 43 : ctfc->ctfc_strlen += strlen (name) + 1;
714 : :
715 : : return (0);
716 : : }
717 : :
718 : : int
719 : 239 : ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou,
720 : : const char * name, ctf_dtdef_ref type,
721 : : uint64_t bit_offset)
722 : : {
723 : 239 : ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, sou);
724 : 239 : ctf_dmdef_t * dmd;
725 : :
726 : 239 : uint32_t kind, vlen, root;
727 : :
728 : : /* The type of the member being added must already exist. */
729 : 239 : gcc_assert (dtd);
730 : :
731 : 239 : kind = CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info);
732 : 239 : root = CTF_V2_INFO_ISROOT (dtd->dtd_data.ctti_info);
733 : 239 : vlen = CTF_V2_INFO_VLEN (dtd->dtd_data.ctti_info);
734 : :
735 : 239 : gcc_assert (kind == CTF_K_STRUCT || kind == CTF_K_UNION);
736 : 239 : gcc_assert (vlen < CTF_MAX_VLEN);
737 : :
738 : 239 : dmd = ggc_cleared_alloc<ctf_dmdef_t> ();
739 : :
740 : : /* Buffer the strings in the CTF string table. */
741 : 239 : dmd->dmd_name = ctf_add_string (ctfc, name, &(dmd->dmd_name_offset));
742 : 239 : dmd->dmd_type = type;
743 : 239 : dmd->dmd_value = -1;
744 : :
745 : 239 : if (kind == CTF_K_STRUCT && vlen != 0)
746 : 115 : dmd->dmd_offset = bit_offset;
747 : : else
748 : 124 : dmd->dmd_offset = 0;
749 : :
750 : 239 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, root, vlen + 1);
751 : 239 : ctf_dmd_list_append (&dtd->dtd_u.dtu_members, dmd);
752 : :
753 : 239 : if ((name != NULL) && strcmp (name, ""))
754 : 237 : ctfc->ctfc_strlen += strlen (name) + 1;
755 : :
756 : 239 : return 0;
757 : : }
758 : :
759 : : ctf_dvdef_ref
760 : 275 : ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_dtdef_ref ref,
761 : : dw_die_ref die, unsigned int external_vis,
762 : : dw_die_ref die_var_decl)
763 : : {
764 : 275 : ctf_dvdef_ref dvd = NULL, dvd_ignore;
765 : :
766 : 275 : gcc_assert (name);
767 : :
768 : 275 : if (name != NULL)
769 : : {
770 : 275 : dvd = ggc_cleared_alloc<ctf_dvdef_t> ();
771 : 275 : dvd->dvd_key = die;
772 : : /* Buffer the strings in the CTF string table. */
773 : 275 : dvd->dvd_name = ctf_add_string (ctfc, name, &(dvd->dvd_name_offset));
774 : 275 : dvd->dvd_visibility = external_vis;
775 : 275 : dvd->dvd_type = ref;
776 : :
777 : : /* If DW_AT_specification attribute exists, keep track of it as this is
778 : : the non-defining declaration corresponding to the variable. We will
779 : : skip emitting CTF variable for such incomplete, non-defining
780 : : declarations.
781 : : There could be some non-defining declarations, however, for which a
782 : : defining declaration does not show up in the same CU. For such
783 : : cases, the compiler continues to emit CTF variable record as
784 : : usual. */
785 : 275 : if (die_var_decl)
786 : : {
787 : 2 : dvd_ignore = ggc_cleared_alloc<ctf_dvdef_t> ();
788 : 2 : dvd_ignore->dvd_key = die_var_decl;
789 : : /* It's alright to leave other fields as zero. No valid CTF
790 : : variable will be added for these DW_TAG_variable DIEs. */
791 : 2 : ctf_dvd_ignore_insert (ctfc, dvd_ignore);
792 : : }
793 : :
794 : 275 : ctf_dvd_insert (ctfc, dvd);
795 : :
796 : 275 : if (strcmp (name, ""))
797 : 275 : ctfc->ctfc_strlen += strlen (name) + 1;
798 : : }
799 : :
800 : 275 : return dvd;
801 : : }
802 : :
803 : : int
804 : 144 : ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func,
805 : : const char * name, ctf_dtdef_ref arg_dtd)
806 : : {
807 : 144 : ctf_dtdef_ref func_dtd = ctf_dtd_lookup (ctfc, func);
808 : 144 : ctf_func_arg_t * farg;
809 : 144 : uint32_t vlen;
810 : :
811 : : /* The function to which argument is being added must already exist. */
812 : 144 : gcc_assert (func_dtd);
813 : : /* The number of args must have been non-zero. */
814 : 144 : vlen = CTF_V2_INFO_VLEN (func_dtd->dtd_data.ctti_info);
815 : 144 : gcc_assert (vlen);
816 : :
817 : 144 : farg = ggc_cleared_alloc<ctf_func_arg_t> ();
818 : :
819 : : /* Buffer the strings in the auxilliary string table. CTF V3 format does not
820 : : require function argument names. Use auxilliary string table to keep
821 : : these strings to avoid unnecessary bloat in CTF section in CTF V3. */
822 : 144 : farg->farg_name = ctf_add_string (ctfc, name, &(farg->farg_name_offset),
823 : : CTF_AUX_STRTAB);
824 : 144 : farg->farg_type = arg_dtd;
825 : :
826 : 144 : ctf_farg_list_append (&func_dtd->dtd_u.dtu_argv, farg);
827 : :
828 : : /* For aux_str, keep ctfc_aux_strlen updated for debugging. */
829 : 144 : if ((name != NULL) && strcmp (name, ""))
830 : 112 : ctfc->ctfc_aux_strlen += strlen (name) + 1;
831 : :
832 : 144 : return 0;
833 : : }
834 : :
835 : : ctf_dtdef_ref
836 : 450 : ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name,
837 : : const ctf_funcinfo_t * ctc, dw_die_ref die,
838 : : bool from_global_func, int linkage)
839 : : {
840 : 450 : ctf_dtdef_ref dtd;
841 : 450 : uint32_t vlen;
842 : :
843 : 450 : gcc_assert (ctc);
844 : :
845 : 450 : vlen = ctc->ctc_argc;
846 : 450 : gcc_assert (vlen <= CTF_MAX_VLEN);
847 : :
848 : 450 : dtd = ctf_add_generic (ctfc, flag, name, die);
849 : :
850 : 450 : dtd->from_global_func = from_global_func;
851 : 450 : dtd->linkage = linkage;
852 : 450 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
853 : 450 : dtd->ref_type = ctc->ctc_return;
854 : : /* Caller must make sure CTF types for ctc->ctc_return are already added. */
855 : 450 : dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return->dtd_type;
856 : : /* Caller must make sure CTF types for function arguments are already added
857 : : via ctf_add_function_arg () API. */
858 : :
859 : 450 : ctfc->ctfc_num_stypes++;
860 : :
861 : 450 : return dtd;
862 : : }
863 : :
864 : : ctf_dtdef_ref
865 : 111 : ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name,
866 : : uint32_t kind, unsigned HOST_WIDE_INT size, dw_die_ref die)
867 : : {
868 : 111 : ctf_dtdef_ref dtd;
869 : :
870 : 111 : gcc_assert ((kind == CTF_K_STRUCT) || (kind == CTF_K_UNION));
871 : :
872 : : /* In the compiler, no need to handle the case of promoting forwards to
873 : : structs. This comment is simply to note a divergence from libctf. */
874 : :
875 : : /* The compiler does, however, update any previously existing forward types
876 : : to non-root. CTF does not allow existence of two root types with the same
877 : : name. */
878 : 111 : ctf_dtdef_ref sou_fwd_type = ctf_dtd_lookup (ctfc, die);
879 : 111 : if (sou_fwd_type)
880 : : {
881 : 0 : sou_fwd_type->dtd_data.ctti_info
882 : 0 : = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0);
883 : : }
884 : :
885 : 111 : dtd = ctf_add_generic (ctfc, flag, name, die);
886 : :
887 : 111 : dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
888 : :
889 : 111 : if (size > CTF_MAX_SIZE)
890 : : {
891 : 1 : dtd->dtd_data.ctti_size = CTF_LSIZE_SENT;
892 : 1 : dtd->dtd_data.ctti_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
893 : 1 : dtd->dtd_data.ctti_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
894 : 1 : ctfc->ctfc_num_types++;
895 : : }
896 : : else
897 : : {
898 : 110 : dtd->dtd_data.ctti_size = (uint32_t) size;
899 : 110 : ctfc->ctfc_num_stypes++;
900 : : }
901 : :
902 : 111 : return dtd;
903 : : }
904 : :
905 : : /* Given a TREE_TYPE node, return the CTF type object for that type. */
906 : :
907 : : ctf_dtdef_ref
908 : 0 : ctf_lookup_tree_type (ctf_container_ref ctfc, const tree type)
909 : : {
910 : 0 : dw_die_ref die = lookup_type_die (type);
911 : 0 : if (die == NULL)
912 : : return NULL;
913 : :
914 : 0 : ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die);
915 : 0 : if (dtd == NULL)
916 : : return NULL;
917 : :
918 : : return dtd;
919 : : }
920 : :
921 : : /* Check if CTF for TYPE has already been generated. Mainstay for
922 : : de-duplication. If CTF type already exists, returns TRUE and updates
923 : : the CTF type object DTD for the caller. */
924 : :
925 : : bool
926 : 4691 : ctf_type_exists (ctf_container_ref ctfc, dw_die_ref type,
927 : : ctf_dtdef_ref * dtd)
928 : : {
929 : 4691 : bool exists = false;
930 : 4691 : ctf_dtdef_ref ctf_type_seen = ctf_dtd_lookup (ctfc, type);
931 : :
932 : 4691 : if (ctf_type_seen)
933 : : {
934 : 1486 : exists = true;
935 : : /* CTF type for this type exists. */
936 : 1486 : *dtd = ctf_type_seen;
937 : : }
938 : :
939 : 4691 : return exists;
940 : : }
941 : :
942 : : /* Location information for CTF Types and CTF Variables. CTF section does not
943 : : emit location information; at this time, location information is needed for
944 : : BTF CO-RE use-cases. */
945 : :
946 : : int
947 : 0 : ctfc_get_dtd_srcloc (ctf_dtdef_ref dtd, ctf_srcloc_ref loc)
948 : : {
949 : 0 : loc->ctsloc_file = ctf_get_die_loc_file (dtd->dtd_key);
950 : 0 : loc->ctsloc_line = ctf_get_die_loc_line (dtd->dtd_key);
951 : 0 : loc->ctsloc_col = ctf_get_die_loc_col (dtd->dtd_key);
952 : :
953 : 0 : if (loc->ctsloc_file == NULL)
954 : 0 : return 1;
955 : :
956 : : return 0;
957 : : }
958 : :
959 : : int
960 : 0 : ctfc_get_dvd_srcloc (ctf_dvdef_ref dvd, ctf_srcloc_ref loc)
961 : : {
962 : 0 : loc->ctsloc_file = ctf_get_die_loc_file (dvd->dvd_key);
963 : 0 : loc->ctsloc_line = ctf_get_die_loc_line (dvd->dvd_key);
964 : 0 : loc->ctsloc_col = ctf_get_die_loc_col (dvd->dvd_key);
965 : :
966 : 0 : if (loc->ctsloc_file == NULL)
967 : 0 : return 1;
968 : :
969 : : return 0;
970 : : }
971 : :
972 : : /* CTF container setup and teardown routines. */
973 : :
974 : : /* Initialize the CTF string table.
975 : : The first entry in the CTF string table (empty string) is added. */
976 : :
977 : : void
978 : 861 : init_ctf_strtable (ctf_strtable_t * strtab)
979 : : {
980 : 861 : strtab->ctstab_head = NULL;
981 : 861 : strtab->ctstab_tail = NULL;
982 : 861 : strtab->ctstab_num = 0;
983 : 861 : strtab->ctstab_len = 0;
984 : :
985 : : /* The first entry in the CTF string table is an empty string. E.g., CTF
986 : : type records with no name (like CTF_K_CONST, CTF_K_VOLATILE etc) point to
987 : : this string. */
988 : 861 : uint32_t estr_offset = 0;
989 : 861 : strtab->ctstab_estr = ctfc_strtable_add_str (strtab, "", &estr_offset);
990 : 861 : }
991 : :
992 : : /* Initialize the string tables in the CTF container. */
993 : :
994 : : static void
995 : 428 : init_ctf_string_table (ctf_container_ref ctfc)
996 : : {
997 : 428 : init_ctf_strtable (&ctfc->ctfc_strtable);
998 : 428 : ctfc->ctfc_strlen++;
999 : :
1000 : 428 : init_ctf_strtable (&ctfc->ctfc_aux_strtable);
1001 : 428 : ctfc->ctfc_aux_strlen++;
1002 : 428 : }
1003 : :
1004 : : /* Allocate a new CTF container with the desired flags. */
1005 : :
1006 : : static inline ctf_container_ref
1007 : 428 : new_ctf_container (void)
1008 : : {
1009 : 428 : tu_ctfc = ggc_cleared_alloc<ctf_container_t> ();
1010 : 428 : tu_ctfc->ctfc_types
1011 : 428 : = hash_table<ctfc_dtd_hasher>::create_ggc (100);
1012 : 428 : tu_ctfc->ctfc_vars
1013 : 428 : = hash_table<ctfc_dvd_hasher>::create_ggc (100);
1014 : 428 : tu_ctfc->ctfc_ignore_vars
1015 : 428 : = hash_table<ctfc_dvd_hasher>::create_ggc (10);
1016 : :
1017 : 428 : vec_alloc (tu_ctfc->ctfc_tags, 100);
1018 : 428 : tu_ctfc->ctfc_type_tags_map
1019 : 428 : = hash_map<ctf_dtdef_ref, ctf_dtdef_ref>::create_ggc (100);
1020 : :
1021 : 428 : return tu_ctfc;
1022 : : }
1023 : :
1024 : : /* Initialize a CTF container per translation unit. */
1025 : :
1026 : : static void
1027 : 428 : init_ctf_container (void)
1028 : : {
1029 : 428 : tu_ctfc = new_ctf_container ();
1030 : :
1031 : 428 : tu_ctfc->ctfc_magic = CTF_MAGIC;
1032 : 428 : tu_ctfc->ctfc_version = CTF_VERSION;
1033 : 428 : tu_ctfc->ctfc_flags = CTF_F_NEWFUNCINFO;
1034 : 428 : tu_ctfc->ctfc_nextid = CTF_INIT_TYPEID;
1035 : :
1036 : 428 : init_ctf_string_table (tu_ctfc);
1037 : 428 : }
1038 : :
1039 : : void
1040 : 861 : ctfc_delete_strtab (ctf_strtable_t * strtab)
1041 : : {
1042 : 861 : ctf_string_t * str = NULL;
1043 : 861 : ctf_string_t * next_str = NULL;
1044 : :
1045 : 861 : str = strtab->ctstab_head;
1046 : 861 : next_str = str;
1047 : 4134 : while (next_str != NULL)
1048 : : {
1049 : 3273 : next_str = str->cts_next;
1050 : 3273 : ggc_free (str);
1051 : 3273 : str = next_str;
1052 : : }
1053 : :
1054 : 861 : strtab->ctstab_head = NULL;
1055 : 861 : strtab->ctstab_tail = NULL;
1056 : 861 : strtab->ctstab_estr = NULL;
1057 : 861 : }
1058 : :
1059 : : /* Delete the CTF container's resources. */
1060 : :
1061 : : void
1062 : 428 : ctfc_delete_container (ctf_container_ref ctfc)
1063 : : {
1064 : 428 : if (ctfc)
1065 : : {
1066 : 428 : ctfc->ctfc_types->empty ();
1067 : 428 : ctfc->ctfc_types = NULL;
1068 : :
1069 : 428 : ctfc->ctfc_vars->empty ();
1070 : 428 : ctfc->ctfc_types = NULL;
1071 : :
1072 : 428 : ctfc->ctfc_ignore_vars->empty ();
1073 : 428 : ctfc->ctfc_ignore_vars = NULL;
1074 : :
1075 : 428 : ctfc->ctfc_tags = NULL;
1076 : :
1077 : 428 : ctfc->ctfc_type_tags_map->empty ();
1078 : 428 : ctfc->ctfc_type_tags_map = NULL;
1079 : :
1080 : 428 : ctfc_delete_strtab (&ctfc->ctfc_strtable);
1081 : 428 : ctfc_delete_strtab (&ctfc->ctfc_aux_strtable);
1082 : 428 : if (ctfc->ctfc_vars_list)
1083 : : {
1084 : 192 : ggc_free (ctfc->ctfc_vars_list);
1085 : 192 : ctfc->ctfc_vars_list = NULL;
1086 : : }
1087 : 428 : if (ctfc->ctfc_types_list)
1088 : : {
1089 : 428 : ggc_free (ctfc->ctfc_types_list);
1090 : 428 : ctfc->ctfc_types_list = NULL;
1091 : : }
1092 : 428 : if (ctfc->ctfc_gfuncs_list)
1093 : : {
1094 : 261 : ggc_free (ctfc->ctfc_gfuncs_list);
1095 : 261 : ctfc->ctfc_gfuncs_list = NULL;
1096 : : }
1097 : 428 : if (ctfc->ctfc_gobjts_list)
1098 : : {
1099 : 82 : ggc_free (ctfc->ctfc_gobjts_list);
1100 : 82 : ctfc->ctfc_gobjts_list = NULL;
1101 : : }
1102 : :
1103 : 428 : ctfc= NULL;
1104 : : }
1105 : 428 : }
1106 : :
1107 : : /* CTF routines interfacing to the compiler. */
1108 : :
1109 : : void
1110 : 428 : ctf_init (void)
1111 : : {
1112 : 428 : init_ctf_container ();
1113 : 428 : }
|
