Line data Source code
1 : /* dwarf2out.h - Various declarations for functions found in dwarf2out.cc
2 : Copyright (C) 1998-2026 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 : #ifndef GCC_DWARF2OUT_H
21 : #define GCC_DWARF2OUT_H 1
22 :
23 : #include "dwarf2.h" /* ??? Remove this once only used by dwarf2foo.c. */
24 :
25 : typedef struct die_struct *dw_die_ref;
26 : typedef const struct die_struct *const_dw_die_ref;
27 :
28 : typedef struct dw_val_node *dw_val_ref;
29 : typedef struct dw_cfi_node *dw_cfi_ref;
30 : typedef struct dw_loc_descr_node *dw_loc_descr_ref;
31 : typedef struct dw_loc_list_struct *dw_loc_list_ref;
32 : typedef struct dw_discr_list_node *dw_discr_list_ref;
33 : typedef struct dw_wide_int *dw_wide_int_ptr;
34 :
35 :
36 : /* Call frames are described using a sequence of Call Frame
37 : Information instructions. The register number, offset
38 : and address fields are provided as possible operands;
39 : their use is selected by the opcode field. */
40 : enum dw_cfi_oprnd_type: int {
41 : dw_cfi_oprnd_unused,
42 : dw_cfi_oprnd_reg_num,
43 : dw_cfi_oprnd_offset,
44 : dw_cfi_oprnd_addr,
45 : dw_cfi_oprnd_loc,
46 : dw_cfi_oprnd_cfa_loc
47 : };
48 :
49 : typedef union GTY(()) {
50 : unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
51 : HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
52 : const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
53 : struct dw_loc_descr_node * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
54 : struct dw_cfa_location * GTY ((tag ("dw_cfi_oprnd_cfa_loc")))
55 : dw_cfi_cfa_loc;
56 : } dw_cfi_oprnd;
57 :
58 : struct GTY(()) dw_cfi_node {
59 : enum dwarf_call_frame_info dw_cfi_opc;
60 : dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
61 : dw_cfi_oprnd1;
62 : dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
63 : dw_cfi_oprnd2;
64 : };
65 :
66 :
67 : typedef vec<dw_cfi_ref, va_gc> *cfi_vec;
68 :
69 : typedef struct dw_fde_node *dw_fde_ref;
70 :
71 : /* All call frame descriptions (FDE's) in the GCC generated DWARF
72 : refer to a single Common Information Entry (CIE), defined at
73 : the beginning of the .debug_frame section. This use of a single
74 : CIE obviates the need to keep track of multiple CIE's
75 : in the DWARF generation routines below. */
76 :
77 : struct GTY(()) dw_fde_node {
78 : tree decl;
79 : const char *dw_fde_begin;
80 : const char *dw_fde_current_label;
81 : const char *dw_fde_end;
82 : const char *dw_fde_vms_end_prologue;
83 : const char *dw_fde_vms_begin_epilogue;
84 : const char *dw_fde_second_begin;
85 : const char *dw_fde_second_end;
86 : cfi_vec dw_fde_cfi;
87 : int dw_fde_switch_cfi_index; /* Last CFI before switching sections. */
88 : HOST_WIDE_INT stack_realignment;
89 :
90 : unsigned funcdef_number;
91 : unsigned fde_index;
92 :
93 : /* Dynamic realign argument pointer register. */
94 : unsigned int drap_reg;
95 : /* Virtual dynamic realign argument pointer register. */
96 : unsigned int vdrap_reg;
97 : /* These 3 flags are copied from rtl_data in function.h. */
98 : unsigned all_throwers_are_sibcalls : 1;
99 : unsigned uses_eh_lsda : 1;
100 : unsigned nothrow : 1;
101 : /* Whether we did stack realign in this call frame. */
102 : unsigned stack_realign : 1;
103 : /* Whether dynamic realign argument pointer register has been saved. */
104 : unsigned drap_reg_saved: 1;
105 : /* True iff dw_fde_begin label is in text_section or cold_text_section. */
106 : unsigned in_std_section : 1;
107 : /* True iff dw_fde_second_begin label is in text_section or
108 : cold_text_section. */
109 : unsigned second_in_std_section : 1;
110 : /* True if Rule 18 described in dwarf2cfi.cc is in action, i.e. for dynamic
111 : stack realignment in between pushing of hard frame pointer to stack
112 : and setting hard frame pointer to stack pointer. The register save for
113 : hard frame pointer register should be emitted only on the latter
114 : instruction. */
115 : unsigned rule18 : 1;
116 : /* True if this function is to be ignored by debugger. */
117 : unsigned ignored_debug : 1;
118 : };
119 :
120 :
121 : /* This represents a register, in DWARF_FRAME_REGNUM space, for use in CFA
122 : definitions and expressions.
123 : Most architectures only need a single register number, but some (amdgcn)
124 : have pointers that span multiple registers. DWARF permits arbitrary
125 : register sets but existing use-cases only require contiguous register
126 : sets, as represented here. */
127 : struct GTY(()) cfa_reg {
128 : unsigned int reg;
129 : unsigned short span;
130 : unsigned short span_width; /* A.K.A. register mode size. */
131 :
132 3947183 : cfa_reg& set_by_dwreg (unsigned int r)
133 : {
134 3947183 : reg = r;
135 3947183 : span = 1;
136 3947183 : span_width = 0; /* Unknown size (permitted when span == 1). */
137 3947183 : return *this;
138 : }
139 :
140 232043015 : bool operator== (const cfa_reg &other) const
141 : {
142 193564097 : return (reg == other.reg && span == other.span
143 425607112 : && (span_width == other.span_width
144 0 : || (span == 1
145 0 : && (span_width == 0 || other.span_width == 0))));
146 : }
147 :
148 28268 : bool operator!= (const cfa_reg &other) const
149 : {
150 21201 : return !(*this == other);
151 : }
152 : };
153 :
154 : /* This is how we define the location of the CFA. We use to handle it
155 : as REG + OFFSET all the time, but now it can be more complex.
156 : It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
157 : Instead of passing around REG and OFFSET, we pass a copy
158 : of this structure. */
159 : struct GTY(()) dw_cfa_location {
160 : poly_int64 offset;
161 : poly_int64 base_offset;
162 : /* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space. */
163 : struct cfa_reg reg;
164 : BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
165 : BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
166 : };
167 :
168 :
169 : /* Each DIE may have a series of attribute/value pairs. Values
170 : can take on several forms. The forms that are used in this
171 : implementation are listed below. */
172 :
173 : enum dw_val_class
174 : {
175 : dw_val_class_none,
176 : dw_val_class_addr,
177 : dw_val_class_offset,
178 : dw_val_class_loc,
179 : dw_val_class_loc_list,
180 : dw_val_class_range_list,
181 : dw_val_class_const,
182 : dw_val_class_unsigned_const,
183 : dw_val_class_const_double,
184 : dw_val_class_wide_int,
185 : dw_val_class_vec,
186 : dw_val_class_flag,
187 : dw_val_class_die_ref,
188 : dw_val_class_fde_ref,
189 : dw_val_class_lbl_id,
190 : dw_val_class_lineptr,
191 : dw_val_class_str,
192 : dw_val_class_macptr,
193 : dw_val_class_loclistsptr,
194 : dw_val_class_file,
195 : dw_val_class_data8,
196 : dw_val_class_decl_ref,
197 : dw_val_class_vms_delta,
198 : dw_val_class_high_pc,
199 : dw_val_class_discr_value,
200 : dw_val_class_discr_list,
201 : dw_val_class_const_implicit,
202 : dw_val_class_unsigned_const_implicit,
203 : dw_val_class_file_implicit,
204 : dw_val_class_view_list,
205 : dw_val_class_symview
206 : };
207 :
208 : /* Describe a floating point constant value, or a vector constant value. */
209 :
210 : struct GTY(()) dw_vec_const {
211 : void * GTY((atomic)) array;
212 : unsigned length;
213 : unsigned elt_size;
214 : };
215 :
216 : /* Describe a single value that a discriminant can match.
217 :
218 : Discriminants (in the "record variant part" meaning) are scalars.
219 : dw_discr_list_ref and dw_discr_value are a mean to describe a set of
220 : discriminant values that are matched by a particular variant.
221 :
222 : Discriminants can be signed or unsigned scalars, and can be discriminants
223 : values. Both have to be consistent, though. */
224 :
225 : struct GTY(()) dw_discr_value {
226 : int pos; /* Whether the discriminant value is positive (unsigned). */
227 : union
228 : {
229 : HOST_WIDE_INT GTY ((tag ("0"))) sval;
230 : unsigned HOST_WIDE_INT GTY ((tag ("1"))) uval;
231 : }
232 : GTY ((desc ("%1.pos"))) v;
233 : };
234 :
235 : struct addr_table_entry;
236 :
237 : typedef unsigned int var_loc_view;
238 :
239 : /* Location lists are ranges + location descriptions for that range,
240 : so you can track variables that are in different places over
241 : their entire life. */
242 : typedef struct GTY(()) dw_loc_list_struct {
243 : dw_loc_list_ref dw_loc_next;
244 : const char *begin; /* Label and addr_entry for start of range */
245 : addr_table_entry *begin_entry;
246 : const char *end; /* Label for end of range */
247 : addr_table_entry *end_entry;
248 : char *ll_symbol; /* Label for beginning of location list.
249 : Only on head of list. */
250 : char *vl_symbol; /* Label for beginning of view list. Ditto. */
251 : const char *section; /* Section this loclist is relative to */
252 : dw_loc_descr_ref expr;
253 : var_loc_view vbegin, vend;
254 : hashval_t hash;
255 : /* True if all addresses in this and subsequent lists are known to be
256 : resolved. */
257 : bool resolved_addr;
258 : /* True if this list has been replaced by dw_loc_next. */
259 : bool replaced;
260 : /* True if it has been emitted into .debug_loc* / .debug_loclists*
261 : section. */
262 : unsigned char emitted : 1;
263 : /* True if hash field is index rather than hash value. */
264 : unsigned char num_assigned : 1;
265 : /* True if .debug_loclists.dwo offset has been emitted for it already. */
266 : unsigned char offset_emitted : 1;
267 : /* True if note_variable_value_in_expr has been called on it. */
268 : unsigned char noted_variable_value : 1;
269 : /* True if the range should be emitted even if begin and end
270 : are the same. */
271 : bool force;
272 : } dw_loc_list_node;
273 :
274 : /* The dw_val_node describes an attribute's value, as it is
275 : represented internally. */
276 :
277 : struct GTY(()) dw_val_node {
278 : enum dw_val_class val_class;
279 : /* On 64-bit host, there are 4 bytes of padding between val_class
280 : and val_entry. Reuse the padding for other content of
281 : dw_loc_descr_node and dw_attr_struct. */
282 : union dw_val_node_parent
283 : {
284 : struct dw_val_loc_descr_node
285 : {
286 : ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc_v : 8;
287 : /* Used to distinguish DW_OP_addr with a direct symbol relocation
288 : from DW_OP_addr with a dtp-relative symbol relocation. */
289 : unsigned int dw_loc_dtprel_v : 1;
290 : /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
291 : it targets a DWARF prodecure argument. In this case, it needs to be
292 : relocated according to the current frame offset. */
293 : unsigned int dw_loc_frame_offset_rel_v : 1;
294 : } u1;
295 : int u2;
296 : enum dwarf_attribute u3;
297 : } GTY((skip)) u;
298 : struct addr_table_entry * GTY(()) val_entry;
299 : union dw_val_struct_union
300 : {
301 : rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
302 : unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
303 : dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
304 : dw_die_ref GTY ((tag ("dw_val_class_view_list"))) val_view_list;
305 : dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
306 : HOST_WIDE_INT GTY ((default)) val_int;
307 : unsigned HOST_WIDE_INT
308 : GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
309 : double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
310 : dw_wide_int_ptr GTY ((tag ("dw_val_class_wide_int"))) val_wide;
311 : dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
312 : struct dw_val_die_union
313 : {
314 : dw_die_ref die;
315 : int external;
316 : } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
317 : unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
318 : struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
319 : char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
320 : unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
321 : struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
322 : struct dwarf_file_data *
323 : GTY ((tag ("dw_val_class_file_implicit"))) val_file_implicit;
324 : unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
325 : tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
326 : struct dw_val_vms_delta_union
327 : {
328 : char * lbl1;
329 : char * lbl2;
330 : } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
331 : dw_discr_value GTY ((tag ("dw_val_class_discr_value"))) val_discr_value;
332 : dw_discr_list_ref GTY ((tag ("dw_val_class_discr_list"))) val_discr_list;
333 : char * GTY ((tag ("dw_val_class_symview"))) val_symbolic_view;
334 : }
335 : GTY ((desc ("%1.val_class"))) v;
336 : };
337 :
338 : /* Locations in memory are described using a sequence of stack machine
339 : operations. */
340 :
341 : struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
342 : dw_loc_descr_ref dw_loc_next;
343 : #define dw_loc_opc dw_loc_oprnd1.u.u1.dw_loc_opc_v
344 : /* Used to distinguish DW_OP_addr with a direct symbol relocation
345 : from DW_OP_addr with a dtp-relative symbol relocation. */
346 : #define dw_loc_dtprel dw_loc_oprnd1.u.u1.dw_loc_dtprel_v
347 : /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
348 : it targets a DWARF prodecure argument. In this case, it needs to be
349 : relocated according to the current frame offset. */
350 : #define dw_loc_frame_offset_rel dw_loc_oprnd1.u.u1.dw_loc_frame_offset_rel_v
351 : #define dw_loc_addr dw_loc_oprnd2.u.u2
352 : dw_val_node dw_loc_oprnd1;
353 : dw_val_node dw_loc_oprnd2;
354 : };
355 :
356 : /* A variant (inside a record variant part) is selected when the corresponding
357 : discriminant matches its set of values (see the comment for dw_discr_value).
358 : The following datastructure holds such matching information. */
359 :
360 : struct GTY(()) dw_discr_list_node {
361 : dw_discr_list_ref dw_discr_next;
362 :
363 : dw_discr_value dw_discr_lower_bound;
364 : dw_discr_value dw_discr_upper_bound;
365 : /* This node represents only the value in dw_discr_lower_bound when it's
366 : zero. It represents the range between the two fields (bounds included)
367 : otherwise. */
368 : int dw_discr_range;
369 : };
370 :
371 : struct GTY((variable_size)) dw_wide_int {
372 : unsigned int precision;
373 : unsigned int len;
374 : HOST_WIDE_INT val[1];
375 :
376 1779 : unsigned int get_precision () const { return precision; }
377 0 : unsigned int get_len () const { return len; }
378 712 : const HOST_WIDE_INT *get_val () const { return val; }
379 : inline HOST_WIDE_INT elt (unsigned int) const;
380 : inline bool operator == (const dw_wide_int &) const;
381 : };
382 :
383 : inline HOST_WIDE_INT
384 1268 : dw_wide_int::elt (unsigned int i) const
385 : {
386 1268 : if (i < len)
387 1267 : return val[i];
388 1 : wide_int_ref ref = wi::storage_ref (val, len, precision);
389 1 : return wi::sign_mask (ref);
390 : }
391 :
392 : inline bool
393 144 : dw_wide_int::operator == (const dw_wide_int &o) const
394 : {
395 144 : wide_int_ref ref1 = wi::storage_ref (val, len, precision);
396 144 : wide_int_ref ref2 = wi::storage_ref (o.val, o.len, o.precision);
397 144 : return ref1 == ref2;
398 : }
399 :
400 : /* Interface from dwarf2out.cc to dwarf2cfi.cc. */
401 : extern struct dw_loc_descr_node *build_cfa_loc
402 : (dw_cfa_location *, poly_int64);
403 : extern struct dw_loc_descr_node *build_cfa_aligned_loc
404 : (dw_cfa_location *, poly_int64, HOST_WIDE_INT);
405 : extern struct dw_loc_descr_node *build_span_loc (struct cfa_reg);
406 : extern struct dw_loc_descr_node *mem_loc_descriptor
407 : (rtx, machine_mode mode, machine_mode mem_mode,
408 : enum var_init_status);
409 : extern bool loc_descr_equal_p (dw_loc_descr_ref, dw_loc_descr_ref);
410 : extern dw_fde_ref dwarf2out_alloc_current_fde (void);
411 :
412 : extern unsigned long size_of_locs (dw_loc_descr_ref);
413 : extern void output_loc_sequence (dw_loc_descr_ref, int);
414 : extern void output_loc_sequence_raw (dw_loc_descr_ref);
415 :
416 : /* Interface from dwarf2cfi.cc to dwarf2out.cc. */
417 : extern void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc,
418 : dw_cfa_location *remember);
419 : extern bool cfa_equal_p (const dw_cfa_location *, const dw_cfa_location *);
420 :
421 : extern void output_cfi (dw_cfi_ref, dw_fde_ref, int);
422 :
423 : extern GTY(()) cfi_vec cie_cfi_vec;
424 :
425 : /* Interface from dwarf2*.c to the rest of the compiler. */
426 : extern enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc (dwarf_call_frame_info cfi);
427 : extern enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc (dwarf_call_frame_info cfi);
428 :
429 : extern void output_cfi_directive (FILE *f, dw_cfi_ref cfi);
430 :
431 : extern void dwarf2out_emit_cfi (dw_cfi_ref cfi);
432 :
433 : extern void debug_dwarf (void);
434 : struct die_struct;
435 : extern void debug_dwarf_die (struct die_struct *);
436 : extern void debug_dwarf_loc_descr (dw_loc_descr_ref);
437 : extern void debug (die_struct &ref);
438 : extern void debug (die_struct *ptr);
439 : extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
440 : #ifdef VMS_DEBUGGING_INFO
441 : extern void dwarf2out_vms_debug_main_pointer (void);
442 : #endif
443 :
444 : enum array_descr_ordering
445 : {
446 : array_descr_ordering_default,
447 : array_descr_ordering_row_major,
448 : array_descr_ordering_column_major
449 : };
450 :
451 : #define DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN 16
452 :
453 : struct array_descr_info
454 : {
455 : int ndimensions;
456 : enum array_descr_ordering ordering;
457 : tree element_type;
458 : tree base_decl;
459 : tree data_location;
460 : tree allocated;
461 : tree associated;
462 : tree stride;
463 : tree rank;
464 : bool stride_in_bits;
465 : struct array_descr_dimen
466 : {
467 : /* GCC uses sizetype for array indices, so lower_bound and upper_bound
468 : will likely be "sizetype" values. However, bounds may have another
469 : type in the original source code. */
470 : tree bounds_type;
471 : tree lower_bound;
472 : tree upper_bound;
473 :
474 : /* Only Fortran uses more than one dimension for array types. For other
475 : languages, the stride can be rather specified for the whole array. */
476 : tree stride;
477 : } dimen[DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN];
478 : };
479 :
480 : enum fixed_point_scale_factor
481 : {
482 : fixed_point_scale_factor_binary,
483 : fixed_point_scale_factor_decimal,
484 : fixed_point_scale_factor_arbitrary
485 : };
486 :
487 : struct fixed_point_type_info
488 : {
489 : /* The scale factor is the value one has to multiply the actual data with
490 : to get the fixed point value. We support three ways to encode it. */
491 : enum fixed_point_scale_factor scale_factor_kind;
492 : union
493 : {
494 : /* For a binary scale factor, the scale factor is 2 ** binary. */
495 : int binary;
496 : /* For a decimal scale factor, the scale factor is 10 ** decimal. */
497 : int decimal;
498 : /* For an arbitrary scale factor, the scale factor is the ratio
499 : numerator / denominator. */
500 : struct { tree numerator; tree denominator; } arbitrary;
501 : } scale_factor;
502 : };
503 :
504 : void dwarf2cfi_cc_finalize (void);
505 : void dwarf2out_cc_finalize (void);
506 :
507 : /* Some DWARF internals are exposed for the needs of DWARF-based debug
508 : formats. */
509 :
510 : /* Each DIE attribute has a field specifying the attribute kind,
511 : a link to the next attribute in the chain, and an attribute value.
512 : Attributes are typically linked below the DIE they modify. */
513 :
514 : typedef struct GTY(()) dw_attr_struct {
515 : #define dw_attr dw_attr_val.u.u3
516 : dw_val_node dw_attr_val;
517 : }
518 : dw_attr_node;
519 :
520 : extern dw_attr_node *get_AT (dw_die_ref, enum dwarf_attribute);
521 : extern HOST_WIDE_INT AT_int (dw_attr_node *);
522 : extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *a);
523 : extern dw_loc_descr_ref AT_loc (dw_attr_node *);
524 : extern dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
525 : extern const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
526 : extern enum dw_val_class AT_class (dw_attr_node *);
527 : extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *);
528 : extern unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
529 : extern int get_AT_flag (dw_die_ref, enum dwarf_attribute);
530 :
531 : extern void add_name_attribute (dw_die_ref, const char *);
532 :
533 : extern dw_die_ref new_die_raw (enum dwarf_tag);
534 : extern dw_die_ref base_type_die (tree, bool);
535 :
536 : extern dw_die_ref lookup_decl_die (tree);
537 : extern dw_die_ref lookup_type_die (tree);
538 :
539 : extern dw_die_ref dw_get_die_child (dw_die_ref);
540 : extern dw_die_ref dw_get_die_sib (dw_die_ref);
541 : extern dw_die_ref dw_get_die_parent (dw_die_ref);
542 : extern enum dwarf_tag dw_get_die_tag (dw_die_ref);
543 :
544 : /* Data about a single source file. */
545 : struct GTY((for_user)) dwarf_file_data {
546 : const char * key;
547 : const char * filename;
548 : int emitted_number;
549 : };
550 :
551 : extern struct dwarf_file_data *get_AT_file (dw_die_ref,
552 : enum dwarf_attribute);
553 :
554 : #endif /* GCC_DWARF2OUT_H */
|
