]>
Commit | Line | Data |
---|---|---|
1 | /* Output CTF format from GCC. | |
2 | Copyright (C) 2019-2024 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 "memmodel.h" | |
25 | #include "tm_p.h" | |
26 | #include "output.h" | |
27 | #include "dwarf2asm.h" | |
28 | #include "debug.h" | |
29 | #include "ctfc.h" | |
30 | #include "diagnostic-core.h" | |
31 | ||
32 | static int ctf_label_num; | |
33 | ||
34 | /* Pointers to various CTF sections. */ | |
35 | ||
36 | static GTY (()) section * ctf_info_section; | |
37 | ||
38 | /* Section names used to hold CTF debugging information. */ | |
39 | ||
40 | /* CTF debug info section. */ | |
41 | ||
42 | #ifndef CTF_INFO_SECTION_NAME | |
43 | #define CTF_INFO_SECTION_NAME ".ctf" | |
44 | #endif | |
45 | ||
46 | /* Section flags for the CTF debug info section. */ | |
47 | ||
48 | #define CTF_INFO_SECTION_FLAGS (SECTION_DEBUG) | |
49 | ||
50 | /* Maximum size (in bytes) of an artificially generated CTF label. */ | |
51 | ||
52 | #define MAX_CTF_LABEL_BYTES 40 | |
53 | ||
54 | static char ctf_info_section_label[MAX_CTF_LABEL_BYTES]; | |
55 | ||
56 | #ifndef CTF_INFO_SECTION_LABEL | |
57 | #define CTF_INFO_SECTION_LABEL "Lctf" | |
58 | #endif | |
59 | ||
60 | /* CTF preprocess callback arguments. */ | |
61 | ||
62 | typedef struct ctf_dtd_preprocess_arg | |
63 | { | |
64 | uint64_t dtd_global_func_idx; | |
65 | ctf_container_ref dtd_arg_ctfc; | |
66 | } ctf_dtd_preprocess_arg_t; | |
67 | ||
68 | typedef struct ctf_dvd_preprocess_arg | |
69 | { | |
70 | uint64_t dvd_global_obj_idx; | |
71 | ctf_container_ref dvd_arg_ctfc; | |
72 | } ctf_dvd_preprocess_arg_t; | |
73 | ||
74 | /* Compare two CTF variable definition entries. Currently used for sorting | |
75 | by name. */ | |
76 | ||
77 | static int | |
78 | ctf_varent_compare (const void * entry1, const void * entry2) | |
79 | { | |
80 | int result; | |
81 | const ctf_dvdef_t * e1 = *(const ctf_dvdef_t * const*) entry1; | |
82 | const ctf_dvdef_t * e2 = *(const ctf_dvdef_t * const*) entry2; | |
83 | ||
84 | result = strcmp (e1->dvd_name, e2->dvd_name); | |
85 | ||
86 | return result; | |
87 | } | |
88 | ||
89 | /* A CTF type record may be followed by variable-length of bytes to encode the | |
90 | CTF type completely. This routine calculates the number of bytes, in the | |
91 | final binary CTF format, which are used to encode information about the type | |
92 | completely. | |
93 | ||
94 | This function must always be in sync with the CTF header. */ | |
95 | ||
96 | static uint64_t | |
97 | ctf_calc_num_vbytes (ctf_dtdef_ref ctftype) | |
98 | { | |
99 | uint32_t size; | |
100 | uint64_t vlen_bytes = 0; | |
101 | ||
102 | uint32_t kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info); | |
103 | uint32_t vlen = CTF_V2_INFO_VLEN (ctftype->dtd_data.ctti_info); | |
104 | ||
105 | ctf_dmdef_t * dmd; | |
106 | ctf_func_arg_t * farg; | |
107 | uint32_t size_per_member = 0; | |
108 | unsigned int num_members = 0; | |
109 | unsigned int num_fargs = 0; | |
110 | ||
111 | switch (kind) | |
112 | { | |
113 | case CTF_K_FORWARD: | |
114 | case CTF_K_UNKNOWN: | |
115 | case CTF_K_POINTER: | |
116 | case CTF_K_TYPEDEF: | |
117 | case CTF_K_VOLATILE: | |
118 | case CTF_K_CONST: | |
119 | case CTF_K_RESTRICT: | |
120 | /* These types have no vlen data. */ | |
121 | break; | |
122 | ||
123 | case CTF_K_INTEGER: | |
124 | case CTF_K_FLOAT: | |
125 | /* 4 bytes to represent encoding CTF_INT_DATA, CTF_FP_DATA. */ | |
126 | vlen_bytes += sizeof (uint32_t); | |
127 | break; | |
128 | case CTF_K_FUNCTION: | |
129 | /* Sanity check - number of function args must be the same as | |
130 | vlen. */ | |
131 | for (farg = ctftype->dtd_u.dtu_argv; | |
132 | farg != NULL; farg = (ctf_func_arg_t *) ctf_farg_list_next (farg)) | |
133 | num_fargs++; | |
134 | gcc_assert (vlen == num_fargs); | |
135 | ||
136 | /* FIXME - CTF_PADDING_FOR_ALIGNMENT. */ | |
137 | vlen_bytes += (vlen + (vlen & 1)) * sizeof (uint32_t); | |
138 | break; | |
139 | case CTF_K_ARRAY: | |
140 | /* This has a single ctf_array_t. */ | |
141 | vlen_bytes += sizeof (ctf_array_t); | |
142 | break; | |
143 | case CTF_K_SLICE: | |
144 | vlen_bytes += sizeof (ctf_slice_t); | |
145 | break; | |
146 | case CTF_K_STRUCT: | |
147 | case CTF_K_UNION: | |
148 | /* Count the number and type of members. */ | |
149 | size = ctftype->dtd_data.ctti_size; | |
150 | size_per_member = size >= CTF_LSTRUCT_THRESH | |
151 | ? sizeof (ctf_lmember_t) : sizeof (ctf_member_t); | |
152 | ||
153 | /* Sanity check - number of members of struct must be the same as | |
154 | vlen. */ | |
155 | for (dmd = ctftype->dtd_u.dtu_members; | |
156 | dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd)) | |
157 | num_members++; | |
158 | gcc_assert (vlen == num_members); | |
159 | ||
160 | vlen_bytes += (num_members * size_per_member); | |
161 | break; | |
162 | case CTF_K_ENUM: | |
163 | vlen_bytes += vlen * sizeof (ctf_enum_t); | |
164 | break; | |
165 | default : | |
166 | break; | |
167 | } | |
168 | return vlen_bytes; | |
169 | } | |
170 | ||
171 | /* Add a CTF variable to the end of the list. */ | |
172 | ||
173 | static void | |
174 | ctf_list_add_ctf_vars (ctf_container_ref ctfc, ctf_dvdef_ref var) | |
175 | { | |
176 | ctfc->ctfc_vars_list[ctfc->ctfc_vars_list_count++] = var; | |
177 | } | |
178 | ||
179 | /* Initialize the various sections and labels for CTF output. */ | |
180 | ||
181 | void | |
182 | init_ctf_sections (void) | |
183 | { | |
184 | /* Note : Even in case of LTO, the compiler continues to generate a single | |
185 | CTF section for each compilation unit "early". Unlike other debug | |
186 | sections, CTF sections are non-LTO sections, and do not take the | |
187 | .gnu.debuglto_ prefix. The linker will de-duplicate the types in the CTF | |
188 | sections, in case of LTO or otherwise. */ | |
189 | ctf_info_section = get_section (CTF_INFO_SECTION_NAME, CTF_INFO_SECTION_FLAGS, | |
190 | NULL); | |
191 | ||
192 | ASM_GENERATE_INTERNAL_LABEL (ctf_info_section_label, | |
193 | CTF_INFO_SECTION_LABEL, ctf_label_num++); | |
194 | } | |
195 | ||
196 | /* Routines for CTF pre-processing. */ | |
197 | ||
198 | static void | |
199 | ctf_preprocess_var (ctf_container_ref ctfc, ctf_dvdef_ref var) | |
200 | { | |
201 | /* Add it to the list of types. This array of types will be sorted before | |
202 | assembling into output. */ | |
203 | ctf_list_add_ctf_vars (ctfc, var); | |
204 | } | |
205 | ||
206 | /* CTF preprocess callback routine for CTF variables. */ | |
207 | ||
208 | int | |
209 | ctf_dvd_preprocess_cb (ctf_dvdef_ref * slot, void * arg) | |
210 | { | |
211 | ctf_dvd_preprocess_arg_t * dvd_arg = (ctf_dvd_preprocess_arg_t *)arg; | |
212 | ctf_dvdef_ref var = (ctf_dvdef_ref) *slot; | |
213 | ctf_container_ref arg_ctfc = dvd_arg->dvd_arg_ctfc; | |
214 | ||
215 | /* If the CTF variable corresponds to an extern variable declaration with | |
216 | a defining declaration later on, skip it. Only CTF variable | |
217 | corresponding to the defining declaration for the extern variable is | |
218 | desirable. */ | |
219 | if (ctf_dvd_ignore_lookup (arg_ctfc, var->dvd_key)) | |
220 | return 1; | |
221 | ||
222 | ctf_preprocess_var (arg_ctfc, var); | |
223 | ||
224 | /* Keep track of global objts. */ | |
225 | arg_ctfc->ctfc_gobjts_list[dvd_arg->dvd_global_obj_idx] = var; | |
226 | dvd_arg->dvd_global_obj_idx++; | |
227 | ||
228 | return 1; | |
229 | } | |
230 | ||
231 | /* CTF preprocess callback routine for CTF types. */ | |
232 | ||
233 | int | |
234 | ctf_dtd_preprocess_cb (ctf_dtdef_ref * slot, void * arg) | |
235 | { | |
236 | uint32_t kind; | |
237 | ||
238 | ctf_dtdef_ref ctftype = (ctf_dtdef_ref) *slot; | |
239 | ctf_dtd_preprocess_arg_t * dtd_arg = (ctf_dtd_preprocess_arg_t *)arg; | |
240 | ctf_container_ref arg_ctfc = dtd_arg->dtd_arg_ctfc; | |
241 | ||
242 | size_t index = ctftype->dtd_type; | |
243 | gcc_assert (index <= arg_ctfc->ctfc_types->elements ()); | |
244 | ||
245 | /* CTF types need to be output in the order of their type IDs. In other | |
246 | words, if type A is used to define type B, type ID of type A must | |
247 | appear before type ID of type B. */ | |
248 | arg_ctfc->ctfc_types_list[index] = ctftype; | |
249 | ||
250 | /* Keep track of the CTF type if it's a function type and the type | |
251 | was generated from a function object. */ | |
252 | kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info); | |
253 | if (kind == CTF_K_FUNCTION && ctftype->from_global_func) | |
254 | { | |
255 | arg_ctfc->ctfc_gfuncs_list[dtd_arg->dtd_global_func_idx] = ctftype; | |
256 | dtd_arg->dtd_global_func_idx++; | |
257 | } | |
258 | ||
259 | /* Calculate the vlen bytes. */ | |
260 | arg_ctfc->ctfc_num_vlen_bytes += ctf_calc_num_vbytes (ctftype); | |
261 | ||
262 | return 1; | |
263 | } | |
264 | ||
265 | /* CTF preprocessing. | |
266 | After the CTF types for the compilation unit have been generated fully, the | |
267 | compiler writes out the asm for the CTF types. | |
268 | ||
269 | CTF writeout in the compiler requires two passes over the CTF types. In the | |
270 | first pass, the CTF preprocess pass: | |
271 | 1. CTF types are sorted in the order of their type IDs. | |
272 | 2. The variable number of bytes after each CTF type record are calculated. | |
273 | This is used to calculate the offsets in the ctf_header_t. | |
274 | 3. If the CTF type is of CTF_K_FUNCTION, the number of bytes in the | |
275 | funcinfo sub-section are calculated. This is used to calculate the | |
276 | offsets in the ctf_header_t. | |
277 | 4. Keep the list of CTF variables in ASCIIbetical order of their names. | |
278 | ||
279 | In the second pass, the CTF writeout pass, asm tags are written out using | |
280 | the compiler's afore-generated internal pre-processed CTF types. */ | |
281 | ||
282 | static void | |
283 | ctf_preprocess (ctf_container_ref ctfc) | |
284 | { | |
285 | size_t num_ctf_types = ctfc->ctfc_types->elements (); | |
286 | size_t num_ctf_vars = ctfc_get_num_ctf_vars (ctfc); | |
287 | ||
288 | /* Initialize an array to keep track of the CTF variables at global | |
289 | scope. At this time, size it conservatively. */ | |
290 | size_t num_global_objts = num_ctf_vars; | |
291 | if (num_global_objts) | |
292 | { | |
293 | ctfc->ctfc_gobjts_list = ggc_vec_alloc<ctf_dvdef_t*>(num_global_objts); | |
294 | } | |
295 | ||
296 | if (num_ctf_vars) | |
297 | { | |
298 | ctf_dvd_preprocess_arg_t dvd_arg; | |
299 | dvd_arg.dvd_global_obj_idx = 0; | |
300 | dvd_arg.dvd_arg_ctfc = ctfc; | |
301 | ||
302 | /* Allocate CTF var list. */ | |
303 | ctfc->ctfc_vars_list = ggc_vec_alloc<ctf_dvdef_ref>(num_ctf_vars); | |
304 | /* Variables appear in the sort ASCIIbetical order of their names. This | |
305 | permits binary searching in the CTF reader. Add the variables to a | |
306 | list for sorting. */ | |
307 | ctfc->ctfc_vars->traverse<void *, ctf_dvd_preprocess_cb> (&dvd_arg); | |
308 | /* Sort the list. */ | |
309 | qsort (ctfc->ctfc_vars_list, ctfc->ctfc_vars_list_count, | |
310 | sizeof (ctf_dvdef_ref), ctf_varent_compare); | |
311 | /* Update the actual number of the generated CTF variables at global | |
312 | scope. */ | |
313 | ctfc->ctfc_num_global_objts = dvd_arg.dvd_global_obj_idx; | |
314 | } | |
315 | ||
316 | /* Initialize an array to keep track of the CTF functions types for global | |
317 | functions in the CTF data section. */ | |
318 | size_t num_global_funcs = ctfc->ctfc_num_global_funcs; | |
319 | if (num_global_funcs) | |
320 | { | |
321 | ctfc->ctfc_gfuncs_list = ggc_vec_alloc<ctf_dtdef_t*>(num_global_funcs); | |
322 | gcc_assert (num_ctf_types); | |
323 | } | |
324 | ||
325 | if (num_ctf_types) | |
326 | { | |
327 | ctf_dtd_preprocess_arg_t dtd_arg; | |
328 | dtd_arg.dtd_global_func_idx = 0; | |
329 | dtd_arg.dtd_arg_ctfc = ctfc; | |
330 | /* Allocate the CTF types list. Add 1 because type ID 0 is never a valid | |
331 | CTF type ID. No CTF type record should appear at that offset, this | |
332 | eases debugging and readability. */ | |
333 | ctfc->ctfc_types_list = ggc_vec_alloc<ctf_dtdef_ref>(num_ctf_types + 1); | |
334 | /* Pre-process CTF types. */ | |
335 | ctfc->ctfc_types->traverse<void *, ctf_dtd_preprocess_cb> (&dtd_arg); | |
336 | ||
337 | gcc_assert (dtd_arg.dtd_global_func_idx == num_global_funcs); | |
338 | } | |
339 | } | |
340 | ||
341 | /* CTF asm helper routines. */ | |
342 | ||
343 | /* Asm'out the CTF preamble. */ | |
344 | ||
345 | static void | |
346 | ctf_asm_preamble (ctf_container_ref ctfc) | |
347 | { | |
348 | dw2_asm_output_data (2, ctfc->ctfc_magic, | |
349 | "CTF preamble magic number"); | |
350 | dw2_asm_output_data (1, ctfc->ctfc_version, "CTF preamble version"); | |
351 | dw2_asm_output_data (1, ctfc->ctfc_flags, "CTF preamble flags"); | |
352 | } | |
353 | ||
354 | /* Asm'out a CTF type which is represented by ctf_stype_t. */ | |
355 | ||
356 | static void | |
357 | ctf_asm_stype (ctf_dtdef_ref type) | |
358 | { | |
359 | dw2_asm_output_data (4, type->dtd_data.ctti_name, "ctt_name"); | |
360 | dw2_asm_output_data (4, type->dtd_data.ctti_info, "ctt_info"); | |
361 | /* union. */ | |
362 | dw2_asm_output_data (4, type->dtd_data.ctti_size, "ctt_size or ctt_type"); | |
363 | } | |
364 | ||
365 | /* Asm'out a CTF type which is represented by ctf_type_t. */ | |
366 | ||
367 | static void | |
368 | ctf_asm_type (ctf_dtdef_ref type) | |
369 | { | |
370 | dw2_asm_output_data (4, type->dtd_data.ctti_name, "ctt_name"); | |
371 | dw2_asm_output_data (4, type->dtd_data.ctti_info, "ctt_info"); | |
372 | /* union. */ | |
373 | dw2_asm_output_data (4, type->dtd_data.ctti_size, "ctt_size"); | |
374 | dw2_asm_output_data (4, type->dtd_data.ctti_lsizehi, "ctt_lsizehi"); | |
375 | dw2_asm_output_data (4, type->dtd_data.ctti_lsizelo, "ctt_lsizelo"); | |
376 | } | |
377 | ||
378 | /* Asm'out a CTF type of kind CTF_K_SLICE. */ | |
379 | ||
380 | static void | |
381 | ctf_asm_slice (ctf_dtdef_ref type) | |
382 | { | |
383 | dw2_asm_output_data (4, type->dtd_u.dtu_slice.cts_type, "cts_type"); | |
384 | dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_offset, "cts_offset"); | |
385 | dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_bits, "cts_bits"); | |
386 | } | |
387 | ||
388 | /* Asm'out a CTF type of kind CTF_K_ARRAY. */ | |
389 | ||
390 | static void | |
391 | ctf_asm_array (ctf_dtdef_ref dtd) | |
392 | { | |
393 | dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_contents, "cta_contents"); | |
394 | dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_index, "cta_index"); | |
395 | dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "cta_nelems"); | |
396 | } | |
397 | ||
398 | /* Asm'out a CTF variable. */ | |
399 | ||
400 | static void | |
401 | ctf_asm_varent (ctf_dvdef_ref var) | |
402 | { | |
403 | /* Output the reference to the name in the string table. */ | |
404 | dw2_asm_output_data (4, var->dvd_name_offset, "ctv_name"); | |
405 | /* Output the type index. */ | |
406 | dw2_asm_output_data (4, var->dvd_type, "ctv_typeidx"); | |
407 | } | |
408 | ||
409 | /* Asm'out a member of CTF struct or union, represented by ctf_lmember_t. */ | |
410 | ||
411 | static void | |
412 | ctf_asm_sou_lmember (ctf_dmdef_t * dmd) | |
413 | { | |
414 | dw2_asm_output_data (4, dmd->dmd_name_offset, "ctlm_name"); | |
415 | dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset), | |
416 | "ctlm_offsethi"); | |
417 | dw2_asm_output_data (4, dmd->dmd_type, "ctlm_type"); | |
418 | dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset), | |
419 | "ctlm_offsetlo"); | |
420 | } | |
421 | ||
422 | /* Asm'out a member of a CTF sruct or union, represented by ctf_member_t. */ | |
423 | ||
424 | static void | |
425 | ctf_asm_sou_member (ctf_dmdef_t * dmd) | |
426 | { | |
427 | dw2_asm_output_data (4, dmd->dmd_name_offset, "ctm_name"); | |
428 | dw2_asm_output_data (4, dmd->dmd_offset, "ctm_offset"); | |
429 | dw2_asm_output_data (4, dmd->dmd_type, "ctm_type"); | |
430 | } | |
431 | ||
432 | /* Asm'out an enumerator constant. */ | |
433 | ||
434 | static void | |
435 | ctf_asm_enum_const (ctf_dmdef_t * dmd) | |
436 | { | |
437 | dw2_asm_output_data (4, dmd->dmd_name_offset, "cte_name"); | |
438 | dw2_asm_output_data (4, dmd->dmd_value, "cte_value"); | |
439 | } | |
440 | ||
441 | /* Asm'out a function argument. */ | |
442 | ||
443 | static void | |
444 | ctf_asm_func_arg (ctf_func_arg_t * farg) | |
445 | { | |
446 | dw2_asm_output_data (4, farg->farg_type, "dtu_argv"); | |
447 | } | |
448 | ||
449 | /* CTF writeout to asm file. */ | |
450 | ||
451 | static void | |
452 | output_ctf_header (ctf_container_ref ctfc) | |
453 | { | |
454 | switch_to_section (ctf_info_section); | |
455 | ASM_OUTPUT_LABEL (asm_out_file, ctf_info_section_label); | |
456 | ||
457 | ctf_asm_preamble (ctfc); | |
458 | ||
459 | /* For a single compilation unit, the parent container's name and label are | |
460 | NULL. */ | |
461 | dw2_asm_output_data (4, 0, "cth_parlabel"); | |
462 | dw2_asm_output_data (4, 0, "cth_parname"); | |
463 | dw2_asm_output_data (4, ctfc->ctfc_cuname_offset, "cth_cuname"); | |
464 | ||
465 | int typeslen = 0; | |
466 | /* Initialize the offsets. The offsets are from after the CTF header. */ | |
467 | uint32_t lbloff = 0; | |
468 | uint32_t objtoff = 0; | |
469 | uint32_t funcoff = 0; | |
470 | uint32_t objtidxoff = 0; | |
471 | uint32_t funcidxoff = 0; | |
472 | uint32_t varoff = 0; | |
473 | uint32_t typeoff = 0; | |
474 | uint32_t stroff = 0; | |
475 | ||
476 | if (!ctfc_is_empty_container (ctfc)) | |
477 | { | |
478 | gcc_assert (ctfc_get_num_ctf_types (ctfc) | |
479 | == (ctfc->ctfc_num_types + ctfc->ctfc_num_stypes)); | |
480 | ||
481 | funcoff = objtoff + ctfc->ctfc_num_global_objts * sizeof (uint32_t); | |
482 | /* Object index appears after function info. */ | |
483 | objtidxoff = funcoff + ctfc->ctfc_num_global_funcs * sizeof (uint32_t); | |
484 | /* Funxtion index goes next. */ | |
485 | funcidxoff = objtidxoff + ctfc->ctfc_num_global_objts * sizeof (uint32_t); | |
486 | /* Vars appear after function index. */ | |
487 | varoff = funcidxoff + ctfc->ctfc_num_global_funcs * sizeof (uint32_t); | |
488 | /* CTF types appear after vars. */ | |
489 | typeoff = varoff + (ctfc->ctfc_vars_list_count) * sizeof (ctf_varent_t); | |
490 | /* The total number of bytes for CTF types is the sum of the number of | |
491 | times struct ctf_type_t, struct ctf_stype_t are written, plus the | |
492 | amount of variable length data after each one of these. */ | |
493 | typeslen = ctfc->ctfc_num_types * sizeof (ctf_type_t) | |
494 | + ctfc->ctfc_num_stypes * (sizeof (ctf_stype_t)) | |
495 | + ctfc_get_num_vlen_bytes (ctfc); | |
496 | ||
497 | /* Strings appear after types. */ | |
498 | stroff = typeoff + typeslen; | |
499 | } | |
500 | ||
501 | /* Offset of label section. */ | |
502 | dw2_asm_output_data (4, lbloff, "cth_lbloff"); | |
503 | /* Offset of object section. */ | |
504 | dw2_asm_output_data (4, objtoff, "cth_objtoff"); | |
505 | /* Offset of function section. */ | |
506 | dw2_asm_output_data (4, funcoff, "cth_funcoff"); | |
507 | /* Offset of object index section. */ | |
508 | dw2_asm_output_data (4, objtidxoff, "cth_objtidxoff"); | |
509 | /* Offset of function index section. */ | |
510 | dw2_asm_output_data (4, funcidxoff, "cth_funcidxoff"); | |
511 | ||
512 | /* Offset of variable section. */ | |
513 | dw2_asm_output_data (4, varoff, "cth_varoff"); | |
514 | /* Offset of type section. */ | |
515 | dw2_asm_output_data (4, typeoff, "cth_typeoff"); | |
516 | /* Offset of string section. */ | |
517 | dw2_asm_output_data (4, stroff, "cth_stroff"); | |
518 | /* Length of string section in bytes. */ | |
519 | dw2_asm_output_data (4, ctfc->ctfc_strlen, "cth_strlen"); | |
520 | } | |
521 | ||
522 | /* Output the CTF object info section. */ | |
523 | ||
524 | static void | |
525 | output_ctf_obj_info (ctf_container_ref ctfc) | |
526 | { | |
527 | uint64_t i; | |
528 | ctf_dvdef_ref var; | |
529 | ||
530 | if (!ctfc->ctfc_num_global_objts) return; | |
531 | ||
532 | /* Compiler spits out the objts (at global scope) in the CTF obj info section. | |
533 | In no specific order. In an object file, the CTF object index section is | |
534 | used to associate the objts to their corresponding names. */ | |
535 | for (i = 0; i < ctfc->ctfc_num_global_objts; i++) | |
536 | { | |
537 | var = ctfc->ctfc_gobjts_list[i]; | |
538 | ||
539 | /* CTF type ID corresponding to the type of the variable. */ | |
540 | dw2_asm_output_data (4, var->dvd_type, "objtinfo_var_type"); | |
541 | } | |
542 | ||
543 | } | |
544 | ||
545 | /* Output the CTF function info section. */ | |
546 | ||
547 | static void | |
548 | output_ctf_func_info (ctf_container_ref ctfc) | |
549 | { | |
550 | uint64_t i; | |
551 | ctf_dtdef_ref ctftype; | |
552 | ||
553 | if (!ctfc->ctfc_num_global_funcs) return; | |
554 | ||
555 | /* The CTF funcinfo section is simply an array of CTF_K_FUNCTION type IDs in | |
556 | the type section. In an object file, the CTF function index section is | |
557 | used to associate functions to their corresponding names. */ | |
558 | for (i = 0; i < ctfc->ctfc_num_global_funcs; i++) | |
559 | { | |
560 | ctftype = ctfc->ctfc_gfuncs_list[i]; | |
561 | dw2_asm_output_data (4, ctftype->dtd_type, "funcinfo_func_type"); | |
562 | } | |
563 | } | |
564 | ||
565 | /* Output the CTF object index section. */ | |
566 | ||
567 | static void | |
568 | output_ctf_objtidx (ctf_container_ref ctfc) | |
569 | { | |
570 | uint64_t i; | |
571 | ctf_dvdef_ref var; | |
572 | ||
573 | if (!ctfc->ctfc_num_global_objts) return; | |
574 | ||
575 | for (i = 0; i < ctfc->ctfc_num_global_objts; i++) | |
576 | { | |
577 | var = ctfc->ctfc_gobjts_list[i]; | |
578 | /* Offset to the name in CTF string table. */ | |
579 | dw2_asm_output_data (4, var->dvd_name_offset, "objtinfo_name"); | |
580 | } | |
581 | } | |
582 | ||
583 | /* Output the CTF function index section. */ | |
584 | ||
585 | static void | |
586 | output_ctf_funcidx (ctf_container_ref ctfc) | |
587 | { | |
588 | uint64_t i; | |
589 | ctf_dtdef_ref ctftype; | |
590 | ||
591 | if (!ctfc->ctfc_num_global_funcs) return; | |
592 | ||
593 | for (i = 0; i < ctfc->ctfc_num_global_funcs; i++) | |
594 | { | |
595 | ctftype = ctfc->ctfc_gfuncs_list[i]; | |
596 | /* Offset to the name in CTF string table. */ | |
597 | dw2_asm_output_data (4, ctftype->dtd_data.ctti_name, "funcinfo_name"); | |
598 | } | |
599 | } | |
600 | ||
601 | /* Output the CTF variables. Variables appear in the sorted ASCIIbetical | |
602 | order of their names. This permits binary searching in the CTF reader. */ | |
603 | ||
604 | static void | |
605 | output_ctf_vars (ctf_container_ref ctfc) | |
606 | { | |
607 | size_t i; | |
608 | unsigned int num_ctf_vars = ctfc->ctfc_vars_list_count; | |
609 | if (num_ctf_vars) | |
610 | { | |
611 | /* Iterate over the list of sorted vars and output the asm. */ | |
612 | for (i = 0; i < num_ctf_vars; i++) | |
613 | { | |
614 | ctf_asm_varent (ctfc->ctfc_vars_list[i]); | |
615 | /* The type of variable must be a valid one. */ | |
616 | gcc_assert (ctfc->ctfc_vars_list[i]->dvd_type != CTF_NULL_TYPEID); | |
617 | } | |
618 | } | |
619 | } | |
620 | ||
621 | /* Output the CTF string records. */ | |
622 | ||
623 | static void | |
624 | output_ctf_strs (ctf_container_ref ctfc) | |
625 | { | |
626 | ctf_string_t * ctf_string = ctfc->ctfc_strtable.ctstab_head; | |
627 | ||
628 | while (ctf_string) | |
629 | { | |
630 | dw2_asm_output_nstring (ctf_string->cts_str, -1, "ctf_string"); | |
631 | ctf_string = ctf_string->cts_next; | |
632 | } | |
633 | } | |
634 | ||
635 | /* Output the members of the CTF struct or union. */ | |
636 | ||
637 | static void | |
638 | output_asm_ctf_sou_fields (ctf_container_ref ARG_UNUSED (ctfc), | |
639 | ctf_dtdef_ref dtd) | |
640 | { | |
641 | ctf_dmdef_t * dmd; | |
642 | ||
643 | /* Function pointer to dump struct/union members. */ | |
644 | void (*ctf_asm_sou_field_func) (ctf_dmdef_t *); | |
645 | ||
646 | uint32_t size = dtd->dtd_data.ctti_size; | |
647 | ||
648 | /* The variable length data struct/union CTF types is an array of | |
649 | ctf_member or ctf_lmember, depending on size of the member. */ | |
650 | if (size >= CTF_LSTRUCT_THRESH) | |
651 | ctf_asm_sou_field_func = ctf_asm_sou_lmember; | |
652 | else | |
653 | ctf_asm_sou_field_func = ctf_asm_sou_member; | |
654 | ||
655 | for (dmd = dtd->dtd_u.dtu_members; | |
656 | dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd)) | |
657 | { | |
658 | ctf_asm_sou_field_func (dmd); | |
659 | /* Sanity Check - Unrepresented types appear as explicit types. */ | |
660 | gcc_assert (dmd->dmd_type != CTF_NULL_TYPEID); | |
661 | } | |
662 | } | |
663 | ||
664 | /* Output the list of enumerator constants of the CTF enum type. */ | |
665 | ||
666 | static void | |
667 | output_asm_ctf_enum_list (ctf_container_ref ARG_UNUSED (ctfc), | |
668 | ctf_dtdef_ref dtd) | |
669 | { | |
670 | ctf_dmdef_t * dmd; | |
671 | ||
672 | for (dmd = dtd->dtd_u.dtu_members; | |
673 | dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd)) | |
674 | ctf_asm_enum_const (dmd); | |
675 | } | |
676 | ||
677 | /* Output the list of function arguments of the CTF function type. */ | |
678 | ||
679 | static void | |
680 | output_asm_func_args_list (ctf_container_ref ARG_UNUSED (ctfc), | |
681 | ctf_dtdef_ref dtd) | |
682 | { | |
683 | ctf_func_arg_t * farg; | |
684 | ||
685 | for (farg = dtd->dtd_u.dtu_argv; | |
686 | farg != NULL; farg = (ctf_func_arg_t *) ctf_farg_list_next (farg)) | |
687 | ctf_asm_func_arg (farg); | |
688 | } | |
689 | ||
690 | /* Output the variable length portion of the CTF type record. */ | |
691 | ||
692 | static void | |
693 | output_asm_ctf_vlen_bytes (ctf_container_ref ctfc, ctf_dtdef_ref ctftype) | |
694 | { | |
695 | uint32_t encoding; | |
696 | uint32_t kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info); | |
697 | uint32_t vlen = CTF_V2_INFO_VLEN (ctftype->dtd_data.ctti_info); | |
698 | ||
699 | switch (kind) | |
700 | { | |
701 | case CTF_K_INTEGER: | |
702 | case CTF_K_FLOAT: | |
703 | if (kind == CTF_K_INTEGER) | |
704 | { | |
705 | encoding = CTF_INT_DATA (ctftype->dtd_u.dtu_enc.cte_format, | |
706 | ctftype->dtd_u.dtu_enc.cte_offset, | |
707 | ctftype->dtd_u.dtu_enc.cte_bits); | |
708 | } | |
709 | else | |
710 | { | |
711 | encoding = CTF_FP_DATA (ctftype->dtd_u.dtu_enc.cte_format, | |
712 | ctftype->dtd_u.dtu_enc.cte_offset, | |
713 | ctftype->dtd_u.dtu_enc.cte_bits); | |
714 | } | |
715 | dw2_asm_output_data (4, encoding, "ctf_encoding_data"); | |
716 | break; | |
717 | case CTF_K_FUNCTION: | |
718 | { | |
719 | output_asm_func_args_list (ctfc, ctftype); | |
720 | /* FIXME - CTF_PADDING_FOR_ALIGNMENT. | |
721 | libctf expects this padding for alignment reasons. Expected to | |
722 | be redundant in CTF_VERSION_4. */ | |
723 | if (vlen & 1) | |
724 | dw2_asm_output_data (4, 0, "dtu_argv_padding"); | |
725 | ||
726 | break; | |
727 | } | |
728 | case CTF_K_ARRAY: | |
729 | ctf_asm_array (ctftype); | |
730 | break; | |
731 | case CTF_K_SLICE: | |
732 | { | |
733 | ctf_asm_slice (ctftype); | |
734 | /* Type of the slice must be a valid CTF type. */ | |
735 | gcc_assert (ctftype->dtd_u.dtu_slice.cts_type != CTF_NULL_TYPEID); | |
736 | break; | |
737 | } | |
738 | case CTF_K_STRUCT: | |
739 | case CTF_K_UNION: | |
740 | output_asm_ctf_sou_fields (ctfc, ctftype); | |
741 | break; | |
742 | case CTF_K_ENUM: | |
743 | output_asm_ctf_enum_list (ctfc, ctftype); | |
744 | break; | |
745 | ||
746 | default: | |
747 | /* CTF types of kind CTF_K_VOLATILE, CTF_K_CONST, CTF_K_RESTRICT, | |
748 | etc have no vlen data to write. */ | |
749 | break; | |
750 | } | |
751 | } | |
752 | ||
753 | /* Output a CTF Type. */ | |
754 | ||
755 | static void | |
756 | output_asm_ctf_type (ctf_container_ref ctfc, ctf_dtdef_ref type) | |
757 | { | |
758 | if (type->dtd_data.ctti_size <= CTF_MAX_SIZE) | |
759 | ctf_asm_stype (type); | |
760 | else | |
761 | ctf_asm_type (type); | |
762 | /* Now comes the variable-length portion for defining types completely. | |
763 | E.g., encoding follows CTF_INT_DATA, CTF_FP_DATA types, | |
764 | struct ctf_array_t follows CTF_K_ARRAY types, or a bunch of | |
765 | struct ctf_member / ctf_lmember ctf_enum sit in there for CTF_K_STRUCT or | |
766 | CTF_K_UNION. */ | |
767 | output_asm_ctf_vlen_bytes (ctfc, type); | |
768 | ||
769 | uint32_t kind = CTF_V2_INFO_KIND (type->dtd_data.ctti_info); | |
770 | /* The underlying type must be a valid CTF type. */ | |
771 | if (kind == CTF_K_POINTER || kind == CTF_K_TYPEDEF | |
772 | || kind == CTF_K_VOLATILE || kind == CTF_K_CONST | |
773 | || kind == CTF_K_RESTRICT) | |
774 | gcc_assert (type->dtd_data.ctti_type != CTF_NULL_TYPEID); | |
775 | } | |
776 | ||
777 | /* Output all CTF type records. */ | |
778 | ||
779 | static void | |
780 | output_ctf_types (ctf_container_ref ctfc) | |
781 | { | |
782 | size_t i; | |
783 | size_t num_ctf_types = ctfc->ctfc_types->elements (); | |
784 | if (num_ctf_types) | |
785 | { | |
786 | /* Type ID = 0 is used as sentinel value; not a valid type. */ | |
787 | for (i = 1; i <= num_ctf_types; i++) | |
788 | output_asm_ctf_type (ctfc, ctfc->ctfc_types_list[i]); | |
789 | } | |
790 | } | |
791 | ||
792 | /* CTF routines interfacing to the compiler. */ | |
793 | ||
794 | /* Prepare and output the CTF section. */ | |
795 | ||
796 | void | |
797 | ctf_output (const char * filename) | |
798 | { | |
799 | if (ctf_debug_info_level == CTFINFO_LEVEL_NONE) | |
800 | return; | |
801 | ||
802 | /* Get the CTF container for the current translation unit. */ | |
803 | ctf_container_ref tu_ctfc = ctf_get_tu_ctfc (); | |
804 | ||
805 | init_ctf_sections (); | |
806 | ||
807 | ctf_add_cuname (tu_ctfc, filename); | |
808 | ||
809 | /* Pre-process CTF before generating assembly. */ | |
810 | ctf_preprocess (tu_ctfc); | |
811 | output_ctf_header (tu_ctfc); | |
812 | output_ctf_obj_info (tu_ctfc); | |
813 | output_ctf_func_info (tu_ctfc); | |
814 | output_ctf_objtidx (tu_ctfc); | |
815 | output_ctf_funcidx (tu_ctfc); | |
816 | output_ctf_vars (tu_ctfc); | |
817 | output_ctf_types (tu_ctfc); | |
818 | output_ctf_strs (tu_ctfc); | |
819 | ||
820 | /* The total number of string bytes must be equal to those processed out to | |
821 | the str subsection. */ | |
822 | gcc_assert (tu_ctfc->ctfc_strlen | |
823 | == ctfc_get_strtab_len (tu_ctfc, CTF_STRTAB)); | |
824 | ||
825 | } | |
826 | ||
827 | /* Reset all state for CTF generation so that we can rerun the compiler within | |
828 | the same process. */ | |
829 | ||
830 | void | |
831 | ctf_finalize (void) | |
832 | { | |
833 | ctf_info_section = NULL; | |
834 | ||
835 | ctf_container_ref tu_ctfc = ctf_get_tu_ctfc (); | |
836 | ctfc_delete_container (tu_ctfc); | |
837 | tu_ctfc = NULL; | |
838 | } | |
839 | ||
840 | #include "gt-ctfout.h" |