1 /* ctfc.h - Declarations and definitions related to the CTF container.
2 Copyright (C) 2019-2022 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 defines the data structures and functions used by the compiler
21 to generate the CTF debug info. The definitions below are compiler internal
22 representations and closely reflect the CTF format requirements in <ctf.h>.
23
24 The contents of the CTF container are used eventually for emission of both
25 CTF (ctfout.cc) and BTF debug info (btfout.cc), as the two type debug formats
26 are close cousins. */
27
28 #ifndef GCC_CTFC_H
29 #define GCC_CTFC_H 1
30
31 #include "config.h"
32 #include "system.h"
33 #include "tree.h"
34 #include "fold-const.h"
35 #include "dwarf2ctf.h"
36 #include "ctf.h"
37 #include "btf.h"
38
39 /* Invalid CTF type ID definition. */
40
41 #define CTF_NULL_TYPEID 0
42
43 /* Value to start generating the CTF type ID from. */
44
45 #define CTF_INIT_TYPEID 1
46
47 /* CTF type ID. */
48
49 typedef uint64_t ctf_id_t;
50
51 /* CTF string table element (list node). */
52
53 typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string
54 {
55 const char * cts_str; /* CTF string. */
56 struct ctf_string * cts_next; /* A list node. */
57 } ctf_string_t;
58
59 /* Internal representation of CTF string table. */
60
61 typedef struct GTY (()) ctf_strtable
62 {
63 ctf_string_t * ctstab_head; /* Head str ptr. */
64 ctf_string_t * ctstab_tail; /* Tail. new str appended to tail. */
65 int ctstab_num; /* Number of strings in the table. */
66 size_t ctstab_len; /* Size of string table in bytes. */
67 const char * ctstab_estr; /* Empty string "". */
68 } ctf_strtable_t;
69
70 /* Encoding information for integers, floating-point values etc. The flags
71 field will contain values appropriate for the type defined in <ctf.h>. */
72
73 typedef struct GTY (()) ctf_encoding
74 {
75 unsigned int cte_format; /* Data format (CTF_INT_* or CTF_FP_* flags). */
76 unsigned int cte_offset; /* Offset of value in bits. */
77 unsigned int cte_bits; /* Size of storage in bits. */
78 } ctf_encoding_t;
79
80 /* Array information for CTF generation. */
81
82 typedef struct GTY (()) ctf_arinfo
83 {
84 ctf_id_t ctr_contents; /* Type of array contents. */
85 ctf_id_t ctr_index; /* Type of array index. */
86 unsigned int ctr_nelems; /* Number of elements. */
87 } ctf_arinfo_t;
88
89 /* Function information for CTF generation. */
90
91 typedef struct GTY (()) ctf_funcinfo
92 {
93 ctf_id_t ctc_return; /* Function return type. */
94 unsigned int ctc_argc; /* Number of typed arguments to function. */
95 unsigned int ctc_flags; /* Function attributes (see below). */
96 } ctf_funcinfo_t;
97
98 typedef struct GTY (()) ctf_sliceinfo
99 {
100 unsigned int cts_type; /* Reference CTF type. */
101 unsigned short cts_offset; /* Offset in bits of the first bit. */
102 unsigned short cts_bits; /* Size in bits. */
103 } ctf_sliceinfo_t;
104
105 /* CTF type representation internal to the compiler. It closely reflects the
106 ctf_type_t type node in <ctf.h> except the GTY (()) tags. */
107
108 typedef struct GTY (()) ctf_itype
109 {
110 uint32_t ctti_name; /* Reference to name in string table. */
111 uint32_t ctti_info; /* Encoded kind, variant length (see below). */
112 union GTY ((desc ("0")))
113 {
114 uint32_t GTY ((tag ("0"))) _size;/* Size of entire type in bytes. */
115 uint32_t GTY ((tag ("1"))) _type;/* Reference to another type. */
116 } _u;
117 uint32_t ctti_lsizehi; /* High 32 bits of type size in bytes. */
118 uint32_t ctti_lsizelo; /* Low 32 bits of type size in bytes. */
119 } ctf_itype_t;
120
121 #define ctti_size _u._size
122 #define ctti_type _u._type
123
124 /* Function arguments end with varargs. */
125
126 #define CTF_FUNC_VARARG 0x1
127
128 /* Struct/union/enum member definition for CTF generation. */
129
130 typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef
131 {
132 const char * dmd_name; /* Name of this member. */
133 ctf_id_t dmd_type; /* Type of this member (for sou). */
134 uint32_t dmd_name_offset; /* Offset of the name in str table. */
135 uint64_t dmd_offset; /* Offset of this member in bits (for sou). */
136 int dmd_value; /* Value of this member (for enum). */
137 struct ctf_dmdef * dmd_next; /* A list node. */
138 } ctf_dmdef_t;
139
140 #define ctf_dmd_list_next(elem) ((ctf_dmdef_t *)((elem)->dmd_next))
141
142 /* Function Argument. */
143
144 typedef struct GTY (()) ctf_func_arg
145 {
146 ctf_id_t farg_type; /* Type identifier of the argument. */
147 const char * farg_name; /* Name of the argument. */
148 uint32_t farg_name_offset; /* Offset of the name in str table. */
149 struct ctf_func_arg * farg_next;/* A list node. */
150 } ctf_func_arg_t;
151
152 #define ctf_farg_list_next(elem) ((ctf_func_arg_t *)((elem)->farg_next))
153
154 /* Type definition for CTF generation. */
155
156 struct GTY ((for_user)) ctf_dtdef
157 {
158 dw_die_ref dtd_key; /* Type key for hashing. */
159 const char * dtd_name; /* Name associated with definition (if any). */
160 ctf_id_t dtd_type; /* Type identifier for this definition. */
161 ctf_itype_t dtd_data; /* Type node. */
162 bool from_global_func; /* Whether this type was added from a global
163 function. */
164 union GTY ((desc ("ctf_dtu_d_union_selector (&%1)")))
165 {
166 /* struct, union, or enum. */
167 ctf_dmdef_t * GTY ((tag ("CTF_DTU_D_MEMBERS"))) dtu_members;
168 /* array. */
169 ctf_arinfo_t GTY ((tag ("CTF_DTU_D_ARRAY"))) dtu_arr;
170 /* integer or float. */
171 ctf_encoding_t GTY ((tag ("CTF_DTU_D_ENCODING"))) dtu_enc;
172 /* function. */
173 ctf_func_arg_t * GTY ((tag ("CTF_DTU_D_ARGUMENTS"))) dtu_argv;
174 /* slice. */
175 ctf_sliceinfo_t GTY ((tag ("CTF_DTU_D_SLICE"))) dtu_slice;
176 } dtd_u;
177 };
178
179 typedef struct ctf_dtdef ctf_dtdef_t;
180
181 /* Variable definition for CTF generation. */
182
183 struct GTY ((for_user)) ctf_dvdef
184 {
185 dw_die_ref dvd_key; /* DWARF DIE corresponding to the variable. */
186 const char * dvd_name; /* Name associated with variable. */
187 uint32_t dvd_name_offset; /* Offset of the name in str table. */
188 unsigned int dvd_visibility; /* External visibility. 0=static,1=global. */
189 ctf_id_t dvd_type; /* Type of variable. */
190 };
191
192 typedef struct ctf_dvdef ctf_dvdef_t;
193
194 typedef ctf_dvdef_t * ctf_dvdef_ref;
195 typedef ctf_dtdef_t * ctf_dtdef_ref;
196
197 /* Location information for CTF Types and CTF Variables. */
198
199 typedef struct GTY (()) ctf_srcloc
200 {
201 const char * ctsloc_file;
202 unsigned int ctsloc_line;
203 unsigned int ctsloc_col;
204 } ctf_srcloc_t;
205
206 typedef ctf_srcloc_t * ctf_srcloc_ref;
207
208 /* Helper enum and api for the GTY machinery to work on union dtu_d. */
209
210 enum ctf_dtu_d_union_enum {
211 CTF_DTU_D_MEMBERS,
212 CTF_DTU_D_ARRAY,
213 CTF_DTU_D_ENCODING,
214 CTF_DTU_D_ARGUMENTS,
215 CTF_DTU_D_SLICE
216 };
217
218 enum ctf_dtu_d_union_enum
219 ctf_dtu_d_union_selector (ctf_dtdef_ref);
220
221 struct ctfc_dtd_hasher : ggc_ptr_hash <ctf_dtdef_t>
222 {
223 typedef ctf_dtdef_ref compare_type;
224
225 static hashval_t hash (ctf_dtdef_ref);
226 static bool equal (ctf_dtdef_ref, ctf_dtdef_ref);
227 };
228
229 inline hashval_t
hash(ctf_dtdef_ref dtd)230 ctfc_dtd_hasher::hash (ctf_dtdef_ref dtd)
231 {
232 return htab_hash_pointer (dtd->dtd_key);
233 }
234
235 inline bool
equal(ctf_dtdef_ref dtd,ctf_dtdef_ref dtd2)236 ctfc_dtd_hasher::equal (ctf_dtdef_ref dtd, ctf_dtdef_ref dtd2)
237 {
238 return (dtd->dtd_key == dtd2->dtd_key);
239 }
240
241 struct ctfc_dvd_hasher : ggc_ptr_hash <ctf_dvdef_t>
242 {
243 typedef ctf_dvdef_ref compare_type;
244
245 static hashval_t hash (ctf_dvdef_ref);
246 static bool equal (ctf_dvdef_ref, ctf_dvdef_ref);
247 };
248
249 inline hashval_t
hash(ctf_dvdef_ref dvd)250 ctfc_dvd_hasher::hash (ctf_dvdef_ref dvd)
251 {
252 return htab_hash_pointer (dvd->dvd_key);
253 }
254
255 inline bool
equal(ctf_dvdef_ref dvd,ctf_dvdef_ref dvd2)256 ctfc_dvd_hasher::equal (ctf_dvdef_ref dvd, ctf_dvdef_ref dvd2)
257 {
258 return (dvd->dvd_key == dvd2->dvd_key);
259 }
260
261 /* CTF container structure.
262 It is the context passed around when generating ctf debug info. There is
263 one container per translation unit. */
264
265 typedef struct GTY (()) ctf_container
266 {
267 /* CTF Preamble. */
268 unsigned short ctfc_magic;
269 unsigned char ctfc_version;
270 unsigned char ctfc_flags;
271 uint32_t ctfc_cuname_offset;
272
273 /* CTF types. */
274 hash_table <ctfc_dtd_hasher> * GTY (()) ctfc_types;
275 /* CTF variables. */
276 hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_vars;
277 /* CTF variables to be ignored. */
278 hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_ignore_vars;
279
280 /* CTF string table. */
281 ctf_strtable_t ctfc_strtable;
282 /* Auxilliary string table. At this time, used for keeping func arg names
283 for BTF. */
284 ctf_strtable_t ctfc_aux_strtable;
285
286 uint64_t ctfc_num_types;
287 uint64_t ctfc_num_stypes;
288 uint64_t ctfc_num_global_funcs;
289 uint64_t ctfc_num_global_objts;
290
291 /* Number of vlen bytes - the variable length portion after ctf_type_t and
292 ctf_stype_t in the CTF section. This is used to calculate the offsets in
293 the CTF header. */
294 uint64_t ctfc_num_vlen_bytes;
295
296 /* Next CTF type id to assign. */
297 ctf_id_t ctfc_nextid;
298
299 /* Specify an explicit length of 0 so that the GC marking routines steer
300 clear of marking the CTF vars and CTF types twice. These lists below do
301 not own the pointed to objects, they simply hold references to them. */
302
303 /* List of pre-processed CTF Variables. CTF requires that the variables
304 appear in the sorted order of their names. */
305 ctf_dvdef_t ** GTY ((length ("0"))) ctfc_vars_list;
306 /* Count of pre-processed CTF Variables in the list. */
307 uint64_t ctfc_vars_list_count;
308 /* List of pre-processed CTF types. CTF requires that a shared type must
309 appear before the type that uses it. For the compiler, this means types
310 are emitted in sorted order of their type IDs. */
311 ctf_dtdef_t ** GTY ((length ("0"))) ctfc_types_list;
312 /* List of CTF function types for global functions. The order of global
313 function entries in the CTF funcinfo section is undefined by the
314 compiler. */
315 ctf_dtdef_t ** GTY ((length ("0"))) ctfc_gfuncs_list;
316 /* List of CTF variables at global scope. The order of global object entries
317 in the CTF objinfo section is undefined by the compiler. */
318 ctf_dvdef_t ** GTY ((length ("0"))) ctfc_gobjts_list;
319
320 /* Following members are for debugging only. They do not add functional
321 value to the task of CTF creation. These can be cleaned up once CTF
322 generation stabilizes. */
323
324 /* Keep a count of the number of bytes dumped in asm for debugging
325 purposes. */
326 uint64_t ctfc_numbytes_asm;
327 /* Total length of all strings in CTF. */
328 size_t ctfc_strlen;
329 /* Total length of all strings in aux string table. */
330 size_t ctfc_aux_strlen;
331
332 } ctf_container_t;
333
334 /* Markers for which string table from the CTF container to use. */
335
336 #define CTF_STRTAB 0 /* CTF string table. */
337 #define CTF_AUX_STRTAB 1 /* CTF auxilliary string table. */
338
339 typedef ctf_container_t * ctf_container_ref;
340
341 extern GTY (()) ctf_container_ref tu_ctfc;
342
343 extern void ctfc_delete_container (ctf_container_ref);
344
345 /* If the next ctf type id is still set to the init value, no ctf records to
346 report. */
347 extern bool ctfc_is_empty_container (ctf_container_ref);
348
349 /* Get the total number of CTF types in the container. */
350
351 extern unsigned int ctfc_get_num_ctf_types (ctf_container_ref);
352
353 /* Get the total number of CTF variables in the container. */
354
355 extern unsigned int ctfc_get_num_ctf_vars (ctf_container_ref);
356
357 /* Get reference to the CTF string table or the CTF auxilliary
358 string table. */
359
360 extern ctf_strtable_t * ctfc_get_strtab (ctf_container_ref, int);
361
362 /* Get the length of the specified string table in the CTF container. */
363
364 extern size_t ctfc_get_strtab_len (ctf_container_ref, int);
365
366 /* Get the number of bytes to represent the variable length portion of all CTF
367 types in the CTF container. */
368
369 extern size_t ctfc_get_num_vlen_bytes (ctf_container_ref);
370
371 /* The compiler demarcates whether types are visible at top-level scope or not.
372 The only example so far of a type not visible at top-level scope is slices.
373 CTF_ADD_NONROOT is used to indicate the latter. */
374 #define CTF_ADD_NONROOT 0 /* CTF type only visible in nested scope. */
375 #define CTF_ADD_ROOT 1 /* CTF type visible at top-level scope. */
376
377 /* These APIs allow to initialize and finalize the CTF machinery and
378 to add types to the CTF container associated to the current
379 translation unit. Used in dwarf2ctf.cc. */
380
381 extern void ctf_init (void);
382 extern void ctf_output (const char * filename);
383 extern void ctf_finalize (void);
384
385 extern void btf_output (const char * filename);
386 extern void btf_init_postprocess (void);
387 extern void btf_finalize (void);
388
389 extern ctf_container_ref ctf_get_tu_ctfc (void);
390
391 extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_id_t *);
392
393 extern void ctf_add_cuname (ctf_container_ref, const char *);
394
395 extern ctf_dtdef_ref ctf_dtd_lookup (const ctf_container_ref ctfc,
396 dw_die_ref die);
397 extern ctf_dvdef_ref ctf_dvd_lookup (const ctf_container_ref ctfc,
398 dw_die_ref die);
399 extern bool ctf_dvd_ignore_lookup (const ctf_container_ref ctfc,
400 dw_die_ref die);
401
402 extern const char * ctf_add_string (ctf_container_ref, const char *,
403 uint32_t *, int);
404
405 extern ctf_id_t ctf_add_reftype (ctf_container_ref, uint32_t, ctf_id_t,
406 uint32_t, dw_die_ref);
407 extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, const char *,
408 HOST_WIDE_INT, dw_die_ref);
409 extern ctf_id_t ctf_add_slice (ctf_container_ref, uint32_t, ctf_id_t,
410 uint32_t, uint32_t, dw_die_ref);
411 extern ctf_id_t ctf_add_float (ctf_container_ref, uint32_t, const char *,
412 const ctf_encoding_t *, dw_die_ref);
413 extern ctf_id_t ctf_add_integer (ctf_container_ref, uint32_t, const char *,
414 const ctf_encoding_t *, dw_die_ref);
415 extern ctf_id_t ctf_add_unknown (ctf_container_ref, uint32_t, const char *,
416 const ctf_encoding_t *, dw_die_ref);
417 extern ctf_id_t ctf_add_pointer (ctf_container_ref, uint32_t, ctf_id_t,
418 dw_die_ref);
419 extern ctf_id_t ctf_add_array (ctf_container_ref, uint32_t,
420 const ctf_arinfo_t *, dw_die_ref);
421 extern ctf_id_t ctf_add_forward (ctf_container_ref, uint32_t, const char *,
422 uint32_t, dw_die_ref);
423 extern ctf_id_t ctf_add_typedef (ctf_container_ref, uint32_t, const char *,
424 ctf_id_t, dw_die_ref);
425 extern ctf_id_t ctf_add_function (ctf_container_ref, uint32_t, const char *,
426 const ctf_funcinfo_t *, dw_die_ref, bool);
427 extern ctf_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *,
428 uint32_t, size_t, dw_die_ref);
429
430 extern int ctf_add_enumerator (ctf_container_ref, ctf_id_t, const char *,
431 HOST_WIDE_INT, dw_die_ref);
432 extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *,
433 ctf_id_t, uint64_t);
434 extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref,
435 const char *, ctf_id_t);
436 extern int ctf_add_variable (ctf_container_ref, const char *, ctf_id_t,
437 dw_die_ref, unsigned int, dw_die_ref);
438
439 extern ctf_id_t ctf_lookup_tree_type (ctf_container_ref, const tree);
440 extern ctf_id_t get_btf_id (ctf_id_t);
441
442 /* CTF section does not emit location information; at this time, location
443 information is needed for BTF CO-RE use-cases. */
444
445 extern int ctfc_get_dtd_srcloc (ctf_dtdef_ref, ctf_srcloc_ref);
446 extern int ctfc_get_dvd_srcloc (ctf_dvdef_ref, ctf_srcloc_ref);
447
448 #endif /* GCC_CTFC_H */
449