]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/dwarf2out.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove special cases for cygwin32.
[thirdparty/gcc.git] / gcc / dwarf2out.c
CommitLineData
a3f97cbb
JW		 1/* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 1993, 1995, 1996 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com). Derived from the
4 DWARF 1 implementation written by Ron Guilmette (rfg@monkeys.com).
469ac993 5 Extensively modified by Jason Merrill (jason@cygnus.com).
a3f97cbb
JW		 6
7This file is part of GNU CC.
8
9GNU CC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GNU CC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GNU CC; see the file COPYING. If not, write to
21the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22
23#include "config.h"
24
9a666dda 25#ifdef DWARF2_DEBUGGING_INFO
a3f97cbb 26#include <stdio.h>
469ac993 27#include <setjmp.h>
a3f97cbb
JW		 28#include "dwarf2.h"
29#include "tree.h"
30#include "flags.h"
31#include "rtl.h"
32#include "hard-reg-set.h"
33#include "regs.h"
34#include "insn-config.h"
35#include "reload.h"
36#include "output.h"
37#include "defaults.h"
38
39/* #define NDEBUG 1 */
40#include "assert.h"
a3f97cbb
JW		 41
42extern char *getpwd ();
a3f97cbb
JW		 43
44/* IMPORTANT NOTE: Please see the file README.DWARF for important details
45 regarding the GNU implementation of DWARF. */
46
47/* NOTE: In the comments in this file, many references are made to
48 "Debugging Information Entries". This term is abbreviated as `DIE'
49 throughout the remainder of this file. */
50
a3f97cbb
JW		 51#if defined(__GNUC__) && (NDEBUG == 1)
52#define inline static inline
53#else
54#define inline static
55#endif
56
57
58/* An internal representation of the DWARF output is built, and then
59 walked to generate the DWARF debugging info. The walk of the internal
60 representation is done after the entire program has been compiled.
61 The types below are used to describe the internal representation. */
62
63/* Each DIE may have a series of attribute/value pairs. Values
64 can take on several forms. The forms that are used in this
65 impelementation are listed below. */
66typedef enum
67 {
68 dw_val_class_addr,
69 dw_val_class_loc,
70 dw_val_class_const,
71 dw_val_class_unsigned_const,
469ac993
JM		 72 dw_val_class_long_long,
73 dw_val_class_float,
a3f97cbb
JW		 74 dw_val_class_flag,
75 dw_val_class_die_ref,
76 dw_val_class_fde_ref,
77 dw_val_class_lbl_id,
78 dw_val_class_section_offset,
79 dw_val_class_str
80 }
81dw_val_class;
82
83/* Various DIE's use offsets relative to the beginning of the
84 .debug_info section to refer to each other. */
85typedef long int dw_offset;
86
87/* Define typedefs here to avoid circular dependencies. */
88typedef struct die_struct *dw_die_ref;
89typedef struct dw_attr_struct *dw_attr_ref;
90typedef struct dw_val_struct *dw_val_ref;
91typedef struct dw_line_info_struct *dw_line_info_ref;
e90b62db 92typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
a3f97cbb
JW		 93typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
94typedef struct dw_cfi_struct *dw_cfi_ref;
95typedef struct dw_fde_struct *dw_fde_ref;
96typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
d291dd49
JM		 97typedef struct pubname_struct *pubname_ref;
98typedef dw_die_ref *arange_ref;
a3f97cbb
JW		 99
100/* Describe a double word constant value. */
469ac993 101typedef struct dw_long_long_struct
a3f97cbb 102 {
469ac993
JM		 103 unsigned long hi;
104 unsigned long low;
a3f97cbb 105 }
469ac993
JM		 106dw_long_long_const;
107
108/* Describe a floating point constant value. */
109typedef struct dw_fp_struct
110 {
111 long *array;
112 unsigned length;
113 }
114dw_float_const;
a3f97cbb
JW		 115
116/* Each entry in the line_info_table maintains the file and
117 line nuber associated with the label generated for that
118 entry. The label gives the PC value associated with
119 the line number entry. */
120typedef struct dw_line_info_struct
121 {
122 unsigned long dw_file_num;
123 unsigned long dw_line_num;
124 }
125dw_line_info_entry;
126
e90b62db
JM		 127/* Line information for functions in separate sections; each one gets its
128 own sequence. */
129typedef struct dw_separate_line_info_struct
130 {
131 unsigned long dw_file_num;
132 unsigned long dw_line_num;
133 unsigned long function;
134 }
135dw_separate_line_info_entry;
136
a3f97cbb
JW		 137/* The dw_val_node describes an attibute's value, as it is
138 represnted internally. */
139typedef struct dw_val_struct
140 {
141 dw_val_class val_class;
142 union
143 {
144 char *val_addr;
145 dw_loc_descr_ref val_loc;
146 long int val_int;
147 long unsigned val_unsigned;
469ac993
JM		 148 dw_long_long_const val_long_long;
149 dw_float_const val_float;
a3f97cbb
JW		 150 dw_die_ref val_die_ref;
151 unsigned val_fde_index;
152 char *val_str;
153 char *val_lbl_id;
154 char *val_section;
155 unsigned char val_flag;
156 }
157 v;
158 }
159dw_val_node;
160
161/* Locations in memory are described using a sequence of stack machine
162 operations. */
163typedef struct dw_loc_descr_struct
164 {
165 dw_loc_descr_ref dw_loc_next;
166 enum dwarf_location_atom dw_loc_opc;
167 dw_val_node dw_loc_oprnd1;
168 dw_val_node dw_loc_oprnd2;
169 }
170dw_loc_descr_node;
171
172/* Each DIE attribute has a field specifying the attribute kind,
173 a link to the next attribute in the chain, and an attribute value.
174 Attributes are typically linked below the DIE they modify. */
175typedef struct dw_attr_struct
176 {
177 enum dwarf_attribute dw_attr;
178 dw_attr_ref dw_attr_next;
179 dw_val_node dw_attr_val;
180 }
181dw_attr_node;
182
183/* Call frames are described using a sequence of Call Frame
184 Information instructions. The register number, offset
185 and address fields are provided as possible operands;
186 their use is selected by the opcode field. */
187typedef union dw_cfi_oprnd_struct
188 {
189 unsigned long dw_cfi_reg_num;
190 long int dw_cfi_offset;
191 char *dw_cfi_addr;
192 }
193dw_cfi_oprnd;
194
195typedef struct dw_cfi_struct
196 {
197 dw_cfi_ref dw_cfi_next;
198 enum dwarf_call_frame_info dw_cfi_opc;
199 dw_cfi_oprnd dw_cfi_oprnd1;
200 dw_cfi_oprnd dw_cfi_oprnd2;
201 }
202dw_cfi_node;
203
204/* All call frame descriptions (FDE's) in the GCC generated DWARF
4b674448 205 refer to a single Common Information Entry (CIE), defined at
a3f97cbb
JW		 206 the beginning of the .debug_frame section. This used of a single
207 CIE obviates the need to keep track of multiple CIE's
208 in the DWARF generation routines below. */
209typedef struct dw_fde_struct
210 {
211 unsigned long dw_fde_offset;
212 char *dw_fde_begin;
a94dbf2c 213 char *dw_fde_current_label;
a3f97cbb
JW		 214 char *dw_fde_end;
215 dw_cfi_ref dw_fde_cfi;
216 }
217dw_fde_node;
218
219/* The Debugging Information Entry (DIE) structure */
220typedef struct die_struct
221 {
222 enum dwarf_tag die_tag;
223 dw_attr_ref die_attr;
224 dw_attr_ref die_attr_last;
225 dw_die_ref die_parent;
226 dw_die_ref die_child;
227 dw_die_ref die_child_last;
228 dw_die_ref die_sib;
229 dw_offset die_offset;
230 unsigned long die_abbrev;
231 }
232die_node;
233
d291dd49
JM		 234/* The pubname structure */
235typedef struct pubname_struct
236{
237 dw_die_ref die;
238 char * name;
239}
240pubname_entry;
241
a3f97cbb
JW		 242/* How to start an assembler comment. */
243#ifndef ASM_COMMENT_START
244#define ASM_COMMENT_START ";#"
245#endif
246
5c90448c
JM		 247/* Define a macro which returns non-zero for a TYPE_DECL which was
248 implicitly generated for a tagged type.
249
250 Note that unlike the gcc front end (which generates a NULL named
251 TYPE_DECL node for each complete tagged type, each array type, and
252 each function type node created) the g++ front end generates a
253 _named_ TYPE_DECL node for each tagged type node created.
254 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
255 generate a DW_TAG_typedef DIE for them. */
256#define TYPE_DECL_IS_STUB(decl) \
257 (DECL_NAME (decl) == NULL \
258 || (DECL_ARTIFICIAL (decl) \
259 && is_tagged_type (TREE_TYPE (decl)) \
260 && decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
261
a3f97cbb
JW		 262/* Information concerning the compilation unit's programming
263 language, and compiler version. */
264extern int flag_traditional;
265extern char *version_string;
266extern char *language_string;
267
268/* Maximum size (in bytes) of an artificially generated label. */
269#define MAX_ARTIFICIAL_LABEL_BYTES 30
270
271/* Make sure we know the sizes of the various types dwarf can describe. These
272 are only defaults. If the sizes are different for your target, you should
273 override these values by defining the appropriate symbols in your tm.h
274 file. */
275#ifndef CHAR_TYPE_SIZE
276#define CHAR_TYPE_SIZE BITS_PER_UNIT
277#endif
a3f97cbb 278#ifndef PTR_SIZE
a9d38797 279#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
a3f97cbb
JW		 280#endif
281
7e23cb16
JM		 282/* The size in bytes of a DWARF field indicating an offset or length
283 relative to a debug info section, specified to be 4 bytes in the DWARF-2
284 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
285#ifndef DWARF_OFFSET_SIZE
286#define DWARF_OFFSET_SIZE 4
287#endif
288
9a666dda
JM		 289#define DWARF_VERSION 2
290
a3f97cbb 291/* Fixed size portion of the DWARF compilation unit header. */
7e23cb16 292#define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
a3f97cbb
JW		 293
294/* Fixed size portion of debugging line information prolog. */
295#define DWARF_LINE_PROLOG_HEADER_SIZE 5
296
297/* Fixed size portion of public names info. */
7e23cb16
JM		 298#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
299
300/* Round SIZE up to the nearest BOUNDARY. */
301#define DWARF_ROUND(SIZE,BOUNDARY) \
302 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
a3f97cbb
JW		 303
304/* Fixed size portion of the address range info. */
7e23cb16
JM		 305#define DWARF_ARANGES_HEADER_SIZE \
306 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
a3f97cbb 307
c8cc5c4a 308/* Fixed size portion of the CIE (including the length field). */
a94dbf2c 309#define DWARF_CIE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 5)
a3f97cbb 310
a94dbf2c
JM		 311/* The un-padded size of the CIE. Initialized in calc_fde_sizes, used
312 in output_call_frame_info. */
313static unsigned cie_size;
a3f97cbb
JW		 314
315/* Offsets recorded in opcodes are a multiple of this alignment factor. */
469ac993
JM		 316#ifdef STACK_GROWS_DOWNWARD
317#define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
318#else
319#define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
320#endif
a3f97cbb
JW		 321
322/* Fixed size portion of the FDE. */
7e23cb16 323#define DWARF_FDE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2 * PTR_SIZE)
a3f97cbb
JW		 324
325/* Define the architecture-dependent minimum instruction length (in bytes).
326 In this implementation of DWARF, this field is used for information
327 purposes only. Since GCC generates assembly language, we have
328 no a priori knowledge of how many instruction bytes are generated
329 for each source line, and therefore can use only the DW_LNE_set_address
330 and DW_LNS_fixed_advance_pc line information commands. */
331#ifndef DWARF_LINE_MIN_INSTR_LENGTH
332#define DWARF_LINE_MIN_INSTR_LENGTH 4
333#endif
334
335/* Minimum line offset in a special line info. opcode.
336 This value was chosen to give a reasonable range of values. */
337#define DWARF_LINE_BASE -10
338
339/* First special line opcde - leave room for the standard opcodes. */
340#define DWARF_LINE_OPCODE_BASE 10
341
342/* Range of line offsets in a special line info. opcode. */
343#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
344
345/* Flag that indicates the initial value of the is_stmt_start flag.
346 In the present implementation, we do not mark any lines as
347 the beginning of a source statement, because that information
348 is not made available by the GCC front-end. */
349#define DWARF_LINE_DEFAULT_IS_STMT_START 1
350
351/* This location is used by calc_die_sizes() to keep track
352 the offset of each DIE within the .debug_info section. */
353static unsigned long next_die_offset;
354
355/* This location is used by calc_fde_sizes() to keep track
356 the offset of each FDE within the .debug_frame section. */
357static unsigned long next_fde_offset;
358
359/* Record the root of the DIE's built for the current compilation unit. */
360dw_die_ref comp_unit_die;
361
a94dbf2c
JM		 362/* The number of DIEs with a NULL parent waiting to be relocated. */
363static int limbo_die_count;
364
a3f97cbb
JW		 365/* Pointer to an array of filenames referenced by this compilation unit. */
366static char **file_table;
367
368/* Total number of entries in the table (i.e. array) pointed to by
369 `file_table'. This is the *total* and includes both used and unused
370 slots. */
371static unsigned file_table_allocated;
372
373/* Number of entries in the file_table which are actually in use. */
374static unsigned file_table_in_use;
375
376/* Size (in elements) of increments by which we may expand the filename
377 table. */
378#define FILE_TABLE_INCREMENT 64
379
380/* Local pointer to the name of the main input file. Initialized in
9a666dda 381 dwarf2out_init. */
a3f97cbb
JW		 382static char *primary_filename;
383
384/* For Dwarf output, we must assign lexical-blocks id numbers in the order in
385 which their beginnings are encountered. We output Dwarf debugging info
386 that refers to the beginnings and ends of the ranges of code for each
387 lexical block. The labels themselves are generated in final.c, which
388 assigns numbers to the blocks in the same way. */
389static unsigned next_block_number = 2;
390
a3f97cbb
JW		 391/* A pointer to the base of a table of references to DIE's that describe
392 declarations. The table is indexed by DECL_UID() which is a unique
393 number, indentifying each decl. */
394static dw_die_ref *decl_die_table;
395
396/* Number of elements currently allocated for the decl_die_table. */
397static unsigned decl_die_table_allocated;
398
399/* Number of elements in decl_die_table currently in use. */
400static unsigned decl_die_table_in_use;
401
402/* Size (in elements) of increments by which we may expand the
403 decl_die_table. */
404#define DECL_DIE_TABLE_INCREMENT 256
405
406/* A pointer to the base of a table of references to declaration
407 scopes. This table is a display which tracks the nesting
408 of declaration scopes at the current scope and containing
409 scopes. This table is used to find the proper place to
410 define type declaration DIE's. */
411static tree *decl_scope_table;
412
413/* Number of elements currently allocated for the decl_scope_table. */
414static unsigned decl_scope_table_allocated;
415
416/* Current level of nesting of declataion scopes. */
417static unsigned decl_scope_depth;
418
419/* Size (in elements) of increments by which we may expand the
420 decl_scope_table. */
421#define DECL_SCOPE_TABLE_INCREMENT 64
422
423/* A pointer to the base of a list of references to DIE's that
424 are uniquely identified by their tag, presence/absence of
425 children DIE's, and list of attribute/value pairs. */
426static dw_die_ref *abbrev_die_table;
427
428/* Number of elements currently allocated for abbrev_die_table. */
429static unsigned abbrev_die_table_allocated;
430
431/* Number of elements in type_die_table currently in use. */
432static unsigned abbrev_die_table_in_use;
433
434/* Size (in elements) of increments by which we may expand the
435 abbrev_die_table. */
436#define ABBREV_DIE_TABLE_INCREMENT 256
437
438/* A pointer to the base of a table that contains line information
e90b62db 439 for each source code line in .text in the compilation unit. */
a3f97cbb
JW		 440static dw_line_info_ref line_info_table;
441
442/* Number of elements currently allocated for line_info_table. */
443static unsigned line_info_table_allocated;
444
e90b62db
JM		 445/* Number of elements in separate_line_info_table currently in use. */
446static unsigned separate_line_info_table_in_use;
447
448/* A pointer to the base of a table that contains line information
449 for each source code line outside of .text in the compilation unit. */
450static dw_separate_line_info_ref separate_line_info_table;
451
452/* Number of elements currently allocated for separate_line_info_table. */
453static unsigned separate_line_info_table_allocated;
454
a3f97cbb
JW		 455/* Number of elements in line_info_table currently in use. */
456static unsigned line_info_table_in_use;
457
458/* Size (in elements) of increments by which we may expand the
459 line_info_table. */
460#define LINE_INFO_TABLE_INCREMENT 1024
461
a3f97cbb
JW		 462/* A pointer to the base of a table that contains frame description
463 information for each routine. */
464static dw_fde_ref fde_table;
465
466/* Number of elements currently allocated for fde_table. */
467static unsigned fde_table_allocated;
468
469/* Number of elements in fde_table currently in use. */
470static unsigned fde_table_in_use;
471
472/* Size (in elements) of increments by which we may expand the
473 fde_table. */
474#define FDE_TABLE_INCREMENT 256
475
a94dbf2c
JM		 476/* A list of call frame insns for the CIE. */
477static dw_cfi_ref cie_cfi_head;
478
d291dd49
JM		 479/* A pointer to the base of a table that contains a list of publicly
480 accessible names. */
481static pubname_ref pubname_table;
482
483/* Number of elements currently allocated for pubname_table. */
484static unsigned pubname_table_allocated;
485
486/* Number of elements in pubname_table currently in use. */
487static unsigned pubname_table_in_use;
488
489/* Size (in elements) of increments by which we may expand the
490 pubname_table. */
491#define PUBNAME_TABLE_INCREMENT 64
492
493/* A pointer to the base of a table that contains a list of publicly
494 accessible names. */
495static arange_ref arange_table;
496
497/* Number of elements currently allocated for arange_table. */
498static unsigned arange_table_allocated;
499
500/* Number of elements in arange_table currently in use. */
501static unsigned arange_table_in_use;
502
503/* Size (in elements) of increments by which we may expand the
504 arange_table. */
505#define ARANGE_TABLE_INCREMENT 64
506
a94dbf2c
JM		 507/* A pointer to the base of a list of pending types which we haven't
508 generated DIEs for yet, but which we will have to come back to
509 later on. */
510
511static tree *pending_types_list;
512
513/* Number of elements currently allocated for the pending_types_list. */
514
515static unsigned pending_types_allocated;
516
517/* Number of elements of pending_types_list currently in use. */
518
519static unsigned pending_types;
520
521/* Size (in elements) of increments by which we may expand the pending
522 types list. Actually, a single hunk of space of this size should
523 be enough for most typical programs. */
524
525#define PENDING_TYPES_INCREMENT 64
526
a3f97cbb
JW		 527/* The number of the current function definition for which debugging
528 information is being generated. These numbers range from 1 up to the
529 maximum number of function definitions contained within the current
530 compilation unit. These numbers are used to create unique label id's
531 unique to each function definition. */
532static unsigned current_funcdef_number = 1;
533
534/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
535 attribute that accelerates the lookup of the FDE associated
536 with the subprogram. This variable holds the table index of the FDE
537 associated with the current function (body) definition. */
538static unsigned current_funcdef_fde;
539
7e23cb16
JM		 540/* Record whether the function being analyzed contains inlined functions. */
541static int current_function_has_inlines;
542static int comp_unit_has_inlines;
543
a3f97cbb
JW		 544/* A pointer to the ..._DECL node which we have most recently been working
545 on. We keep this around just in case something about it looks screwy and
546 we want to tell the user what the source coordinates for the actual
547 declaration are. */
548static tree dwarf_last_decl;
549
a3f97cbb
JW		 550/* Forward declarations for functions defined in this file. */
551static void gen_type_die ();
552static void add_type_attribute ();
553static void decls_for_scope ();
554static void gen_decl_die ();
555static unsigned lookup_filename ();
7e23cb16 556static int constant_size PROTO((long unsigned));
f37230f0 557static enum dwarf_form value_format PROTO((dw_val_ref));
a94dbf2c 558static unsigned reg_number ();
a3f97cbb
JW		 559
560/* Definitions of defaults for assembler-dependent names of various
561 pseudo-ops and section names.
562 Theses may be overridden in the tm.h file (if necessary) for a particular
563 assembler. */
564#ifndef UNALIGNED_SHORT_ASM_OP
565#define UNALIGNED_SHORT_ASM_OP ".2byte"
566#endif
567#ifndef UNALIGNED_INT_ASM_OP
568#define UNALIGNED_INT_ASM_OP ".4byte"
569#endif
7e23cb16
JM		 570#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
571#define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
572#endif
a3f97cbb
JW		 573#ifndef ASM_BYTE_OP
574#define ASM_BYTE_OP ".byte"
575#endif
576
7e23cb16
JM		 577#ifndef UNALIGNED_OFFSET_ASM_OP
578#define UNALIGNED_OFFSET_ASM_OP \
579 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
580#endif
581
582#ifndef UNALIGNED_WORD_ASM_OP
583#define UNALIGNED_WORD_ASM_OP \
584 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
585#endif
586
587/* Data and reference forms for relocatable data. */
588#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
589#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
590
a3f97cbb
JW		 591/* Pseudo-op for defining a new section. */
592#ifndef SECTION_ASM_OP
593#define SECTION_ASM_OP ".section"
594#endif
595
596/* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
597 print the SECTION_ASM_OP and the section name. The default here works for
598 almost all svr4 assemblers, except for the sparc, where the section name
599 must be enclosed in double quotes. (See sparcv4.h). */
600#ifndef SECTION_FORMAT
601#define SECTION_FORMAT "\t%s\t%s\n"
602#endif
603
604/* Section names used to hold DWARF debugging information. */
605#ifndef DEBUG_SECTION
606#define DEBUG_SECTION ".debug_info"
607#endif
608#ifndef ABBREV_SECTION
609#define ABBREV_SECTION ".debug_abbrev"
610#endif
611#ifndef ARANGES_SECTION
612#define ARANGES_SECTION ".debug_aranges"
613#endif
614#ifndef DW_MACINFO_SECTION
615#define DW_MACINFO_SECTION ".debug_macinfo"
616#endif
617#ifndef FRAME_SECTION
618#define FRAME_SECTION ".debug_frame"
619#endif
620#ifndef LINE_SECTION
621#define LINE_SECTION ".debug_line"
622#endif
623#ifndef LOC_SECTION
624#define LOC_SECTION ".debug_loc"
625#endif
626#ifndef PUBNAMES_SECTION
627#define PUBNAMES_SECTION ".debug_pubnames"
628#endif
629#ifndef STR_SECTION
630#define STR_SECTION ".debug_str"
631#endif
632
633/* Standerd ELF section names for compiled code and data. */
634#ifndef TEXT_SECTION
635#define TEXT_SECTION ".text"
636#endif
637#ifndef DATA_SECTION
638#define DATA_SECTION ".data"
639#endif
a3f97cbb
JW		 640#ifndef BSS_SECTION
641#define BSS_SECTION ".bss"
642#endif
643
644
645/* Definitions of defaults for formats and names of various special
646 (artificial) labels which may be generated within this file (when the -g
647 options is used and DWARF_DEBUGGING_INFO is in effect.
648 If necessary, these may be overridden from within the tm.h file, but
5c90448c
JM		 649 typically, overriding these defaults is unnecessary. */
650
651char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
652
a3f97cbb 653#ifndef TEXT_END_LABEL
5c90448c 654#define TEXT_END_LABEL "Letext"
a3f97cbb
JW		 655#endif
656#ifndef DATA_END_LABEL
5c90448c 657#define DATA_END_LABEL "Ledata"
a3f97cbb
JW		 658#endif
659#ifndef BSS_END_LABEL
5c90448c 660#define BSS_END_LABEL "Lebss"
a3f97cbb
JW		 661#endif
662#ifndef INSN_LABEL_FMT
5c90448c 663#define INSN_LABEL_FMT "LI%u_"
a3f97cbb 664#endif
5c90448c
JM		 665#ifndef BLOCK_BEGIN_LABEL
666#define BLOCK_BEGIN_LABEL "LBB"
a3f97cbb 667#endif
5c90448c
JM		 668#ifndef BLOCK_END_LABEL
669#define BLOCK_END_LABEL "LBE"
a3f97cbb 670#endif
5c90448c
JM		 671#ifndef BODY_BEGIN_LABEL
672#define BODY_BEGIN_LABEL "Lbb"
a3f97cbb 673#endif
5c90448c
JM		 674#ifndef BODY_END_LABEL
675#define BODY_END_LABEL "Lbe"
d291dd49 676#endif
5c90448c
JM		 677#ifndef FUNC_BEGIN_LABEL
678#define FUNC_BEGIN_LABEL "LFB"
a3f97cbb 679#endif
5c90448c
JM		 680#ifndef FUNC_END_LABEL
681#define FUNC_END_LABEL "LFE"
a3f97cbb 682#endif
5c90448c
JM		 683#ifndef LINE_CODE_LABEL
684#define LINE_CODE_LABEL "LM"
e90b62db 685#endif
5c90448c
JM		 686#ifndef SEPARATE_LINE_CODE_LABEL
687#define SEPARATE_LINE_CODE_LABEL "LSM"
a3f97cbb
JW		 688#endif
689
a3f97cbb
JW		 690/* Definitions of defaults for various types of primitive assembly language
691 output operations. These may be overridden from within the tm.h file,
692 but typically, that is unecessary. */
693#ifndef ASM_OUTPUT_SECTION
694#define ASM_OUTPUT_SECTION(FILE, SECTION) \
695 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
696#endif
697
698#ifndef ASM_OUTPUT_DWARF_DELTA2
699#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
700 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
701 assemble_name (FILE, LABEL1); \
702 fprintf (FILE, "-"); \
703 assemble_name (FILE, LABEL2); \
704 } while (0)
705#endif
706
707#ifndef ASM_OUTPUT_DWARF_DELTA4
708#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
709 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
710 assemble_name (FILE, LABEL1); \
711 fprintf (FILE, "-"); \
712 assemble_name (FILE, LABEL2); \
713 } while (0)
714#endif
715
7e23cb16
JM		 716#ifndef ASM_OUTPUT_DWARF_DELTA
717#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
718 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
719 assemble_name (FILE, LABEL1); \
720 fprintf (FILE, "-"); \
721 assemble_name (FILE, LABEL2); \
722 } while (0)
723#endif
724
725#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
726#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
727 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
728 assemble_name (FILE, LABEL1); \
729 fprintf (FILE, "-"); \
730 assemble_name (FILE, LABEL2); \
731 } while (0)
732#endif
733
a3f97cbb
JW		 734#ifndef ASM_OUTPUT_DWARF_ADDR
735#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
7e23cb16 736 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
a3f97cbb
JW		 737 assemble_name (FILE, LABEL); \
738 } while (0)
739#endif
740
741#ifndef ASM_OUTPUT_DWARF_ADDR_CONST
742#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
7e23cb16
JM		 743 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
744#endif
745
746#ifndef ASM_OUTPUT_DWARF_OFFSET
747#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
748 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
749 assemble_name (FILE, LABEL); \
750 } while (0)
a3f97cbb
JW		 751#endif
752
753#ifndef ASM_OUTPUT_DWARF_DATA1
754#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
755 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, VALUE)
756#endif
757
758#ifndef ASM_OUTPUT_DWARF_DATA2
759#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
760 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
761#endif
762
763#ifndef ASM_OUTPUT_DWARF_DATA4
764#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
765 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
766#endif
767
7e23cb16
JM		 768#ifndef ASM_OUTPUT_DWARF_DATA
769#define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
770 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
771 (unsigned long) VALUE)
772#endif
773
774#ifndef ASM_OUTPUT_DWARF_ADDR_DATA
775#define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
776 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
777 (unsigned long) VALUE)
778#endif
779
a3f97cbb
JW		 780#ifndef ASM_OUTPUT_DWARF_DATA8
781#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
782 do { \
783 if (WORDS_BIG_ENDIAN) \
784 { \
785 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
786 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
787 } \
788 else \
789 { \
790 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
791 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
792 } \
793 } while (0)
794#endif
795
796/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
797 newline is produced. When flag_verbose_asm is asserted, we add commnetary
798 at the end of the line, so we must avoid output of a newline here. */
799#ifndef ASM_OUTPUT_DWARF_STRING
800#define ASM_OUTPUT_DWARF_STRING(FILE,P) \
801 do { \
802 register int slen = strlen(P); \
803 register char *p = (P); \
804 register int i; \
805 fprintf (FILE, "\t.ascii \""); \
806 for (i = 0; i < slen; i++) \
807 { \
808 register int c = p[i]; \
809 if (c == '\"' || c == '\\') \
810 putc ('\\', FILE); \
811 if (c >= ' ' && c < 0177) \
812 putc (c, FILE); \
813 else \
814 { \
815 fprintf (FILE, "\\%o", c); \
816 } \
817 } \
818 fprintf (FILE, "\\0\""); \
819 } \
820 while (0)
821#endif
822
823/* Convert a reference to the assembler name of a C-level name. This
824 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
825 a string rather than writing to a file. */
826#ifndef ASM_NAME_TO_STRING
827#define ASM_NAME_TO_STRING(STR, NAME) \
828 do { \
829 if ((NAME)[0] == '*') \
830 strcpy (STR, NAME+1); \
831 else \
832 strcpy (STR, NAME); \
833 } \
834 while (0)
835#endif
836
c8cc5c4a 837/* The DWARF 2 CFA column which tracks the return address. Normally this
a94dbf2c
JM		 838 is the column for PC, or the first column after all of the hard
839 registers. */
c8cc5c4a 840#ifndef DWARF_FRAME_RETURN_COLUMN
a94dbf2c
JM		 841#ifdef PC_REGNUM
842#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
843#else
844#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER + 1
845#endif
c8cc5c4a
JM		 846#endif
847
848/* The mapping from gcc register number to DWARF 2 CFA column number. By
469ac993 849 default, we just provide columns for all registers. */
c8cc5c4a 850#ifndef DWARF_FRAME_REGNUM
469ac993 851#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
c8cc5c4a 852#endif
a3f97cbb
JW		 853\f
854/************************ general utility functions **************************/
855
856/* Return a pointer to a copy of the section string name 's' with all
857 attributes stripped off. */
858inline char *
859stripattributes (s)
860 register char *s;
861{
862 register char *stripped, *p;
863 stripped = xstrdup (s);
864 p = stripped;
865 while (*p && *p != ',')
866 p++;
867 *p = '\0';
868 return stripped;
869}
870
871/* Convert an integer constant expression into assembler syntax.
872 Addition and subtraction are the only arithmetic
873 that may appear in these expressions. This is an adaptation
874 of output_addr_const() in final.c. Here, the target of the
875 conversion is a string buffer. We can't use output_addr_const
876 directly, because it writes to a file. */
877static void
878addr_const_to_string (str, x)
879 char *str;
880 rtx x;
881{
882 char buf1[256];
883 char buf2[256];
884
885restart:
886 str[0] = '\0';
887 switch (GET_CODE (x))
888 {
889 case PC:
890 if (flag_pic)
891 strcat (str, ",");
892 else
893 abort ();
894 break;
895
896 case SYMBOL_REF:
897 ASM_NAME_TO_STRING (buf1, XSTR (x, 0));
898 strcat (str, buf1);
899 break;
900
901 case LABEL_REF:
902 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
903 ASM_NAME_TO_STRING (buf2, buf1);
904 strcat (str, buf2);
905 break;
906
907 case CODE_LABEL:
908 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
909 ASM_NAME_TO_STRING (buf2, buf1);
910 strcat (str, buf2);
911 break;
912
913 case CONST_INT:
914 sprintf (buf1,
915#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
916 "%d",
917#else
918 "%ld",
919#endif
920 INTVAL (x));
921 strcat (str, buf1);
922 break;
923
924 case CONST:
925 /* This used to output parentheses around the expression, but that does
926 not work on the 386 (either ATT or BSD assembler). */
927 addr_const_to_string (buf1, XEXP (x, 0));
928 strcat (str, buf1);
929 break;
930
931 case CONST_DOUBLE:
932 if (GET_MODE (x) == VOIDmode)
933 {
934 /* We can use %d if the number is one word and positive. */
935 if (CONST_DOUBLE_HIGH (x))
936 sprintf (buf1,
937#if HOST_BITS_PER_WIDE_INT == 64
938#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
939 "0x%lx%016lx",
940#else
941 "0x%x%016x",
942#endif
943#else
944#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
945 "0x%lx%08lx",
946#else
947 "0x%x%08x",
948#endif
949#endif
950 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
951 else if (CONST_DOUBLE_LOW (x) < 0)
952 sprintf (buf1,
953#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
954 "0x%x",
955#else
956 "0x%lx",
957#endif
958 CONST_DOUBLE_LOW (x));
959 else
960 sprintf (buf1,
961#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
962 "%d",
963#else
964 "%ld",
965#endif
966 CONST_DOUBLE_LOW (x));
967 strcat (str, buf1);
968 }
969 else
970 /* We can't handle floating point constants; PRINT_OPERAND must
971 handle them. */
972 output_operand_lossage ("floating constant misused");
973 break;
974
975 case PLUS:
976 /* Some assemblers need integer constants to appear last (eg masm). */
977 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
978 {
979 addr_const_to_string (buf1, XEXP (x, 1));
980 strcat (str, buf1);
981 if (INTVAL (XEXP (x, 0)) >= 0)
982 strcat (str, "+");
983 addr_const_to_string (buf1, XEXP (x, 0));
984 strcat (str, buf1);
985 }
986 else
987 {
988 addr_const_to_string (buf1, XEXP (x, 0));
989 strcat (str, buf1);
bdb669cb 990 if (INTVAL (XEXP (x, 1)) >= 0)
a3f97cbb
JW		 991 strcat (str, "+");
992 addr_const_to_string (buf1, XEXP (x, 1));
bdb669cb 993 strcat (str, buf1);
a3f97cbb
JW		 994 }
995 break;
996
997 case MINUS:
998 /* Avoid outputting things like x-x or x+5-x, since some assemblers
999 can't handle that. */
1000 x = simplify_subtraction (x);
1001 if (GET_CODE (x) != MINUS)
1002 goto restart;
1003
1004 addr_const_to_string (buf1, XEXP (x, 0));
1005 strcat (str, buf1);
1006 strcat (str, "-");
1007 if (GET_CODE (XEXP (x, 1)) == CONST_INT
1008 && INTVAL (XEXP (x, 1)) < 0)
1009 {
1010 strcat (str, ASM_OPEN_PAREN);
1011 addr_const_to_string (buf1, XEXP (x, 1));
1012 strcat (str, buf1);
1013 strcat (str, ASM_CLOSE_PAREN);
1014 }
1015 else
1016 {
1017 addr_const_to_string (buf1, XEXP (x, 1));
1018 strcat (str, buf1);
1019 }
1020 break;
1021
1022 case ZERO_EXTEND:
1023 case SIGN_EXTEND:
1024 addr_const_to_string (buf1, XEXP (x, 0));
1025 strcat (str, buf1);
1026 break;
1027
1028 default:
1029 output_operand_lossage ("invalid expression as operand");
1030 }
1031}
1032
1033/* Convert an address constant to a string, and return a pointer to
1034 a copy of the result, located on the heap. */
1035static char *
1036addr_to_string (x)
1037 rtx x;
1038{
1039 char buf[1024];
1040 addr_const_to_string (buf, x);
1041 return xstrdup (buf);
1042}
1043
1044/* Test if rtl node points to a psuedo register. */
1045inline int
1046is_pseudo_reg (rtl)
1047 register rtx rtl;
1048{
1049 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
1050 || ((GET_CODE (rtl) == SUBREG)
1051 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
1052}
1053
1054
1055/* Return a reference to a type, with its const and volatile qualifiers
1056 removed. */
1057inline tree
1058type_main_variant (type)
1059 register tree type;
1060{
1061 type = TYPE_MAIN_VARIANT (type);
1062
1063 /* There really should be only one main variant among any group of variants
1064 of a given type (and all of the MAIN_VARIANT values for all members of
1065 the group should point to that one type) but sometimes the C front-end
1066 messes this up for array types, so we work around that bug here. */
1067 if (TREE_CODE (type) == ARRAY_TYPE)
1068 {
1069 while (type != TYPE_MAIN_VARIANT (type))
1070 type = TYPE_MAIN_VARIANT (type);
1071 }
1072 return type;
1073}
1074
1075/* Return non-zero if the given type node represents a tagged type. */
1076inline int
1077is_tagged_type (type)
1078 register tree type;
1079{
1080 register enum tree_code code = TREE_CODE (type);
1081
1082 return (code == RECORD_TYPE || code == UNION_TYPE
1083 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
1084}
1085
1086/* Convert a DIE tag into its string name. */
1087static char *
1088dwarf_tag_name (tag)
1089 register unsigned tag;
1090{
1091 switch (tag)
1092 {
1093 case DW_TAG_padding:
1094 return "DW_TAG_padding";
1095 case DW_TAG_array_type:
1096 return "DW_TAG_array_type";
1097 case DW_TAG_class_type:
1098 return "DW_TAG_class_type";
1099 case DW_TAG_entry_point:
1100 return "DW_TAG_entry_point";
1101 case DW_TAG_enumeration_type:
1102 return "DW_TAG_enumeration_type";
1103 case DW_TAG_formal_parameter:
1104 return "DW_TAG_formal_parameter";
1105 case DW_TAG_imported_declaration:
1106 return "DW_TAG_imported_declaration";
1107 case DW_TAG_label:
1108 return "DW_TAG_label";
1109 case DW_TAG_lexical_block:
1110 return "DW_TAG_lexical_block";
1111 case DW_TAG_member:
1112 return "DW_TAG_member";
1113 case DW_TAG_pointer_type:
1114 return "DW_TAG_pointer_type";
1115 case DW_TAG_reference_type:
1116 return "DW_TAG_reference_type";
1117 case DW_TAG_compile_unit:
1118 return "DW_TAG_compile_unit";
1119 case DW_TAG_string_type:
1120 return "DW_TAG_string_type";
1121 case DW_TAG_structure_type:
1122 return "DW_TAG_structure_type";
1123 case DW_TAG_subroutine_type:
1124 return "DW_TAG_subroutine_type";
1125 case DW_TAG_typedef:
1126 return "DW_TAG_typedef";
1127 case DW_TAG_union_type:
1128 return "DW_TAG_union_type";
1129 case DW_TAG_unspecified_parameters:
1130 return "DW_TAG_unspecified_parameters";
1131 case DW_TAG_variant:
1132 return "DW_TAG_variant";
1133 case DW_TAG_common_block:
1134 return "DW_TAG_common_block";
1135 case DW_TAG_common_inclusion:
1136 return "DW_TAG_common_inclusion";
1137 case DW_TAG_inheritance:
1138 return "DW_TAG_inheritance";
1139 case DW_TAG_inlined_subroutine:
1140 return "DW_TAG_inlined_subroutine";
1141 case DW_TAG_module:
1142 return "DW_TAG_module";
1143 case DW_TAG_ptr_to_member_type:
1144 return "DW_TAG_ptr_to_member_type";
1145 case DW_TAG_set_type:
1146 return "DW_TAG_set_type";
1147 case DW_TAG_subrange_type:
1148 return "DW_TAG_subrange_type";
1149 case DW_TAG_with_stmt:
1150 return "DW_TAG_with_stmt";
1151 case DW_TAG_access_declaration:
1152 return "DW_TAG_access_declaration";
1153 case DW_TAG_base_type:
1154 return "DW_TAG_base_type";
1155 case DW_TAG_catch_block:
1156 return "DW_TAG_catch_block";
1157 case DW_TAG_const_type:
1158 return "DW_TAG_const_type";
1159 case DW_TAG_constant:
1160 return "DW_TAG_constant";
1161 case DW_TAG_enumerator:
1162 return "DW_TAG_enumerator";
1163 case DW_TAG_file_type:
1164 return "DW_TAG_file_type";
1165 case DW_TAG_friend:
1166 return "DW_TAG_friend";
1167 case DW_TAG_namelist:
1168 return "DW_TAG_namelist";
1169 case DW_TAG_namelist_item:
1170 return "DW_TAG_namelist_item";
1171 case DW_TAG_packed_type:
1172 return "DW_TAG_packed_type";
1173 case DW_TAG_subprogram:
1174 return "DW_TAG_subprogram";
1175 case DW_TAG_template_type_param:
1176 return "DW_TAG_template_type_param";
1177 case DW_TAG_template_value_param:
1178 return "DW_TAG_template_value_param";
1179 case DW_TAG_thrown_type:
1180 return "DW_TAG_thrown_type";
1181 case DW_TAG_try_block:
1182 return "DW_TAG_try_block";
1183 case DW_TAG_variant_part:
1184 return "DW_TAG_variant_part";
1185 case DW_TAG_variable:
1186 return "DW_TAG_variable";
1187 case DW_TAG_volatile_type:
1188 return "DW_TAG_volatile_type";
1189 case DW_TAG_MIPS_loop:
1190 return "DW_TAG_MIPS_loop";
1191 case DW_TAG_format_label:
1192 return "DW_TAG_format_label";
1193 case DW_TAG_function_template:
1194 return "DW_TAG_function_template";
1195 case DW_TAG_class_template:
1196 return "DW_TAG_class_template";
1197 default:
1198 return "DW_TAG_<unknown>";
1199 }
1200}
1201
1202/* Convert a DWARF attribute code into its string name. */
1203static char *
1204dwarf_attr_name (attr)
1205 register unsigned attr;
1206{
1207 switch (attr)
1208 {
1209 case DW_AT_sibling:
1210 return "DW_AT_sibling";
1211 case DW_AT_location:
1212 return "DW_AT_location";
1213 case DW_AT_name:
1214 return "DW_AT_name";
1215 case DW_AT_ordering:
1216 return "DW_AT_ordering";
1217 case DW_AT_subscr_data:
1218 return "DW_AT_subscr_data";
1219 case DW_AT_byte_size:
1220 return "DW_AT_byte_size";
1221 case DW_AT_bit_offset:
1222 return "DW_AT_bit_offset";
1223 case DW_AT_bit_size:
1224 return "DW_AT_bit_size";
1225 case DW_AT_element_list:
1226 return "DW_AT_element_list";
1227 case DW_AT_stmt_list:
1228 return "DW_AT_stmt_list";
1229 case DW_AT_low_pc:
1230 return "DW_AT_low_pc";
1231 case DW_AT_high_pc:
1232 return "DW_AT_high_pc";
1233 case DW_AT_language:
1234 return "DW_AT_language";
1235 case DW_AT_member:
1236 return "DW_AT_member";
1237 case DW_AT_discr:
1238 return "DW_AT_discr";
1239 case DW_AT_discr_value:
1240 return "DW_AT_discr_value";
1241 case DW_AT_visibility:
1242 return "DW_AT_visibility";
1243 case DW_AT_import:
1244 return "DW_AT_import";
1245 case DW_AT_string_length:
1246 return "DW_AT_string_length";
1247 case DW_AT_common_reference:
1248 return "DW_AT_common_reference";
1249 case DW_AT_comp_dir:
1250 return "DW_AT_comp_dir";
1251 case DW_AT_const_value:
1252 return "DW_AT_const_value";
1253 case DW_AT_containing_type:
1254 return "DW_AT_containing_type";
1255 case DW_AT_default_value:
1256 return "DW_AT_default_value";
1257 case DW_AT_inline:
1258 return "DW_AT_inline";
1259 case DW_AT_is_optional:
1260 return "DW_AT_is_optional";
1261 case DW_AT_lower_bound:
1262 return "DW_AT_lower_bound";
1263 case DW_AT_producer:
1264 return "DW_AT_producer";
1265 case DW_AT_prototyped:
1266 return "DW_AT_prototyped";
1267 case DW_AT_return_addr:
1268 return "DW_AT_return_addr";
1269 case DW_AT_start_scope:
1270 return "DW_AT_start_scope";
1271 case DW_AT_stride_size:
1272 return "DW_AT_stride_size";
1273 case DW_AT_upper_bound:
1274 return "DW_AT_upper_bound";
1275 case DW_AT_abstract_origin:
1276 return "DW_AT_abstract_origin";
1277 case DW_AT_accessibility:
1278 return "DW_AT_accessibility";
1279 case DW_AT_address_class:
1280 return "DW_AT_address_class";
1281 case DW_AT_artificial:
1282 return "DW_AT_artificial";
1283 case DW_AT_base_types:
1284 return "DW_AT_base_types";
1285 case DW_AT_calling_convention:
1286 return "DW_AT_calling_convention";
1287 case DW_AT_count:
1288 return "DW_AT_count";
1289 case DW_AT_data_member_location:
1290 return "DW_AT_data_member_location";
1291 case DW_AT_decl_column:
1292 return "DW_AT_decl_column";
1293 case DW_AT_decl_file:
1294 return "DW_AT_decl_file";
1295 case DW_AT_decl_line:
1296 return "DW_AT_decl_line";
1297 case DW_AT_declaration:
1298 return "DW_AT_declaration";
1299 case DW_AT_discr_list:
1300 return "DW_AT_discr_list";
1301 case DW_AT_encoding:
1302 return "DW_AT_encoding";
1303 case DW_AT_external:
1304 return "DW_AT_external";
1305 case DW_AT_frame_base:
1306 return "DW_AT_frame_base";
1307 case DW_AT_friend:
1308 return "DW_AT_friend";
1309 case DW_AT_identifier_case:
1310 return "DW_AT_identifier_case";
1311 case DW_AT_macro_info:
1312 return "DW_AT_macro_info";
1313 case DW_AT_namelist_items:
1314 return "DW_AT_namelist_items";
1315 case DW_AT_priority:
1316 return "DW_AT_priority";
1317 case DW_AT_segment:
1318 return "DW_AT_segment";
1319 case DW_AT_specification:
1320 return "DW_AT_specification";
1321 case DW_AT_static_link:
1322 return "DW_AT_static_link";
1323 case DW_AT_type:
1324 return "DW_AT_type";
1325 case DW_AT_use_location:
1326 return "DW_AT_use_location";
1327 case DW_AT_variable_parameter:
1328 return "DW_AT_variable_parameter";
1329 case DW_AT_virtuality:
1330 return "DW_AT_virtuality";
1331 case DW_AT_vtable_elem_location:
1332 return "DW_AT_vtable_elem_location";
1333
a3f97cbb
JW		 1334 case DW_AT_MIPS_fde:
1335 return "DW_AT_MIPS_fde";
1336 case DW_AT_MIPS_loop_begin:
1337 return "DW_AT_MIPS_loop_begin";
1338 case DW_AT_MIPS_tail_loop_begin:
1339 return "DW_AT_MIPS_tail_loop_begin";
1340 case DW_AT_MIPS_epilog_begin:
1341 return "DW_AT_MIPS_epilog_begin";
1342 case DW_AT_MIPS_loop_unroll_factor:
1343 return "DW_AT_MIPS_loop_unroll_factor";
1344 case DW_AT_MIPS_software_pipeline_depth:
1345 return "DW_AT_MIPS_software_pipeline_depth";
1346 case DW_AT_MIPS_linkage_name:
1347 return "DW_AT_MIPS_linkage_name";
7e23cb16
JM		 1348 case DW_AT_MIPS_stride:
1349 return "DW_AT_MIPS_stride";
1350 case DW_AT_MIPS_abstract_name:
1351 return "DW_AT_MIPS_abstract_name";
1352 case DW_AT_MIPS_clone_origin:
1353 return "DW_AT_MIPS_clone_origin";
1354 case DW_AT_MIPS_has_inlines:
1355 return "DW_AT_MIPS_has_inlines";
a3f97cbb
JW		 1356
1357 case DW_AT_sf_names:
1358 return "DW_AT_sf_names";
1359 case DW_AT_src_info:
1360 return "DW_AT_src_info";
1361 case DW_AT_mac_info:
1362 return "DW_AT_mac_info";
1363 case DW_AT_src_coords:
1364 return "DW_AT_src_coords";
1365 case DW_AT_body_begin:
1366 return "DW_AT_body_begin";
1367 case DW_AT_body_end:
1368 return "DW_AT_body_end";
1369 default:
1370 return "DW_AT_<unknown>";
1371 }
1372}
1373
1374/* Convert a DWARF value form code into its string name. */
1375static char *
1376dwarf_form_name (form)
1377 register unsigned form;
1378{
1379 switch (form)
1380 {
1381 case DW_FORM_addr:
1382 return "DW_FORM_addr";
1383 case DW_FORM_block2:
1384 return "DW_FORM_block2";
1385 case DW_FORM_block4:
1386 return "DW_FORM_block4";
1387 case DW_FORM_data2:
1388 return "DW_FORM_data2";
1389 case DW_FORM_data4:
1390 return "DW_FORM_data4";
1391 case DW_FORM_data8:
1392 return "DW_FORM_data8";
1393 case DW_FORM_string:
1394 return "DW_FORM_string";
1395 case DW_FORM_block:
1396 return "DW_FORM_block";
1397 case DW_FORM_block1:
1398 return "DW_FORM_block1";
1399 case DW_FORM_data1:
1400 return "DW_FORM_data1";
1401 case DW_FORM_flag:
1402 return "DW_FORM_flag";
1403 case DW_FORM_sdata:
1404 return "DW_FORM_sdata";
1405 case DW_FORM_strp:
1406 return "DW_FORM_strp";
1407 case DW_FORM_udata:
1408 return "DW_FORM_udata";
1409 case DW_FORM_ref_addr:
1410 return "DW_FORM_ref_addr";
1411 case DW_FORM_ref1:
1412 return "DW_FORM_ref1";
1413 case DW_FORM_ref2:
1414 return "DW_FORM_ref2";
1415 case DW_FORM_ref4:
1416 return "DW_FORM_ref4";
1417 case DW_FORM_ref8:
1418 return "DW_FORM_ref8";
1419 case DW_FORM_ref_udata:
1420 return "DW_FORM_ref_udata";
1421 case DW_FORM_indirect:
1422 return "DW_FORM_indirect";
1423 default:
1424 return "DW_FORM_<unknown>";
1425 }
1426}
1427
1428/* Convert a DWARF stack opcode into its string name. */
1429static char *
1430dwarf_stack_op_name (op)
1431 register unsigned op;
1432{
1433 switch (op)
1434 {
1435 case DW_OP_addr:
1436 return "DW_OP_addr";
1437 case DW_OP_deref:
1438 return "DW_OP_deref";
1439 case DW_OP_const1u:
1440 return "DW_OP_const1u";
1441 case DW_OP_const1s:
1442 return "DW_OP_const1s";
1443 case DW_OP_const2u:
1444 return "DW_OP_const2u";
1445 case DW_OP_const2s:
1446 return "DW_OP_const2s";
1447 case DW_OP_const4u:
1448 return "DW_OP_const4u";
1449 case DW_OP_const4s:
1450 return "DW_OP_const4s";
1451 case DW_OP_const8u:
1452 return "DW_OP_const8u";
1453 case DW_OP_const8s:
1454 return "DW_OP_const8s";
1455 case DW_OP_constu:
1456 return "DW_OP_constu";
1457 case DW_OP_consts:
1458 return "DW_OP_consts";
1459 case DW_OP_dup:
1460 return "DW_OP_dup";
1461 case DW_OP_drop:
1462 return "DW_OP_drop";
1463 case DW_OP_over:
1464 return "DW_OP_over";
1465 case DW_OP_pick:
1466 return "DW_OP_pick";
1467 case DW_OP_swap:
1468 return "DW_OP_swap";
1469 case DW_OP_rot:
1470 return "DW_OP_rot";
1471 case DW_OP_xderef:
1472 return "DW_OP_xderef";
1473 case DW_OP_abs:
1474 return "DW_OP_abs";
1475 case DW_OP_and:
1476 return "DW_OP_and";
1477 case DW_OP_div:
1478 return "DW_OP_div";
1479 case DW_OP_minus:
1480 return "DW_OP_minus";
1481 case DW_OP_mod:
1482 return "DW_OP_mod";
1483 case DW_OP_mul:
1484 return "DW_OP_mul";
1485 case DW_OP_neg:
1486 return "DW_OP_neg";
1487 case DW_OP_not:
1488 return "DW_OP_not";
1489 case DW_OP_or:
1490 return "DW_OP_or";
1491 case DW_OP_plus:
1492 return "DW_OP_plus";
1493 case DW_OP_plus_uconst:
1494 return "DW_OP_plus_uconst";
1495 case DW_OP_shl:
1496 return "DW_OP_shl";
1497 case DW_OP_shr:
1498 return "DW_OP_shr";
1499 case DW_OP_shra:
1500 return "DW_OP_shra";
1501 case DW_OP_xor:
1502 return "DW_OP_xor";
1503 case DW_OP_bra:
1504 return "DW_OP_bra";
1505 case DW_OP_eq:
1506 return "DW_OP_eq";
1507 case DW_OP_ge:
1508 return "DW_OP_ge";
1509 case DW_OP_gt:
1510 return "DW_OP_gt";
1511 case DW_OP_le:
1512 return "DW_OP_le";
1513 case DW_OP_lt:
1514 return "DW_OP_lt";
1515 case DW_OP_ne:
1516 return "DW_OP_ne";
1517 case DW_OP_skip:
1518 return "DW_OP_skip";
1519 case DW_OP_lit0:
1520 return "DW_OP_lit0";
1521 case DW_OP_lit1:
1522 return "DW_OP_lit1";
1523 case DW_OP_lit2:
1524 return "DW_OP_lit2";
1525 case DW_OP_lit3:
1526 return "DW_OP_lit3";
1527 case DW_OP_lit4:
1528 return "DW_OP_lit4";
1529 case DW_OP_lit5:
1530 return "DW_OP_lit5";
1531 case DW_OP_lit6:
1532 return "DW_OP_lit6";
1533 case DW_OP_lit7:
1534 return "DW_OP_lit7";
1535 case DW_OP_lit8:
1536 return "DW_OP_lit8";
1537 case DW_OP_lit9:
1538 return "DW_OP_lit9";
1539 case DW_OP_lit10:
1540 return "DW_OP_lit10";
1541 case DW_OP_lit11:
1542 return "DW_OP_lit11";
1543 case DW_OP_lit12:
1544 return "DW_OP_lit12";
1545 case DW_OP_lit13:
1546 return "DW_OP_lit13";
1547 case DW_OP_lit14:
1548 return "DW_OP_lit14";
1549 case DW_OP_lit15:
1550 return "DW_OP_lit15";
1551 case DW_OP_lit16:
1552 return "DW_OP_lit16";
1553 case DW_OP_lit17:
1554 return "DW_OP_lit17";
1555 case DW_OP_lit18:
1556 return "DW_OP_lit18";
1557 case DW_OP_lit19:
1558 return "DW_OP_lit19";
1559 case DW_OP_lit20:
1560 return "DW_OP_lit20";
1561 case DW_OP_lit21:
1562 return "DW_OP_lit21";
1563 case DW_OP_lit22:
1564 return "DW_OP_lit22";
1565 case DW_OP_lit23:
1566 return "DW_OP_lit23";
1567 case DW_OP_lit24:
1568 return "DW_OP_lit24";
1569 case DW_OP_lit25:
1570 return "DW_OP_lit25";
1571 case DW_OP_lit26:
1572 return "DW_OP_lit26";
1573 case DW_OP_lit27:
1574 return "DW_OP_lit27";
1575 case DW_OP_lit28:
1576 return "DW_OP_lit28";
1577 case DW_OP_lit29:
1578 return "DW_OP_lit29";
1579 case DW_OP_lit30:
1580 return "DW_OP_lit30";
1581 case DW_OP_lit31:
1582 return "DW_OP_lit31";
1583 case DW_OP_reg0:
1584 return "DW_OP_reg0";
1585 case DW_OP_reg1:
1586 return "DW_OP_reg1";
1587 case DW_OP_reg2:
1588 return "DW_OP_reg2";
1589 case DW_OP_reg3:
1590 return "DW_OP_reg3";
1591 case DW_OP_reg4:
1592 return "DW_OP_reg4";
1593 case DW_OP_reg5:
1594 return "DW_OP_reg5";
1595 case DW_OP_reg6:
1596 return "DW_OP_reg6";
1597 case DW_OP_reg7:
1598 return "DW_OP_reg7";
1599 case DW_OP_reg8:
1600 return "DW_OP_reg8";
1601 case DW_OP_reg9:
1602 return "DW_OP_reg9";
1603 case DW_OP_reg10:
1604 return "DW_OP_reg10";
1605 case DW_OP_reg11:
1606 return "DW_OP_reg11";
1607 case DW_OP_reg12:
1608 return "DW_OP_reg12";
1609 case DW_OP_reg13:
1610 return "DW_OP_reg13";
1611 case DW_OP_reg14:
1612 return "DW_OP_reg14";
1613 case DW_OP_reg15:
1614 return "DW_OP_reg15";
1615 case DW_OP_reg16:
1616 return "DW_OP_reg16";
1617 case DW_OP_reg17:
1618 return "DW_OP_reg17";
1619 case DW_OP_reg18:
1620 return "DW_OP_reg18";
1621 case DW_OP_reg19:
1622 return "DW_OP_reg19";
1623 case DW_OP_reg20:
1624 return "DW_OP_reg20";
1625 case DW_OP_reg21:
1626 return "DW_OP_reg21";
1627 case DW_OP_reg22:
1628 return "DW_OP_reg22";
1629 case DW_OP_reg23:
1630 return "DW_OP_reg23";
1631 case DW_OP_reg24:
1632 return "DW_OP_reg24";
1633 case DW_OP_reg25:
1634 return "DW_OP_reg25";
1635 case DW_OP_reg26:
1636 return "DW_OP_reg26";
1637 case DW_OP_reg27:
1638 return "DW_OP_reg27";
1639 case DW_OP_reg28:
1640 return "DW_OP_reg28";
1641 case DW_OP_reg29:
1642 return "DW_OP_reg29";
1643 case DW_OP_reg30:
1644 return "DW_OP_reg30";
1645 case DW_OP_reg31:
1646 return "DW_OP_reg31";
1647 case DW_OP_breg0:
1648 return "DW_OP_breg0";
1649 case DW_OP_breg1:
1650 return "DW_OP_breg1";
1651 case DW_OP_breg2:
1652 return "DW_OP_breg2";
1653 case DW_OP_breg3:
1654 return "DW_OP_breg3";
1655 case DW_OP_breg4:
1656 return "DW_OP_breg4";
1657 case DW_OP_breg5:
1658 return "DW_OP_breg5";
1659 case DW_OP_breg6:
1660 return "DW_OP_breg6";
1661 case DW_OP_breg7:
1662 return "DW_OP_breg7";
1663 case DW_OP_breg8:
1664 return "DW_OP_breg8";
1665 case DW_OP_breg9:
1666 return "DW_OP_breg9";
1667 case DW_OP_breg10:
1668 return "DW_OP_breg10";
1669 case DW_OP_breg11:
1670 return "DW_OP_breg11";
1671 case DW_OP_breg12:
1672 return "DW_OP_breg12";
1673 case DW_OP_breg13:
1674 return "DW_OP_breg13";
1675 case DW_OP_breg14:
1676 return "DW_OP_breg14";
1677 case DW_OP_breg15:
1678 return "DW_OP_breg15";
1679 case DW_OP_breg16:
1680 return "DW_OP_breg16";
1681 case DW_OP_breg17:
1682 return "DW_OP_breg17";
1683 case DW_OP_breg18:
1684 return "DW_OP_breg18";
1685 case DW_OP_breg19:
1686 return "DW_OP_breg19";
1687 case DW_OP_breg20:
1688 return "DW_OP_breg20";
1689 case DW_OP_breg21:
1690 return "DW_OP_breg21";
1691 case DW_OP_breg22:
1692 return "DW_OP_breg22";
1693 case DW_OP_breg23:
1694 return "DW_OP_breg23";
1695 case DW_OP_breg24:
1696 return "DW_OP_breg24";
1697 case DW_OP_breg25:
1698 return "DW_OP_breg25";
1699 case DW_OP_breg26:
1700 return "DW_OP_breg26";
1701 case DW_OP_breg27:
1702 return "DW_OP_breg27";
1703 case DW_OP_breg28:
1704 return "DW_OP_breg28";
1705 case DW_OP_breg29:
1706 return "DW_OP_breg29";
1707 case DW_OP_breg30:
1708 return "DW_OP_breg30";
1709 case DW_OP_breg31:
1710 return "DW_OP_breg31";
1711 case DW_OP_regx:
1712 return "DW_OP_regx";
1713 case DW_OP_fbreg:
1714 return "DW_OP_fbreg";
1715 case DW_OP_bregx:
1716 return "DW_OP_bregx";
1717 case DW_OP_piece:
1718 return "DW_OP_piece";
1719 case DW_OP_deref_size:
1720 return "DW_OP_deref_size";
1721 case DW_OP_xderef_size:
1722 return "DW_OP_xderef_size";
1723 case DW_OP_nop:
1724 return "DW_OP_nop";
1725 default:
1726 return "OP_<unknown>";
1727 }
1728}
1729
1730/* Convert a DWARF type code into its string name. */
1731static char *
1732dwarf_type_encoding_name (enc)
1733 register unsigned enc;
1734{
1735 switch (enc)
1736 {
1737 case DW_ATE_address:
1738 return "DW_ATE_address";
1739 case DW_ATE_boolean:
1740 return "DW_ATE_boolean";
1741 case DW_ATE_complex_float:
1742 return "DW_ATE_complex_float";
1743 case DW_ATE_float:
1744 return "DW_ATE_float";
1745 case DW_ATE_signed:
1746 return "DW_ATE_signed";
1747 case DW_ATE_signed_char:
1748 return "DW_ATE_signed_char";
1749 case DW_ATE_unsigned:
1750 return "DW_ATE_unsigned";
1751 case DW_ATE_unsigned_char:
1752 return "DW_ATE_unsigned_char";
1753 default:
1754 return "DW_ATE_<unknown>";
1755 }
1756}
1757
1758/* Convert a DWARF call frame info. operation to its string name */
1759static char *
1760dwarf_cfi_name (cfi_opc)
1761 register unsigned cfi_opc;
1762{
1763 switch (cfi_opc)
1764 {
1765 case DW_CFA_advance_loc:
1766 return "DW_CFA_advance_loc";
1767 case DW_CFA_offset:
1768 return "DW_CFA_offset";
1769 case DW_CFA_restore:
1770 return "DW_CFA_restore";
1771 case DW_CFA_nop:
1772 return "DW_CFA_nop";
1773 case DW_CFA_set_loc:
1774 return "DW_CFA_set_loc";
1775 case DW_CFA_advance_loc1:
1776 return "DW_CFA_advance_loc1";
1777 case DW_CFA_advance_loc2:
1778 return "DW_CFA_advance_loc2";
1779 case DW_CFA_advance_loc4:
1780 return "DW_CFA_advance_loc4";
1781 case DW_CFA_offset_extended:
1782 return "DW_CFA_offset_extended";
1783 case DW_CFA_restore_extended:
1784 return "DW_CFA_restore_extended";
1785 case DW_CFA_undefined:
1786 return "DW_CFA_undefined";
1787 case DW_CFA_same_value:
1788 return "DW_CFA_same_value";
1789 case DW_CFA_register:
1790 return "DW_CFA_register";
1791 case DW_CFA_remember_state:
1792 return "DW_CFA_remember_state";
1793 case DW_CFA_restore_state:
1794 return "DW_CFA_restore_state";
1795 case DW_CFA_def_cfa:
1796 return "DW_CFA_def_cfa";
1797 case DW_CFA_def_cfa_register:
1798 return "DW_CFA_def_cfa_register";
1799 case DW_CFA_def_cfa_offset:
1800 return "DW_CFA_def_cfa_offset";
1801 /* SGI/MIPS specific */
1802 case DW_CFA_MIPS_advance_loc8:
1803 return "DW_CFA_MIPS_advance_loc8";
1804 default:
1805 return "DW_CFA_<unknown>";
1806 }
1807}
1808\f
1809/* Determine the "ultimate origin" of a decl. The decl may be an inlined
1810 instance of an inlined instance of a decl which is local to an inline
1811 function, so we have to trace all of the way back through the origin chain
1812 to find out what sort of node actually served as the original seed for the
1813 given block. */
1814static tree
1815decl_ultimate_origin (decl)
1816 register tree decl;
1817{
1818 register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
1819
1820 if (immediate_origin == NULL)
1821 return NULL;
1822 else
1823 {
1824 register tree ret_val;
1825 register tree lookahead = immediate_origin;
1826
1827 do
1828 {
1829 ret_val = lookahead;
1830 lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
1831 }
1832 while (lookahead != NULL && lookahead != ret_val);
1833 return ret_val;
1834 }
1835}
1836
1837/* Determine the "ultimate origin" of a block. The block may be an inlined
1838 instance of an inlined instance of a block which is local to an inline
1839 function, so we have to trace all of the way back through the origin chain
1840 to find out what sort of node actually served as the original seed for the
1841 given block. */
1842static tree
1843block_ultimate_origin (block)
1844 register tree block;
1845{
1846 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
1847
1848 if (immediate_origin == NULL)
1849 return NULL;
1850 else
1851 {
1852 register tree ret_val;
1853 register tree lookahead = immediate_origin;
1854
1855 do
1856 {
1857 ret_val = lookahead;
1858 lookahead = (TREE_CODE (ret_val) == BLOCK)
1859 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
1860 : NULL;
1861 }
1862 while (lookahead != NULL && lookahead != ret_val);
1863 return ret_val;
1864 }
1865}
bdb669cb
JM		 1866
1867/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
1868 of a virtual function may refer to a base class, so we check the 'this'
1869 parameter. */
1870
a94dbf2c 1871static tree
bdb669cb
JM		 1872decl_class_context (decl)
1873 tree decl;
1874{
1875 tree context = NULL_TREE;
a94dbf2c 1876 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
bdb669cb
JM		 1877 context = DECL_CONTEXT (decl);
1878 else
1879 context = TYPE_MAIN_VARIANT
1880 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
1881
1882 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
1883 context = NULL_TREE;
1884
1885 return context;
1886}
a3f97cbb
JW		 1887\f
1888/**************** DIE internal representation constturction *******************/
1889
1890/* Add an attribute/value pair to a DIE */
1891inline void
1892add_dwarf_attr (die, attr)
1893 register dw_die_ref die;
1894 register dw_attr_ref attr;
1895{
1896 if (die != NULL && attr != NULL)
1897 {
1898 if (die->die_attr == NULL)
1899 {
1900 die->die_attr = attr;
1901 die->die_attr_last = attr;
1902 }
1903 else
1904 {
1905 die->die_attr_last->dw_attr_next = attr;
1906 die->die_attr_last = attr;
1907 }
1908 }
1909}
1910
1911/* Add a flag value attribute to a DIE. */
1912inline void
1913add_AT_flag (die, attr_kind, flag)
1914 register dw_die_ref die;
1915 register enum dwarf_attribute attr_kind;
1916 register unsigned flag;
1917{
1918 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1919 if (attr != NULL)
1920 {
1921 attr->dw_attr_next = NULL;
1922 attr->dw_attr = attr_kind;
1923 attr->dw_attr_val.val_class = dw_val_class_flag;
1924 attr->dw_attr_val.v.val_flag = flag;
1925 add_dwarf_attr (die, attr);
1926 }
1927}
1928
1929/* Add a signed integer attribute value to a DIE. */
1930inline void
1931add_AT_int (die, attr_kind, int_val)
1932 register dw_die_ref die;
1933 register enum dwarf_attribute attr_kind;
1934 register long int int_val;
1935{
1936 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1937 if (attr != NULL)
1938 {
1939 attr->dw_attr_next = NULL;
1940 attr->dw_attr = attr_kind;
1941 attr->dw_attr_val.val_class = dw_val_class_const;
1942 attr->dw_attr_val.v.val_int = int_val;
1943 add_dwarf_attr (die, attr);
1944 }
1945}
1946
1947/* Add an unsigned integer attribute value to a DIE. */
1948inline void
1949add_AT_unsigned (die, attr_kind, unsigned_val)
1950 register dw_die_ref die;
1951 register enum dwarf_attribute attr_kind;
1952 register unsigned long unsigned_val;
1953{
1954 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1955 if (attr != NULL)
1956 {
1957 attr->dw_attr_next = NULL;
1958 attr->dw_attr = attr_kind;
1959 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
1960 attr->dw_attr_val.v.val_unsigned = unsigned_val;
1961 add_dwarf_attr (die, attr);
1962 }
1963}
1964
1965/* Add an unsigned double integer attribute value to a DIE. */
1966inline void
469ac993 1967add_AT_long_long (die, attr_kind, val_hi, val_low)
a3f97cbb
JW		 1968 register dw_die_ref die;
1969 register enum dwarf_attribute attr_kind;
1970 register unsigned long val_hi;
1971 register unsigned long val_low;
1972{
1973 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1974 if (attr != NULL)
1975 {
1976 attr->dw_attr_next = NULL;
1977 attr->dw_attr = attr_kind;
469ac993
JM		 1978 attr->dw_attr_val.val_class = dw_val_class_long_long;
1979 attr->dw_attr_val.v.val_long_long.hi = val_hi;
1980 attr->dw_attr_val.v.val_long_long.low = val_low;
1981 add_dwarf_attr (die, attr);
1982 }
1983}
1984
1985/* Add a floating point attribute value to a DIE and return it. */
1986inline void
1987add_AT_float (die, attr_kind, length, array)
1988 register dw_die_ref die;
1989 register enum dwarf_attribute attr_kind;
1990 register unsigned length;
1991 register long *array;
1992{
1993 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1994 if (attr != NULL)
1995 {
1996 attr->dw_attr_next = NULL;
1997 attr->dw_attr = attr_kind;
1998 attr->dw_attr_val.val_class = dw_val_class_float;
1999 attr->dw_attr_val.v.val_float.length = length;
2000 attr->dw_attr_val.v.val_float.array = array;
a3f97cbb
JW		 2001 add_dwarf_attr (die, attr);
2002 }
2003}
2004
2005/* Add a string attribute value to a DIE. */
2006inline void
2007add_AT_string (die, attr_kind, str)
2008 register dw_die_ref die;
2009 register enum dwarf_attribute attr_kind;
2010 register char *str;
2011{
2012 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2013 if (attr != NULL)
2014 {
2015 attr->dw_attr_next = NULL;
2016 attr->dw_attr = attr_kind;
2017 attr->dw_attr_val.val_class = dw_val_class_str;
2018 attr->dw_attr_val.v.val_str = xstrdup (str);
2019 add_dwarf_attr (die, attr);
2020 }
2021}
2022
2023/* Add a DIE reference attribute value to a DIE. */
2024inline void
2025add_AT_die_ref (die, attr_kind, targ_die)
2026 register dw_die_ref die;
2027 register enum dwarf_attribute attr_kind;
2028 register dw_die_ref targ_die;
2029{
2030 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2031 if (attr != NULL)
2032 {
2033 attr->dw_attr_next = NULL;
2034 attr->dw_attr = attr_kind;
2035 attr->dw_attr_val.val_class = dw_val_class_die_ref;
2036 attr->dw_attr_val.v.val_die_ref = targ_die;
2037 add_dwarf_attr (die, attr);
2038 }
2039}
2040
2041/* Add an FDE reference attribute value to a DIE. */
2042inline void
2043add_AT_fde_ref (die, attr_kind, targ_fde)
2044 register dw_die_ref die;
2045 register enum dwarf_attribute attr_kind;
2046 register unsigned targ_fde;
2047{
2048 register dw_attr_ref attr;
2049
2050 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2051 if (attr != NULL)
2052 {
2053 attr->dw_attr_next = NULL;
2054 attr->dw_attr = attr_kind;
2055 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
2056 attr->dw_attr_val.v.val_fde_index = targ_fde;
2057 add_dwarf_attr (die, attr);
2058 }
2059}
2060
2061/* Add a location description attribute value to a DIE. */
2062inline void
2063add_AT_loc (die, attr_kind, loc)
2064 register dw_die_ref die;
2065 register enum dwarf_attribute attr_kind;
2066 register dw_loc_descr_ref loc;
2067{
2068 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2069 if (attr != NULL)
2070 {
2071 attr->dw_attr_next = NULL;
2072 attr->dw_attr = attr_kind;
2073 attr->dw_attr_val.val_class = dw_val_class_loc;
2074 attr->dw_attr_val.v.val_loc = loc;
2075 add_dwarf_attr (die, attr);
2076 }
2077}
2078
2079/* Add an address constant attribute value to a DIE. */
2080inline void
2081add_AT_addr (die, attr_kind, addr)
2082 register dw_die_ref die;
2083 register enum dwarf_attribute attr_kind;
2084 char *addr;
2085{
2086 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2087 if (attr != NULL)
2088 {
2089 attr->dw_attr_next = NULL;
2090 attr->dw_attr = attr_kind;
2091 attr->dw_attr_val.val_class = dw_val_class_addr;
2092 attr->dw_attr_val.v.val_addr = addr;
2093 add_dwarf_attr (die, attr);
2094 }
2095}
2096
2097/* Add a label identifier attribute value to a DIE. */
2098inline void
2099add_AT_lbl_id (die, attr_kind, lbl_id)
2100 register dw_die_ref die;
2101 register enum dwarf_attribute attr_kind;
2102 register char *lbl_id;
2103{
2104 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2105 if (attr != NULL)
2106 {
2107 attr->dw_attr_next = NULL;
2108 attr->dw_attr = attr_kind;
2109 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
2110 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
2111 add_dwarf_attr (die, attr);
2112 }
2113}
2114
2115/* Add a section offset attribute value to a DIE. */
2116inline void
2117add_AT_section_offset (die, attr_kind, section)
2118 register dw_die_ref die;
2119 register enum dwarf_attribute attr_kind;
2120 register char *section;
2121{
2122 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2123 if (attr != NULL)
2124 {
2125 attr->dw_attr_next = NULL;
2126 attr->dw_attr = attr_kind;
2127 attr->dw_attr_val.val_class = dw_val_class_section_offset;
2128 attr->dw_attr_val.v.val_section = section;
2129 add_dwarf_attr (die, attr);
2130 }
2131}
2132
a3f97cbb
JW		 2133/* Test if die refers to an external subroutine. */
2134inline int
2135is_extern_subr_die (die)
2136 register dw_die_ref die;
2137{
2138 register dw_attr_ref a;
2139 register int is_subr = FALSE;
2140 register int is_extern = FALSE;
2141 if (die != NULL && die->die_tag == DW_TAG_subprogram)
2142 {
2143 is_subr = TRUE;
2144 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2145 {
2146 if (a->dw_attr == DW_AT_external
2147 && a->dw_attr_val.val_class == dw_val_class_flag
2148 && a->dw_attr_val.v.val_flag != 0)
2149 {
2150 is_extern = TRUE;
2151 break;
2152 }
2153 }
2154 }
2155 return is_subr && is_extern;
2156}
2157
d291dd49
JM		 2158/* Get the attribute of type attr_kind. */
2159inline dw_attr_ref
2160get_AT (die, attr_kind)
a3f97cbb 2161 register dw_die_ref die;
d291dd49 2162 register enum dwarf_attribute attr_kind;
a3f97cbb
JW		 2163{
2164 register dw_attr_ref a;
7e23cb16 2165 register dw_die_ref spec = NULL;
d291dd49 2166
a3f97cbb
JW		 2167 if (die != NULL)
2168 {
2169 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2170 {
d291dd49
JM		 2171 if (a->dw_attr == attr_kind)
2172 return a;
2173 if (a->dw_attr == DW_AT_specification
2174 || a->dw_attr == DW_AT_abstract_origin)
2175 spec = a->dw_attr_val.v.val_die_ref;
a3f97cbb 2176 }
d291dd49
JM		 2177 if (spec)
2178 return get_AT (spec, attr_kind);
a3f97cbb 2179 }
d291dd49
JM		 2180 return NULL;
2181}
2182
2183/* Return the "low pc" attribute value, typically associated with
2184 a subprogram DIE. Return null if the "low pc" attribute is
2185 either not prsent, or if it cannot be represented as an
2186 assembler label identifier. */
2187inline char *
2188get_AT_low_pc (die)
2189 register dw_die_ref die;
2190{
2191 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
2192 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
2193 return a->dw_attr_val.v.val_lbl_id;
2194 return NULL;
2195}
2196
2197/* Return the "high pc" attribute value, typically associated with
2198 a subprogram DIE. Return null if the "high pc" attribute is
2199 either not prsent, or if it cannot be represented as an
2200 assembler label identifier. */
2201inline char *
2202get_AT_hi_pc (die)
2203 register dw_die_ref die;
2204{
2205 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
2206 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
2207 return a->dw_attr_val.v.val_lbl_id;
2208 return NULL;
2209}
2210
2211/* Return the value of the string attribute designated by ATTR_KIND, or
2212 NULL if it is not present. */
2213inline char *
2214get_AT_string (die, attr_kind)
2215 register dw_die_ref die;
2216 register enum dwarf_attribute attr_kind;
2217{
2218 register dw_attr_ref a = get_AT (die, attr_kind);
2219 if (a && a->dw_attr_val.val_class == dw_val_class_str)
2220 return a->dw_attr_val.v.val_str;
2221 return NULL;
a3f97cbb
JW		 2222}
2223
bdb669cb
JM		 2224/* Return the value of the flag attribute designated by ATTR_KIND, or -1
2225 if it is not present. */
2226inline int
2227get_AT_flag (die, attr_kind)
2228 register dw_die_ref die;
2229 register enum dwarf_attribute attr_kind;
2230{
d291dd49
JM		 2231 register dw_attr_ref a = get_AT (die, attr_kind);
2232 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
2233 return a->dw_attr_val.v.val_flag;
bdb669cb
JM		 2234 return -1;
2235}
2236
2237/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
2238 if it is not present. */
2239inline unsigned
2240get_AT_unsigned (die, attr_kind)
2241 register dw_die_ref die;
2242 register enum dwarf_attribute attr_kind;
2243{
d291dd49
JM		 2244 register dw_attr_ref a = get_AT (die, attr_kind);
2245 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
2246 return a->dw_attr_val.v.val_unsigned;
bdb669cb
JM		 2247 return 0;
2248}
a3f97cbb 2249
a9d38797
JM		 2250inline int
2251is_c_family ()
2252{
2253 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
2254 return (lang == DW_LANG_C || lang == DW_LANG_C89
2255 || lang == DW_LANG_C_plus_plus);
2256}
2257
2258inline int
2259is_fortran ()
2260{
2261 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
2262 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
2263}
2264
4b674448
JM		 2265/* Remove the specified attribute if present. */
2266inline void
2267remove_AT (die, attr_kind)
2268 register dw_die_ref die;
2269 register enum dwarf_attribute attr_kind;
2270{
2271 register dw_attr_ref a;
2272 register dw_attr_ref removed = NULL;;
2273 if (die != NULL)
2274 {
2275 if (die->die_attr->dw_attr == attr_kind)
2276 {
2277 removed = die->die_attr;
2278 if (die->die_attr_last == die->die_attr)
2279 die->die_attr_last = NULL;
2280 die->die_attr = die->die_attr->dw_attr_next;
2281 }
2282 else for (a = die->die_attr; a->dw_attr_next != NULL;
2283 a = a->dw_attr_next)
2284 if (a->dw_attr_next->dw_attr == attr_kind)
2285 {
2286 removed = a->dw_attr_next;
2287 if (die->die_attr_last == a->dw_attr_next)
2288 die->die_attr_last = a;
2289 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
e90b62db 2290 break;
4b674448
JM		 2291 }
2292 if (removed)
2293 free (removed);
2294 }
2295}
2296
2297/* Discard the children of this DIE. */
2298inline void
2299remove_children (die)
2300 register dw_die_ref die;
2301{
2302 register dw_die_ref child_die = die->die_child;
2303 die->die_child = NULL;
2304 die->die_child_last = NULL;
2305 while (child_die != NULL)
2306 {
2307 register dw_die_ref tmp_die = child_die;
2308 register dw_attr_ref a;
2309 child_die = child_die->die_sib;
2310
2311 for (a = tmp_die->die_attr; a != NULL; )
2312 {
2313 register dw_attr_ref tmp_a = a;
2314 a = a->dw_attr_next;
2315 free (tmp_a);
2316 }
2317 free (tmp_die);
2318 }
2319}
2320
a3f97cbb
JW		 2321/* Add a child DIE below its parent. */
2322inline void
2323add_child_die (die, child_die)
2324 register dw_die_ref die;
2325 register dw_die_ref child_die;
2326{
2327 if (die != NULL && child_die != NULL)
2328 {
2329 assert (die != child_die);
2330 child_die->die_parent = die;
2331 child_die->die_sib = NULL;
2332 if (die->die_child == NULL)
2333 {
2334 die->die_child = child_die;
2335 die->die_child_last = child_die;
2336 }
2337 else
2338 {
2339 die->die_child_last->die_sib = child_die;
2340 die->die_child_last = child_die;
2341 }
2342 }
2343}
2344
2345/* Return a pointer to a newly created DIE node. */
2346inline dw_die_ref
2347new_die (tag_value, parent_die)
2348 register enum dwarf_tag tag_value;
2349 register dw_die_ref parent_die;
2350{
2351 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
2352 if (die != NULL)
2353 {
2354 die->die_tag = tag_value;
2355 die->die_abbrev = 0;
2356 die->die_offset = 0;
2357 die->die_child = NULL;
2358 die->die_parent = NULL;
2359 die->die_sib = NULL;
2360 die->die_child_last = NULL;
2361 die->die_attr = NULL;
2362 die->die_attr_last = NULL;
2363 if (parent_die != NULL)
a94dbf2c
JM		 2364 add_child_die (parent_die, die);
2365 else
2366 ++limbo_die_count;
a3f97cbb
JW		 2367 }
2368 return die;
2369}
2370
2371/* Return the DIE associated with the given type specifier. */
2372inline dw_die_ref
2373lookup_type_die (type)
2374 register tree type;
2375{
a94dbf2c 2376 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
a3f97cbb
JW		 2377}
2378
2379/* Equate a DIE to a given type specifier. */
2380static void
2381equate_type_number_to_die (type, type_die)
2382 register tree type;
2383 register dw_die_ref type_die;
2384{
a94dbf2c 2385 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
a3f97cbb
JW		 2386}
2387
2388/* Return the DIE associated with a given declaration. */
2389inline dw_die_ref
2390lookup_decl_die (decl)
2391 register tree decl;
2392{
2393 register unsigned decl_id = DECL_UID (decl);
2394 return (decl_id < decl_die_table_in_use)
2395 ? decl_die_table[decl_id] : NULL;
2396}
2397
2398/* Equate a DIE to a particular declaration. */
2399static void
2400equate_decl_number_to_die (decl, decl_die)
2401 register tree decl;
2402 register dw_die_ref decl_die;
2403{
2404 register unsigned decl_id = DECL_UID (decl);
2405 register unsigned i;
2406 register unsigned num_allocated;
2407 if (decl_id >= decl_die_table_allocated)
2408 {
2409 num_allocated = (((decl_id + 1)
2410 + DECL_DIE_TABLE_INCREMENT - 1)
2411 / DECL_DIE_TABLE_INCREMENT)
2412 * DECL_DIE_TABLE_INCREMENT;
2413 decl_die_table = (dw_die_ref *) xrealloc (decl_die_table,
2414 sizeof (dw_die_ref) * num_allocated);
2415 bzero (&decl_die_table[decl_die_table_allocated],
2416 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
2417 decl_die_table_allocated = num_allocated;
2418 }
2419 if (decl_id >= decl_die_table_in_use)
2420 {
2421 decl_die_table_in_use = (decl_id + 1);
2422 }
2423 decl_die_table[decl_id] = decl_die;
2424}
2425
2426/* Return a pointer to a newly allocated location description. Location
2427 descriptions are simple expression terms that can be strung
2428 together to form more complicated location (address) descriptions. */
2429inline dw_loc_descr_ref
2430new_loc_descr (op, oprnd1, oprnd2)
2431 register enum dwarf_location_atom op;
2432 register unsigned long oprnd1;
2433 register unsigned long oprnd2;
2434{
2435 register dw_loc_descr_ref descr =
2436 (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
2437 if (descr != NULL)
2438 {
2439 descr->dw_loc_next = NULL;
2440 descr->dw_loc_opc = op;
2441 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2442 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2443 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2444 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2445 }
2446 return descr;
2447}
2448
2449/* Add a location description term to a location description expression. */
2450inline void
2451add_loc_descr (list_head, descr)
2452 register dw_loc_descr_ref *list_head;
2453 register dw_loc_descr_ref descr;
2454{
2455 register dw_loc_descr_ref *d;
2456 /* find the end of the chain. */
2457 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
2458 {
2459 /* nothing */ ;
2460 }
2461 *d = descr;
2462}
2463
2464/* Return a pointer to a newly allocated Call Frame Instruction. */
2465inline dw_cfi_ref
2466new_cfi ()
2467{
2468 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
2469 if (cfi != NULL)
2470 {
2471 cfi->dw_cfi_next = NULL;
2472 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
2473 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
2474 }
2475 return cfi;
2476}
2477
2478/* Add a Call Frame Instruction to list of instructions. */
2479inline void
2480add_cfi (list_head, cfi)
2481 register dw_cfi_ref *list_head;
2482 register dw_cfi_ref cfi;
2483{
2484 register dw_cfi_ref *p;
2485 /* find the end of the chain. */
2486 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
2487 {
2488 /* nothing */ ;
2489 }
2490 *p = cfi;
2491}
2492\f
2493/********* Print DWARF Internal Representation (debugging aids) ***************/
2494
2495/* Keep track of the number of spaces used to indent the
2496 output of the debugging routines that print the structure of
2497 the DIE internal representation. */
2498static int print_indent;
2499
2500/* Indent the line the number of spaces given by print_indent. */
2501inline void
2502print_spaces (outfile)
2503 FILE *outfile;
2504{
2505 fprintf (outfile, "%*s", print_indent, "");
2506}
2507
2508/* Print the information assoaciated with a given DIE, and its children.
2509 This routine is a debugging aid only. */
2510static void
2511print_die (die, outfile)
2512 dw_die_ref die;
2513 FILE *outfile;
2514{
2515 register dw_attr_ref a;
2516 register dw_die_ref c;
2517 print_spaces (outfile);
2518 fprintf (outfile, "DIE %4u: %s\n",
2519 die->die_offset, dwarf_tag_name (die->die_tag));
2520 print_spaces (outfile);
2521 fprintf (outfile, " abbrev id: %u", die->die_abbrev);
2522 fprintf (outfile, " offset: %u\n", die->die_offset);
2523 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2524 {
2525 print_spaces (outfile);
2526 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
2527 switch (a->dw_attr_val.val_class)
2528 {
2529 case dw_val_class_addr:
2530 fprintf (outfile, "address");
2531 break;
2532 case dw_val_class_loc:
2533 fprintf (outfile, "location descriptor");
2534 break;
2535 case dw_val_class_const:
2536 fprintf (outfile, "%d", a->dw_attr_val.v.val_int);
2537 break;
2538 case dw_val_class_unsigned_const:
2539 fprintf (outfile, "%u", a->dw_attr_val.v.val_unsigned);
2540 break;
469ac993 2541 case dw_val_class_long_long:
a3f97cbb 2542 fprintf (outfile, "constant (%u,%u)",
469ac993
JM		 2543 a->dw_attr_val.v.val_long_long.hi,
2544 a->dw_attr_val.v.val_long_long.low);
2545 break;
2546 case dw_val_class_float:
2547 fprintf (outfile, "floating-point constant");
a3f97cbb
JW		 2548 break;
2549 case dw_val_class_flag:
2550 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
2551 break;
2552 case dw_val_class_die_ref:
2553 if (a->dw_attr_val.v.val_die_ref != NULL)
2554 {
2555 fprintf (outfile, "die -> %u",
2556 a->dw_attr_val.v.val_die_ref->die_offset);
2557 }
2558 else
2559 {
2560 fprintf (outfile, "die -> <null>");
2561 }
2562 break;
2563 case dw_val_class_lbl_id:
2564 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
2565 break;
2566 case dw_val_class_section_offset:
2567 fprintf (outfile, "section: %s", a->dw_attr_val.v.val_section);
2568 break;
2569 case dw_val_class_str:
2570 if (a->dw_attr_val.v.val_str != NULL)
2571 {
2572 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
2573 }
2574 else
2575 {
2576 fprintf (outfile, "<null>");
2577 }
2578 break;
2579 }
2580 fprintf (outfile, "\n");
2581 }
2582 if (die->die_child != NULL)
2583 {
2584 print_indent += 4;
2585 for (c = die->die_child; c != NULL; c = c->die_sib)
2586 {
2587 print_die (c, outfile);
2588 }
2589 print_indent -= 4;
2590 }
2591}
2592
2593/* Print the contents of the source code line number correspondence table.
2594 This routine is a debugging aid only. */
2595static void
2596print_dwarf_line_table (outfile)
2597 FILE *outfile;
2598{
2599 register unsigned i;
2600 register dw_line_info_ref line_info;
2601 fprintf (outfile, "\n\nDWARF source line information\n");
2602 for (i = 1; i < line_info_table_in_use; ++i)
2603 {
2604 line_info = &line_info_table[i];
2605 fprintf (outfile, "%5d: ", i);
2606 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
2607 fprintf (outfile, "%6d", line_info->dw_line_num);
2608 fprintf (outfile, "\n");
2609 }
2610 fprintf (outfile, "\n\n");
2611}
2612
2613/* Print the information collected for a given DIE. */
2614void
2615debug_dwarf_die (die)
2616 dw_die_ref die;
2617{
2618 print_die (die, stderr);
2619}
2620
2621/* Print all DWARF informaiton collected for the compilation unit.
2622 This routine is a debugging aid only. */
2623void
2624debug_dwarf ()
2625{
2626 print_indent = 0;
2627 print_die (comp_unit_die, stderr);
2628 print_dwarf_line_table (stderr);
2629}
2630
2631\f
2632/***************** DWARF Information Construction Support *********************/
2633
2634/* Traverse the DIE, and add a sibling attribute if it may have the
2635 effect of speeding up access to siblings. To save some space,
2636 avoid generating sibling attributes for DIE's without children. */
2637static void
2638add_sibling_attributes(die)
2639 register dw_die_ref die;
2640{
2641 register dw_die_ref c;
2642 register dw_attr_ref attr;
2643 if (die != comp_unit_die && die->die_child != NULL)
2644 {
2645 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2646 if (attr != NULL)
2647 {
2648 attr->dw_attr_next = NULL;
2649 attr->dw_attr = DW_AT_sibling;
2650 attr->dw_attr_val.val_class = dw_val_class_die_ref;
2651 attr->dw_attr_val.v.val_die_ref = die->die_sib;
2652 }
2653 /* add the sibling link to the front of the attribute list. */
2654 attr->dw_attr_next = die->die_attr;
2655 if (die->die_attr == NULL)
2656 {
2657 die->die_attr_last = attr;
2658 }
2659 die->die_attr = attr;
2660 }
2661 for (c = die->die_child; c != NULL; c = c->die_sib)
2662 {
2663 add_sibling_attributes (c);
2664 }
2665}
2666
2667/* The format of each DIE (and its attribute value pairs)
2668 is encoded in an abbreviation table. This routine builds the
2669 abbreviation table and assigns a unique abbreviation id for
2670 each abbreviation entry. The children of each die are visited
2671 recursively. */
2672static void
2673build_abbrev_table (die)
2674 register dw_die_ref die;
2675{
2676 register unsigned long abbrev_id;
2677 register unsigned long n_alloc;
2678 register dw_die_ref c;
2679 register dw_attr_ref d_attr, a_attr;
2680 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
2681 {
2682 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
2683 if (abbrev->die_tag == die->die_tag)
2684 {
2685 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
2686 {
2687 a_attr = abbrev->die_attr;
2688 d_attr = die->die_attr;
2689 while (a_attr != NULL && d_attr != NULL)
2690 {
2691 if ((a_attr->dw_attr != d_attr->dw_attr)
f37230f0
JM		 2692 || (value_format (&a_attr->dw_attr_val)
2693 != value_format (&d_attr->dw_attr_val)))
a3f97cbb
JW		 2694 {
2695 break;
2696 }
2697 a_attr = a_attr->dw_attr_next;
2698 d_attr = d_attr->dw_attr_next;
2699 }
2700 if (a_attr == NULL && d_attr == NULL)
2701 {
2702 break;
2703 }
2704 }
2705 }
2706 }
2707 if (abbrev_id >= abbrev_die_table_in_use)
2708 {
2709 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
2710 {
2711 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
2712 abbrev_die_table = (dw_die_ref *)
2713 xmalloc (abbrev_die_table,
2714 sizeof (dw_die_ref) * n_alloc);
2715 bzero (&abbrev_die_table[abbrev_die_table_allocated],
2716 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
2717 abbrev_die_table_allocated = n_alloc;
2718 }
2719 ++abbrev_die_table_in_use;
2720 abbrev_die_table[abbrev_id] = die;
2721 }
2722 die->die_abbrev = abbrev_id;
2723 for (c = die->die_child; c != NULL; c = c->die_sib)
2724 {
2725 build_abbrev_table (c);
2726 }
2727}
2728
2729\f
2730/********************** DWARF Information Sizing *****************************/
2731
2732/* Return the size of an unsigned LEB128 quantity. */
2733inline unsigned long
2734size_of_uleb128 (value)
2735 register unsigned long value;
2736{
2737 register unsigned long size = 0;
2738 register unsigned byte;
2739 do
2740 {
2741 byte = (value & 0x7f);
2742 value >>= 7;
2743 size += 1;
2744 }
2745 while (value != 0);
2746 return size;
2747}
2748
2749/* Return the size of a signed LEB128 quantity. */
2750inline unsigned long
2751size_of_sleb128 (value)
2752 register long value;
2753{
2754 register unsigned long size = 0;
2755 register unsigned byte;
2756 do
2757 {
2758 byte = (value & 0x7f);
2759 value >>= 7;
2760 size += 1;
2761 }
2762 while (!(((value == 0) && ((byte & 0x40) == 0))
2763 || ((value == -1) && ((byte & 0x40) != 0))));
2764 return size;
2765}
2766
2767/* Return the size of a string, including the null byte. */
2768static unsigned long
2769size_of_string (str)
2770 register char *str;
2771{
2772 register unsigned long size = 0;
2773 register unsigned long slen = strlen (str);
2774 register unsigned long i;
2775 register unsigned c;
2776 for (i = 0; i < slen; ++i)
2777 {
2778 c = str[i];
2779 if (c == '\\')
2780 {
2781 ++i;
2782 }
2783 size += 1;
2784 }
2785 /* Null terminator. */
2786 size += 1;
2787 return size;
2788}
2789
2790/* Return the size of a location descriptor. */
2791static unsigned long
2792size_of_loc_descr (loc)
2793 register dw_loc_descr_ref loc;
2794{
2795 register unsigned long size = 1;
2796 switch (loc->dw_loc_opc)
2797 {
2798 case DW_OP_addr:
2799 size += PTR_SIZE;
2800 break;
2801 case DW_OP_const1u:
2802 case DW_OP_const1s:
2803 size += 1;
2804 break;
2805 case DW_OP_const2u:
2806 case DW_OP_const2s:
2807 size += 2;
2808 break;
2809 case DW_OP_const4u:
2810 case DW_OP_const4s:
2811 size += 4;
2812 break;
2813 case DW_OP_const8u:
2814 case DW_OP_const8s:
2815 size += 8;
2816 break;
2817 case DW_OP_constu:
2818 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2819 break;
2820 case DW_OP_consts:
2821 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2822 break;
2823 case DW_OP_pick:
2824 size += 1;
2825 break;
2826 case DW_OP_plus_uconst:
2827 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2828 break;
2829 case DW_OP_skip:
2830 case DW_OP_bra:
2831 size += 2;
2832 break;
2833 case DW_OP_breg0:
2834 case DW_OP_breg1:
2835 case DW_OP_breg2:
2836 case DW_OP_breg3:
2837 case DW_OP_breg4:
2838 case DW_OP_breg5:
2839 case DW_OP_breg6:
2840 case DW_OP_breg7:
2841 case DW_OP_breg8:
2842 case DW_OP_breg9:
2843 case DW_OP_breg10:
2844 case DW_OP_breg11:
2845 case DW_OP_breg12:
2846 case DW_OP_breg13:
2847 case DW_OP_breg14:
2848 case DW_OP_breg15:
2849 case DW_OP_breg16:
2850 case DW_OP_breg17:
2851 case DW_OP_breg18:
2852 case DW_OP_breg19:
2853 case DW_OP_breg20:
2854 case DW_OP_breg21:
2855 case DW_OP_breg22:
2856 case DW_OP_breg23:
2857 case DW_OP_breg24:
2858 case DW_OP_breg25:
2859 case DW_OP_breg26:
2860 case DW_OP_breg27:
2861 case DW_OP_breg28:
2862 case DW_OP_breg29:
2863 case DW_OP_breg30:
2864 case DW_OP_breg31:
2865 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2866 break;
2867 case DW_OP_regx:
2868 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2869 break;
2870 case DW_OP_fbreg:
2871 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2872 break;
2873 case DW_OP_bregx:
2874 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2875 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
2876 break;
2877 case DW_OP_piece:
2878 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2879 break;
2880 case DW_OP_deref_size:
2881 case DW_OP_xderef_size:
2882 size += 1;
2883 break;
2884 default:
2885 break;
2886 }
2887 return size;
2888}
2889
f37230f0
JM		 2890/* Return the size of a series of location descriptors. */
2891static unsigned long
2892size_of_locs (loc)
2893 register dw_loc_descr_ref loc;
2894{
2895 register unsigned long size = 0;
2896 for (; loc != NULL; loc = loc->dw_loc_next)
2897 size += size_of_loc_descr (loc);
2898 return size;
2899}
2900
7e23cb16
JM		 2901/* Return the power-of-two number of bytes necessary to represent VALUE. */
2902static int
2903constant_size (value)
2904 long unsigned value;
2905{
2906 int log;
2907
2908 if (value == 0)
2909 log = 0;
2910 else
2911 log = floor_log2 (value);
2912
2913 log = log / 8;
2914 log = 1 << (floor_log2 (log) + 1);
2915
2916 return log;
2917}
2918
a3f97cbb
JW		 2919/* Return the size of a DIE, as it is represented in the
2920 .debug_info section. */
2921static unsigned long
2922size_of_die (die)
2923 register dw_die_ref die;
2924{
2925 register unsigned long size = 0;
2926 register dw_attr_ref a;
a3f97cbb
JW		 2927 size += size_of_uleb128 (die->die_abbrev);
2928 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2929 {
2930 switch (a->dw_attr_val.val_class)
2931 {
2932 case dw_val_class_addr:
7e23cb16 2933 size += PTR_SIZE;
a3f97cbb
JW		 2934 break;
2935 case dw_val_class_loc:
f37230f0
JM		 2936 {
2937 register unsigned long lsize
2938 = size_of_locs (a->dw_attr_val.v.val_loc);
2939
2940 /* Block length. */
2941 size += constant_size (lsize);
2942 size += lsize;
2943 }
a3f97cbb
JW		 2944 break;
2945 case dw_val_class_const:
2946 size += 4;
2947 break;
2948 case dw_val_class_unsigned_const:
7e23cb16 2949 size += constant_size (a->dw_attr_val.v.val_unsigned);
a3f97cbb 2950 break;
469ac993
JM		 2951 case dw_val_class_long_long:
2952 size += 1 + 8; /* block */
2953 break;
2954 case dw_val_class_float:
2955 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
a3f97cbb
JW		 2956 break;
2957 case dw_val_class_flag:
2958 size += 1;
2959 break;
2960 case dw_val_class_die_ref:
7e23cb16 2961 size += DWARF_OFFSET_SIZE;
a3f97cbb
JW		 2962 break;
2963 case dw_val_class_fde_ref:
7e23cb16 2964 size += DWARF_OFFSET_SIZE;
a3f97cbb
JW		 2965 break;
2966 case dw_val_class_lbl_id:
7e23cb16 2967 size += PTR_SIZE;
a3f97cbb
JW		 2968 break;
2969 case dw_val_class_section_offset:
7e23cb16 2970 size += DWARF_OFFSET_SIZE;
a3f97cbb
JW		 2971 break;
2972 case dw_val_class_str:
2973 size += size_of_string (a->dw_attr_val.v.val_str);
2974 break;
2975 default:
2976 abort ();
2977 }
2978 }
2979 return size;
2980}
2981
2982/* Size the debgging information associted with a given DIE.
2983 Visits the DIE's children recursively. Updates the global
2984 variable next_die_offset, on each time through. Uses the
2985 current value of next_die_offset to updete the die_offset
2986 field in each DIE. */
2987static void
2988calc_die_sizes (die)
2989 dw_die_ref die;
2990{
2991 register dw_die_ref c;
a3f97cbb
JW		 2992 die->die_offset = next_die_offset;
2993 next_die_offset += size_of_die (die);
2994 for (c = die->die_child; c != NULL; c = c->die_sib)
2995 {
2996 calc_die_sizes (c);
2997 }
2998 if (die->die_child != NULL)
2999 {
3000 /* Count the null byte used to terminate sibling lists. */
3001 next_die_offset += 1;
3002 }
3003}
3004
3005/* Return the size of the line information prolog generated for the
3006 compilation unit. */
3007static unsigned long
3008size_of_line_prolog ()
3009{
3010 register unsigned long size;
a3f97cbb
JW		 3011 register unsigned long ft_index;
3012 size = DWARF_LINE_PROLOG_HEADER_SIZE;
3013 /* Count the size of the table giving number of args for each
3014 standard opcode. */
3015 size += DWARF_LINE_OPCODE_BASE - 1;
3016 /* Include directory table is empty (at present). Count only the
3017 the null byte used to terminate the table. */
3018 size += 1;
3019 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
3020 {
3021 /* File name entry. */
3022 size += size_of_string (file_table[ft_index]);
3023 /* Include directory index. */
3024 size += size_of_uleb128 (0);
3025 /* Modification time. */
3026 size += size_of_uleb128 (0);
3027 /* File length in bytes. */
3028 size += size_of_uleb128 (0);
3029 }
3030 /* Count the file table terminator. */
3031 size += 1;
3032 return size;
3033}
3034
3035/* Return the size of the line information generated for this
3036 compilation unit. */
3037static unsigned long
3038size_of_line_info ()
3039{
3040 register unsigned long size;
a3f97cbb
JW		 3041 register unsigned long lt_index;
3042 register unsigned long current_line;
3043 register long line_offset;
3044 register long line_delta;
3045 register unsigned long current_file;
e90b62db 3046 register unsigned long function;
a3f97cbb
JW		 3047 /* Version number. */
3048 size = 2;
3049 /* Prolog length specifier. */
7e23cb16 3050 size += DWARF_OFFSET_SIZE;
a3f97cbb
JW		 3051 /* Prolog. */
3052 size += size_of_line_prolog ();
3053 /* Set address register instruction. */
3054 size += 1 + size_of_uleb128 (1 + PTR_SIZE)
3055 + 1 + PTR_SIZE;
3056 current_file = 1;
3057 current_line = 1;
3058 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
3059 {
e90b62db 3060 register dw_line_info_ref line_info;
a3f97cbb
JW		 3061 /* Advance pc instruction. */
3062 size += 1 + 2;
3063 line_info = &line_info_table[lt_index];
3064 if (line_info->dw_file_num != current_file)
3065 {
3066 /* Set file number instruction. */
3067 size += 1;
3068 current_file = line_info->dw_file_num;
3069 size += size_of_uleb128 (current_file);
3070 }
3071 if (line_info->dw_line_num != current_line)
3072 {
3073 line_offset = line_info->dw_line_num - current_line;
3074 line_delta = line_offset - DWARF_LINE_BASE;
3075 current_line = line_info->dw_line_num;
3076 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
3077 {
3078 /* 1-byte special line number instruction. */
3079 size += 1;
3080 }
3081 else
3082 {
3083 /* Advance line instruction. */
3084 size += 1;
3085 size += size_of_sleb128 (line_offset);
3086 /* Generate line entry instruction. */
3087 size += 1;
3088 }
3089 }
3090 }
bdb669cb
JM		 3091 /* Advance pc instruction. */
3092 size += 1 + 2;
a3f97cbb
JW		 3093 /* End of line number info. marker. */
3094 size += 1 + size_of_uleb128 (1) + 1;
e90b62db
JM		 3095 function = 0;
3096 current_file = 1;
3097 current_line = 1;
3098 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
3099 {
3100 register dw_separate_line_info_ref line_info
3101 = &separate_line_info_table[lt_index];
3102 if (function != line_info->function)
3103 {
3104 function = line_info->function;
3105 /* Set address register instruction. */
3106 size += 1 + size_of_uleb128 (1 + PTR_SIZE)
3107 + 1 + PTR_SIZE;
3108 }
3109 else
3110 {
3111 /* Advance pc instruction. */
3112 size += 1 + 2;
3113 }
3114 if (line_info->dw_file_num != current_file)
3115 {
3116 /* Set file number instruction. */
3117 size += 1;
3118 current_file = line_info->dw_file_num;
3119 size += size_of_uleb128 (current_file);
3120 }
3121 if (line_info->dw_line_num != current_line)
3122 {
3123 line_offset = line_info->dw_line_num - current_line;
3124 line_delta = line_offset - DWARF_LINE_BASE;
3125 current_line = line_info->dw_line_num;
3126 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
3127 {
3128 /* 1-byte special line number instruction. */
3129 size += 1;
3130 }
3131 else
3132 {
3133 /* Advance line instruction. */
3134 size += 1;
3135 size += size_of_sleb128 (line_offset);
3136 /* Generate line entry instruction. */
3137 size += 1;
3138 }
3139 }
3140 ++lt_index;
3141
3142 /* If we're done with a function, end its sequence. */
3143 if (lt_index == separate_line_info_table_in_use
3144 || separate_line_info_table[lt_index].function != function)
3145 {
3146 current_file = 1;
3147 current_line = 1;
3148 /* Advance pc instruction. */
3149 size += 1 + 2;
3150 /* End of line number info. marker. */
3151 size += 1 + size_of_uleb128 (1) + 1;
3152 }
3153 }
a3f97cbb
JW		 3154 return size;
3155}
3156
3157/* Return the size of the .debug_pubnames table generated for the
3158 compilation unit. */
3159static unsigned long
3160size_of_pubnames ()
3161{
a3f97cbb 3162 register unsigned long size;
d291dd49
JM		 3163 register unsigned i;
3164
a3f97cbb 3165 size = DWARF_PUBNAMES_HEADER_SIZE;
d291dd49 3166 for (i = 0; i < pubname_table_in_use; ++i)
a3f97cbb 3167 {
d291dd49 3168 register pubname_ref p = &pubname_table[i];
7e23cb16 3169 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
a3f97cbb 3170 }
7e23cb16 3171 size += DWARF_OFFSET_SIZE;
a3f97cbb
JW		 3172 return size;
3173}
3174
3175/* Return the size of the information in the .debug_aranges seciton. */
3176static unsigned long
3177size_of_aranges ()
3178{
3179 register unsigned long size;
3180 size = DWARF_ARANGES_HEADER_SIZE;
3181 /* Count the address/length pair for this compilation unit. */
7e23cb16
JM		 3182 size += 2 * PTR_SIZE;
3183 size += 2 * PTR_SIZE * arange_table_in_use;
a3f97cbb 3184 /* Count the two zero words used to terminated the address range table. */
7e23cb16 3185 size += 2 * PTR_SIZE;
a3f97cbb
JW		 3186 return size;
3187}
3188\f
3189/**************** DWARF Debug Information Output *****************************/
3190
3191/* Output an unsigned LEB128 quantity. */
3192static void
3193output_uleb128 (value)
3194 register unsigned long value;
3195{
b2932ae5 3196 unsigned long save_value = value;
a3f97cbb
JW		 3197 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
3198 do
3199 {
3200 register unsigned byte = (value & 0x7f);
3201 value >>= 7;
3202 if (value != 0)
3203 {
3204 /* More bytes to follow. */
3205 byte |= 0x80;
3206 }
3207 fprintf (asm_out_file, "0x%x", byte);
3208 if (value != 0)
3209 {
3210 fprintf (asm_out_file, ",");
3211 }
3212 }
3213 while (value != 0);
b2932ae5
JM		 3214 if (flag_verbose_asm)
3215 fprintf (asm_out_file, "\t%s ULEB128 0x%x", ASM_COMMENT_START, save_value);
a3f97cbb
JW		 3216}
3217
3218/* Output an signed LEB128 quantity. */
3219static void
3220output_sleb128 (value)
3221 register long value;
3222{
3223 register int more;
3224 register unsigned byte;
b2932ae5 3225 long save_value = value;
a3f97cbb
JW		 3226 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
3227 do
3228 {
3229 byte = (value & 0x7f);
3230 /* arithmetic shift */
3231 value >>= 7;
3232 more = !((((value == 0) && ((byte & 0x40) == 0))
3233 || ((value == -1) && ((byte & 0x40) != 0))));
3234 if (more)
3235 {
3236 byte |= 0x80;
3237 }
3238 fprintf (asm_out_file, "0x%x", byte);
3239 if (more)
3240 {
3241 fprintf (asm_out_file, ",");
3242 }
3243 }
3244 while (more);
b2932ae5
JM		 3245 if (flag_verbose_asm)
3246 fprintf (asm_out_file, "\t%s SLEB128 %d", ASM_COMMENT_START, save_value);
a3f97cbb
JW		 3247}
3248
f37230f0
JM		 3249/* Select the encoding of an attribute value. */
3250static enum dwarf_form
3251value_format (v)
a3f97cbb
JW		 3252 dw_val_ref v;
3253{
a3f97cbb
JW		 3254 switch (v->val_class)
3255 {
3256 case dw_val_class_addr:
f37230f0 3257 return DW_FORM_addr;
a3f97cbb 3258 case dw_val_class_loc:
f37230f0
JM		 3259 switch (constant_size (size_of_locs (v->v.val_loc)))
3260 {
3261 case 1:
3262 return DW_FORM_block1;
3263 case 2:
3264 return DW_FORM_block2;
3265 default:
3266 abort ();
3267 }
a3f97cbb 3268 case dw_val_class_const:
f37230f0 3269 return DW_FORM_data4;
a3f97cbb 3270 case dw_val_class_unsigned_const:
7e23cb16
JM		 3271 switch (constant_size (v->v.val_unsigned))
3272 {
3273 case 1:
f37230f0 3274 return DW_FORM_data1;
7e23cb16 3275 case 2:
f37230f0 3276 return DW_FORM_data2;
7e23cb16 3277 case 4:
f37230f0 3278 return DW_FORM_data4;
7e23cb16
JM		 3279 default:
3280 abort ();
3281 }
469ac993
JM		 3282 case dw_val_class_long_long:
3283 return DW_FORM_block1;
3284 case dw_val_class_float:
3285 return DW_FORM_block1;
a3f97cbb 3286 case dw_val_class_flag:
f37230f0 3287 return DW_FORM_flag;
a3f97cbb 3288 case dw_val_class_die_ref:
f37230f0 3289 return DW_FORM_ref;
a3f97cbb 3290 case dw_val_class_fde_ref:
f37230f0 3291 return DW_FORM_data;
a3f97cbb 3292 case dw_val_class_lbl_id:
f37230f0 3293 return DW_FORM_addr;
a3f97cbb 3294 case dw_val_class_section_offset:
f37230f0 3295 return DW_FORM_data;
a3f97cbb 3296 case dw_val_class_str:
f37230f0 3297 return DW_FORM_string;
a3f97cbb
JW		 3298 default:
3299 abort ();
3300 }
f37230f0
JM		 3301}
3302
3303/* Output the encoding of an attribute value. */
3304static void
3305output_value_format (v)
3306 dw_val_ref v;
3307{
3308 enum dwarf_form form = value_format (v);
a3f97cbb
JW		 3309 output_uleb128 (form);
3310 if (flag_verbose_asm)
b2932ae5 3311 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
a3f97cbb
JW		 3312 fputc ('\n', asm_out_file);
3313}
3314
3315/* Output the .debug_abbrev section which defines the DIE abbreviation
3316 table. */
3317static void
3318output_abbrev_section ()
3319{
3320 unsigned long abbrev_id;
3321 dw_attr_ref a_attr;
3322 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
3323 {
3324 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
3325 output_uleb128 (abbrev_id);
3326 if (flag_verbose_asm)
b2932ae5 3327 fprintf (asm_out_file, " (abbrev code)");
a3f97cbb
JW		 3328 fputc ('\n', asm_out_file);
3329 output_uleb128 (abbrev->die_tag);
3330 if (flag_verbose_asm)
b2932ae5
JM		 3331 fprintf (asm_out_file, " (TAG: %s)",
3332 dwarf_tag_name (abbrev->die_tag));
a3f97cbb
JW		 3333 fputc ('\n', asm_out_file);
3334 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
3335 (abbrev->die_child != NULL)
3336 ? DW_children_yes : DW_children_no);
3337 if (flag_verbose_asm)
3338 {
3339 fprintf (asm_out_file, "\t%s %s",
3340 ASM_COMMENT_START,
3341 (abbrev->die_child != NULL)
3342 ? "DW_children_yes" : "DW_children_no");
3343 }
3344 fputc ('\n', asm_out_file);
3345 for (a_attr = abbrev->die_attr; a_attr != NULL;
3346 a_attr = a_attr->dw_attr_next)
3347 {
3348 output_uleb128 (a_attr->dw_attr);
3349 if (flag_verbose_asm)
b2932ae5
JM		 3350 fprintf (asm_out_file, " (%s)",
3351 dwarf_attr_name (a_attr->dw_attr));
a3f97cbb
JW		 3352 fputc ('\n', asm_out_file);
3353 output_value_format (&a_attr->dw_attr_val);
3354 }
3355 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
3356 }
3357}
3358
3359/* Output location description stack opcode's operands (if any). */
3360static void
3361output_loc_operands (loc)
3362 register dw_loc_descr_ref loc;
3363{
3364 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
3365 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
3366 switch (loc->dw_loc_opc)
3367 {
3368 case DW_OP_addr:
3369 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
3370 fputc ('\n', asm_out_file);
3371 break;
3372 case DW_OP_const1u:
3373 case DW_OP_const1s:
3374 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
3375 fputc ('\n', asm_out_file);
3376 break;
3377 case DW_OP_const2u:
3378 case DW_OP_const2s:
3379 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
3380 fputc ('\n', asm_out_file);
3381 break;
3382 case DW_OP_const4u:
3383 case DW_OP_const4s:
3384 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
3385 fputc ('\n', asm_out_file);
3386 break;
3387 case DW_OP_const8u:
3388 case DW_OP_const8s:
469ac993 3389 abort ();
a3f97cbb
JW		 3390 fputc ('\n', asm_out_file);
3391 break;
3392 case DW_OP_constu:
3393 output_uleb128 (val1->v.val_unsigned);
3394 fputc ('\n', asm_out_file);
3395 break;
3396 case DW_OP_consts:
b2932ae5 3397 output_sleb128 (val1->v.val_int);
a3f97cbb
JW		 3398 fputc ('\n', asm_out_file);
3399 break;
3400 case DW_OP_pick:
3401 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
3402 fputc ('\n', asm_out_file);
3403 break;
3404 case DW_OP_plus_uconst:
3405 output_uleb128 (val1->v.val_unsigned);
3406 fputc ('\n', asm_out_file);
3407 break;
3408 case DW_OP_skip:
3409 case DW_OP_bra:
3410 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
3411 fputc ('\n', asm_out_file);
3412 break;
3413 case DW_OP_breg0:
3414 case DW_OP_breg1:
3415 case DW_OP_breg2:
3416 case DW_OP_breg3:
3417 case DW_OP_breg4:
3418 case DW_OP_breg5:
3419 case DW_OP_breg6:
3420 case DW_OP_breg7:
3421 case DW_OP_breg8:
3422 case DW_OP_breg9:
3423 case DW_OP_breg10:
3424 case DW_OP_breg11:
3425 case DW_OP_breg12:
3426 case DW_OP_breg13:
3427 case DW_OP_breg14:
3428 case DW_OP_breg15:
3429 case DW_OP_breg16:
3430 case DW_OP_breg17:
3431 case DW_OP_breg18:
3432 case DW_OP_breg19:
3433 case DW_OP_breg20:
3434 case DW_OP_breg21:
3435 case DW_OP_breg22:
3436 case DW_OP_breg23:
3437 case DW_OP_breg24:
3438 case DW_OP_breg25:
3439 case DW_OP_breg26:
3440 case DW_OP_breg27:
3441 case DW_OP_breg28:
3442 case DW_OP_breg29:
3443 case DW_OP_breg30:
3444 case DW_OP_breg31:
3445 output_sleb128 (val1->v.val_int);
3446 fputc ('\n', asm_out_file);
3447 break;
3448 case DW_OP_regx:
3449 output_uleb128 (val1->v.val_unsigned);
3450 fputc ('\n', asm_out_file);
3451 break;
3452 case DW_OP_fbreg:
b2932ae5 3453 output_sleb128 (val1->v.val_int);
a3f97cbb
JW		 3454 fputc ('\n', asm_out_file);
3455 break;
3456 case DW_OP_bregx:
3457 output_uleb128 (val1->v.val_unsigned);
3458 fputc ('\n', asm_out_file);
b2932ae5 3459 output_sleb128 (val2->v.val_int);
a3f97cbb
JW		 3460 fputc ('\n', asm_out_file);
3461 break;
3462 case DW_OP_piece:
3463 output_uleb128 (val1->v.val_unsigned);
3464 fputc ('\n', asm_out_file);
3465 break;
3466 case DW_OP_deref_size:
3467 case DW_OP_xderef_size:
3468 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
3469 fputc ('\n', asm_out_file);
3470 break;
3471 default:
3472 break;
3473 }
3474}
3475
3476/* Compute the offset of a sibling. */
3477static unsigned long
3478sibling_offset (die)
3479 dw_die_ref die;
3480{
3481 unsigned long offset;
3482 if (die->die_child_last == NULL)
3483 {
3484 offset = die->die_offset + size_of_die (die);
3485 }
3486 else
3487 {
3488 offset = sibling_offset (die->die_child_last) + 1;
3489 }
3490 return offset;
3491}
3492
3493/* Output the DIE and its attributes. Called recursively to generate
3494 the definitions of each child DIE. */
3495static void
3496output_die (die)
3497 register dw_die_ref die;
3498{
3499 register dw_attr_ref a;
3500 register dw_die_ref c;
3501 register unsigned long ref_offset;
3502 register unsigned long size;
3503 register dw_loc_descr_ref loc;
469ac993
JM		 3504 register int i;
3505
a3f97cbb
JW		 3506 output_uleb128 (die->die_abbrev);
3507 if (flag_verbose_asm)
b2932ae5
JM		 3508 fprintf (asm_out_file, " (DIE (0x%x) %s)",
3509 die->die_offset, dwarf_tag_name (die->die_tag));
a3f97cbb
JW		 3510 fputc ('\n', asm_out_file);
3511 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3512 {
3513 switch (a->dw_attr_val.val_class)
3514 {
3515 case dw_val_class_addr:
3516 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
3517 a->dw_attr_val.v.val_addr);
3518 break;
3519 case dw_val_class_loc:
f37230f0
JM		 3520 size = size_of_locs (a->dw_attr_val.v.val_loc);
3521 /* Output the block length for this list of location operations. */
3522 switch (constant_size (size))
a3f97cbb 3523 {
f37230f0
JM		 3524 case 1:
3525 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
3526 break;
3527 case 2:
3528 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
3529 break;
3530 default:
3531 abort ();
a3f97cbb 3532 }
a3f97cbb
JW		 3533 if (flag_verbose_asm)
3534 {
3535 fprintf (asm_out_file, "\t%s %s",
3536 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3537 }
3538 fputc ('\n', asm_out_file);
3539 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
3540 loc = loc->dw_loc_next)
3541 {
3542 /* Output the opcode. */
3543 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
3544 if (flag_verbose_asm)
3545 {
3546 fprintf (asm_out_file, "\t%s %s",
3547 ASM_COMMENT_START,
3548 dwarf_stack_op_name (loc->dw_loc_opc));
3549 }
3550 fputc ('\n', asm_out_file);
3551 /* Output the operand(s) (if any). */
3552 output_loc_operands (loc);
3553 }
3554 break;
3555 case dw_val_class_const:
3556 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
3557 break;
3558 case dw_val_class_unsigned_const:
7e23cb16
JM		 3559 switch (constant_size (a->dw_attr_val.v.val_unsigned))
3560 {
3561 case 1:
3562 ASM_OUTPUT_DWARF_DATA1
3563 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3564 break;
3565 case 2:
3566 ASM_OUTPUT_DWARF_DATA2
3567 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3568 break;
3569 case 4:
3570 ASM_OUTPUT_DWARF_DATA4
3571 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3572 break;
3573 default:
3574 abort ();
3575 }
a3f97cbb 3576 break;
469ac993
JM		 3577 case dw_val_class_long_long:
3578 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
3579 if (flag_verbose_asm)
3580 fprintf (asm_out_file, "\t%s %s",
3581 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3582 fputc ('\n', asm_out_file);
a3f97cbb 3583 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
469ac993
JM		 3584 a->dw_attr_val.v.val_long_long.hi,
3585 a->dw_attr_val.v.val_long_long.low);
3586 if (flag_verbose_asm)
3587 fprintf (asm_out_file, "\t%s long long constant",
3588 ASM_COMMENT_START);
3589 fputc ('\n', asm_out_file);
3590 break;
3591 case dw_val_class_float:
3592 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
3593 a->dw_attr_val.v.val_float.length * 4);
3594 if (flag_verbose_asm)
3595 fprintf (asm_out_file, "\t%s %s",
3596 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3597 fputc ('\n', asm_out_file);
3598 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
3599 {
3600 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
3601 a->dw_attr_val.v.val_float.array[i]);
3602 if (flag_verbose_asm)
3603 fprintf (asm_out_file, "\t%s fp constant word %d",
3604 ASM_COMMENT_START, i);
3605 fputc ('\n', asm_out_file);
3606 }
a3f97cbb
JW		 3607 break;
3608 case dw_val_class_flag:
3609 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
3610 break;
3611 case dw_val_class_die_ref:
3612 if (a->dw_attr_val.v.val_die_ref != NULL)
3613 {
3614 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
3615 }
3616 else if (a->dw_attr == DW_AT_sibling)
3617 {
3618 ref_offset = sibling_offset(die);
3619 }
3620 else
3621 {
3622 abort ();
3623 }
7e23cb16 3624 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
a3f97cbb
JW		 3625 break;
3626 case dw_val_class_fde_ref:
3627 ref_offset = fde_table[a->dw_attr_val.v.val_fde_index].dw_fde_offset;
7e23cb16 3628 fprintf (asm_out_file, "\t%s\t%s+0x%x", UNALIGNED_OFFSET_ASM_OP,
a3f97cbb
JW		 3629 stripattributes (FRAME_SECTION), ref_offset);
3630 break;
3631 case dw_val_class_lbl_id:
3632 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
3633 break;
3634 case dw_val_class_section_offset:
7e23cb16
JM		 3635 ASM_OUTPUT_DWARF_OFFSET
3636 (asm_out_file, stripattributes (a->dw_attr_val.v.val_section));
a3f97cbb
JW		 3637 break;
3638 case dw_val_class_str:
3639 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
3640 break;
3641 default:
3642 abort ();
3643 }
469ac993
JM		 3644 if (a->dw_attr_val.val_class != dw_val_class_loc
3645 && a->dw_attr_val.val_class != dw_val_class_long_long
3646 && a->dw_attr_val.val_class != dw_val_class_float)
a3f97cbb
JW		 3647 {
3648 if (flag_verbose_asm)
3649 {
3650 fprintf (asm_out_file, "\t%s %s",
3651 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3652 }
3653 fputc ('\n', asm_out_file);
3654 }
3655 }
3656 for (c = die->die_child; c != NULL; c = c->die_sib)
3657 {
3658 output_die (c);
3659 }
3660 if (die->die_child != NULL)
3661 {
3662 /* Add null byte to terminate sibling list. */
3663 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
b2932ae5
JM		 3664 if (flag_verbose_asm)
3665 fprintf (asm_out_file, "\t%s end of children of DIE 0x%x",
3666 ASM_COMMENT_START, die->die_offset);
a3f97cbb
JW		 3667 fputc ('\n', asm_out_file);
3668 }
3669}
3670
3671/* Output the compilation unit that appears at the beginning of the
3672 .debug_info section, and precedes the DIE descriptions. */
3673static void
3674output_compilation_unit_header ()
3675{
7e23cb16 3676 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
a3f97cbb
JW		 3677 if (flag_verbose_asm)
3678 {
3679 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
3680 ASM_COMMENT_START);
3681 }
3682 fputc ('\n', asm_out_file);
7e23cb16 3683 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
a3f97cbb
JW		 3684 if (flag_verbose_asm)
3685 {
3686 fprintf (asm_out_file, "\t%s DWARF version number",
3687 ASM_COMMENT_START);
3688 }
3689 fputc ('\n', asm_out_file);
7e23cb16 3690 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (ABBREV_SECTION));
a3f97cbb
JW		 3691 if (flag_verbose_asm)
3692 {
3693 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
3694 ASM_COMMENT_START);
3695 }
3696 fputc ('\n', asm_out_file);
7e23cb16 3697 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
a3f97cbb
JW		 3698 if (flag_verbose_asm)
3699 {
3700 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)",
3701 ASM_COMMENT_START);
3702 }
3703 fputc ('\n', asm_out_file);
3704}
3705
469ac993
JM		 3706/* Generate a new label for the CFI info to refer to. */
3707
3708char *
3709dwarf2out_cfi_label ()
a94dbf2c 3710{
469ac993
JM		 3711 static char label[20];
3712 static unsigned long label_num = 0;
3713
3714 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
3715 ASM_OUTPUT_LABEL (asm_out_file, label);
3716
3717 return label;
a94dbf2c
JM		 3718}
3719
3720/* Add CFI to the current fde at the PC value indicated by LABEL if specified,
3721 or to the CIE if LABEL is NULL. */
469ac993 3722
a94dbf2c
JM		 3723static void
3724add_fde_cfi (label, cfi)
3725 register char * label;
3726 register dw_cfi_ref cfi;
3727{
3728 if (label)
3729 {
3730 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
469ac993
JM		 3731 if (*label == 0)
3732 label = dwarf2out_cfi_label ();
a94dbf2c
JM		 3733 if (fde->dw_fde_current_label == NULL
3734 || strcmp (label, fde->dw_fde_current_label) != 0)
3735 {
3736 register dw_cfi_ref xcfi;
3737
3738 fde->dw_fde_current_label = label = xstrdup (label);
3739
3740 /* Set the location counter to the new label. */
3741 xcfi = new_cfi ();
3742 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
3743 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
3744 add_cfi (&fde->dw_fde_cfi, xcfi);
3745 }
3746 add_cfi (&fde->dw_fde_cfi, cfi);
3747 }
3748 else
3749 add_cfi (&cie_cfi_head, cfi);
3750}
3751
3752/* Subroutine of lookup_cfa. */
3753inline void
3754lookup_cfa_1 (cfi, regp, offsetp)
3755 register dw_cfi_ref cfi;
3756 register unsigned long *regp;
3757 register long *offsetp;
3758{
3759 switch (cfi->dw_cfi_opc)
3760 {
3761 case DW_CFA_def_cfa_offset:
3762 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
3763 break;
3764 case DW_CFA_def_cfa_register:
3765 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
3766 break;
3767 case DW_CFA_def_cfa:
3768 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
3769 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
3770 break;
3771 }
3772}
3773
3774/* Find the previous value for the CFA. */
3775static void
3776lookup_cfa (regp, offsetp)
3777 register unsigned long *regp;
3778 register long *offsetp;
3779{
3780 register dw_cfi_ref cfi;
3781 *regp = (unsigned long) -1;
3782 *offsetp = 0;
3783
3784 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
3785 lookup_cfa_1 (cfi, regp, offsetp);
3786 if (fde_table_in_use)
3787 {
3788 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
3789 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
3790 lookup_cfa_1 (cfi, regp, offsetp);
3791 }
3792}
3793
3794/* Entry point to update the canonical frame address (CFA).
469ac993
JM		 3795 LABEL is passed to add_fde_cfi. The value of CFA is now to be
3796 calculated from REG+OFFSET. */
a94dbf2c 3797
a94dbf2c 3798void
469ac993 3799dwarf2out_def_cfa (label, reg, offset)
a94dbf2c 3800 register char * label;
469ac993
JM		 3801 register unsigned reg;
3802 register long offset;
a94dbf2c
JM		 3803{
3804 register dw_cfi_ref cfi;
469ac993
JM		 3805 unsigned old_reg;
3806 long old_offset;
a94dbf2c 3807
469ac993 3808 reg = DWARF_FRAME_REGNUM (reg);
a94dbf2c
JM		 3809 lookup_cfa (&old_reg, &old_offset);
3810
3811 if (reg == old_reg && offset == old_offset)
3812 return;
3813
3814 cfi = new_cfi ();
3815
3816 if (reg == old_reg)
3817 {
3818 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
3819 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
3820 }
3821#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
3822 else if (offset == old_offset && old_reg != (unsigned long) -1)
3823 {
3824 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
3825 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3826 }
3827#endif
3828 else
3829 {
3830 cfi->dw_cfi_opc = DW_CFA_def_cfa;
3831 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3832 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
3833 }
3834
3835 add_fde_cfi (label, cfi);
3836}
3837
3838/* Add the CFI for saving a register. REG is the CFA column number.
3839 LABEL is passed to add_fde_cfi.
469ac993
JM		 3840 If SREG is -1, the register is saved at OFFSET from the CFA;
3841 otherwise it is saved in SREG. */
a94dbf2c 3842
a94dbf2c 3843static void
469ac993 3844reg_save (label, reg, sreg, offset)
a94dbf2c 3845 register char * label;
469ac993
JM		 3846 register unsigned reg;
3847 register unsigned sreg;
3848 register long offset;
a94dbf2c 3849{
469ac993 3850 register dw_cfi_ref cfi = new_cfi ();
a94dbf2c
JM		 3851
3852 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3853
469ac993 3854 if (sreg == -1)
a94dbf2c
JM		 3855 {
3856 if (reg & ~0x3f)
3857 /* The register number won't fit in 6 bits, so we have to use
3858 the long form. */
3859 cfi->dw_cfi_opc = DW_CFA_offset_extended;
3860 else
3861 cfi->dw_cfi_opc = DW_CFA_offset;
469ac993
JM		 3862
3863 offset /= DWARF_CIE_DATA_ALIGNMENT;
3864 assert (offset >= 0);
a94dbf2c
JM		 3865 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
3866 }
3867 else
3868 {
3869 cfi->dw_cfi_opc = DW_CFA_register;
3870 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
3871 }
3872
3873 add_fde_cfi (label, cfi);
3874}
3875
3876/* Entry point for saving a register. REG is the GCC register number.
469ac993
JM		 3877 LABEL and OFFSET are passed to reg_save. */
3878
a94dbf2c 3879void
469ac993 3880dwarf2out_reg_save (label, reg, offset)
a94dbf2c 3881 register char * label;
469ac993
JM		 3882 register unsigned reg;
3883 register long offset;
3884{
3885 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
3886}
3887
3888/* Record the initial position of the return address. RTL is
3889 INCOMING_RETURN_ADDR_RTX. */
3890
3891static void
3892initial_return_save (rtl)
a94dbf2c
JM		 3893 register rtx rtl;
3894{
469ac993
JM		 3895 unsigned reg = -1;
3896 long offset = 0;
3897
3898 switch (GET_CODE (rtl))
3899 {
3900 case REG:
3901 /* RA is in a register. */
3902 reg = reg_number (rtl);
3903 break;
3904 case MEM:
3905 /* RA is on the stack. */
3906 rtl = XEXP (rtl, 0);
3907 switch (GET_CODE (rtl))
3908 {
3909 case REG:
3910 assert (REGNO (rtl) == STACK_POINTER_REGNUM);
3911 offset = 0;
3912 break;
3913 case PLUS:
3914 assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
3915 offset = INTVAL (XEXP (rtl, 1));
3916 break;
3917 case MINUS:
3918 assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
3919 offset = -INTVAL (XEXP (rtl, 1));
3920 break;
3921 default:
3922 abort ();
3923 }
3924 break;
3925 default:
3926 abort ();
3927 }
3928
3929 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset);
a94dbf2c
JM		 3930}
3931
469ac993
JM		 3932/* Record call frame debugging information for INSN, which either
3933 sets SP or FP (adjusting how we calculate the frame address) or saves a
3934 register to the stack. If INSN is NULL_RTX, initialize our state. */
3935
a94dbf2c 3936void
469ac993
JM		 3937dwarf2out_frame_debug (insn)
3938 rtx insn;
a94dbf2c 3939{
469ac993
JM		 3940 char *label;
3941 rtx src, dest;
3942 long offset;
141719a8
JM		 3943
3944 /* The current rule for calculating the DWARF2 canonical frame address. */
469ac993
JM		 3945 static unsigned cfa_reg;
3946 static long cfa_offset;
141719a8
JM		 3947
3948 /* The register used for saving registers to the stack, and its offset
3949 from the CFA. */
3950 static unsigned cfa_store_reg;
3951 static long cfa_store_offset;
3952
3953 /* A temporary register used in adjusting SP or setting up the store_reg. */
3954 static unsigned cfa_temp_reg;
3955 static long cfa_temp_value;
469ac993
JM		 3956
3957 if (insn == NULL_RTX)
3958 {
3959 /* Set up state for generating call frame debug info. */
3960 cfa_reg = STACK_POINTER_REGNUM;
3961 cfa_offset = 0;
141719a8
JM		 3962 cfa_store_reg = STACK_POINTER_REGNUM;
3963 cfa_store_offset = 0;
3964 cfa_temp_reg = -1;
3965 cfa_temp_value = 0;
469ac993
JM		 3966 return;
3967 }
3968
3969 label = dwarf2out_cfi_label ();
3970
3971 insn = PATTERN (insn);
3972 assert (GET_CODE (insn) == SET);
3973
3974 src = SET_SRC (insn);
3975 dest = SET_DEST (insn);
3976
3977 switch (GET_CODE (dest))
3978 {
3979 case REG:
3980 /* Update the CFA rule wrt SP or FP. Make sure src is
3981 relative to the current CFA register. */
469ac993
JM		 3982 switch (GET_CODE (src))
3983 {
3984 /* Setting FP from SP. */
3985 case REG:
3986 assert (cfa_reg == REGNO (src));
141719a8
JM		 3987 assert (REGNO (dest) == STACK_POINTER_REGNUM
3988 || frame_pointer_needed && REGNO (dest) == FRAME_POINTER_REGNUM);
469ac993
JM		 3989 cfa_reg = REGNO (dest);
3990 break;
3991
469ac993 3992 case PLUS:
469ac993 3993 case MINUS:
141719a8
JM		 3994 if (dest == stack_pointer_rtx)
3995 {
3996 /* Adjusting SP. */
3997 switch (GET_CODE (XEXP (src, 1)))
3998 {
3999 case CONST_INT:
4000 offset = INTVAL (XEXP (src, 1));
4001 break;
4002 case REG:
4003 assert (REGNO (XEXP (src, 1)) == cfa_temp_reg);
4004 offset = cfa_temp_value;
4005 break;
4006 default:
4007 abort ();
4008 }
4009 if (GET_CODE (src) == PLUS)
4010 offset = -offset;
4011 if (cfa_reg == STACK_POINTER_REGNUM)
4012 cfa_offset += offset;
4013 if (cfa_store_reg == STACK_POINTER_REGNUM)
4014 cfa_store_offset += offset;
4015 assert (XEXP (src, 0) == stack_pointer_rtx);
4016 }
4017 else
4018 {
4019 /* Initializing the store base register. */
4020 assert (GET_CODE (src) == PLUS);
4021 assert (XEXP (src, 1) == stack_pointer_rtx);
4022 assert (GET_CODE (XEXP (src, 0)) == REG
4023 && REGNO (XEXP (src, 0)) == cfa_temp_reg);
4024 assert (cfa_store_reg == STACK_POINTER_REGNUM);
4025 cfa_store_reg = REGNO (dest);
4026 cfa_store_offset -= cfa_temp_value;
4027 }
4028 break;
4029
4030 case CONST_INT:
4031 cfa_temp_reg = REGNO (dest);
4032 cfa_temp_value = INTVAL (src);
469ac993
JM		 4033 break;
4034
4035 default:
4036 abort ();
4037 }
4038 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
4039 break;
4040
4041 case MEM:
4042 /* Saving a register to the stack. Make sure dest is relative to the
4043 CFA register. */
4044 assert (GET_CODE (src) == REG);
4045 switch (GET_CODE (XEXP (dest, 0)))
4046 {
4047 /* With a push. */
469ac993 4048 case PRE_INC:
141719a8
JM		 4049 case PRE_DEC:
4050 offset = GET_MODE_SIZE (GET_MODE (dest));
4051 if (GET_CODE (src) == PRE_INC)
4052 offset = -offset;
469ac993 4053 assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM);
141719a8
JM		 4054 assert (cfa_store_reg == STACK_POINTER_REGNUM);
4055 cfa_store_offset += offset;
469ac993 4056 if (cfa_reg == STACK_POINTER_REGNUM)
141719a8
JM		 4057 cfa_offset = cfa_store_offset;
4058 offset = -cfa_store_offset;
469ac993
JM		 4059 break;
4060
4061 /* With an offset. */
4062 case PLUS:
469ac993 4063 case MINUS:
141719a8
JM		 4064 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
4065 if (GET_CODE (src) == MINUS)
4066 offset = -offset;
4067 assert (cfa_store_reg == REGNO (XEXP (XEXP (dest, 0), 0)));
4068 offset -= cfa_store_offset;
469ac993
JM		 4069 break;
4070
4071 default:
4072 abort ();
4073 }
4074 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
4075 dwarf2out_reg_save (label, REGNO (src), offset);
4076 break;
4077
4078 default:
4079 abort ();
4080 }
a94dbf2c
JM		 4081}
4082
a3f97cbb
JW		 4083/* Return the size of a Call Frame Instruction. */
4084static unsigned long
4085size_of_cfi (cfi)
4086 dw_cfi_ref cfi;
4087{
4088 register unsigned long size;
4089 /* count the 1-byte opcode */
4090 size = 1;
4091 switch (cfi->dw_cfi_opc)
4092 {
4093 case DW_CFA_offset:
4094 size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4095 break;
4096 case DW_CFA_set_loc:
4097 size += PTR_SIZE;
4098 break;
4099 case DW_CFA_advance_loc1:
4100 size += 1;
4101 break;
4102 case DW_CFA_advance_loc2:
4103 size += 2;
4104 break;
4105 case DW_CFA_advance_loc4:
4106 size += 4;
4107 break;
4108#ifdef MIPS_DEBUGGING_INFO
4109 case DW_CFA_MIPS_advance_loc8:
4110 size += 8;
4111 break;
4112#endif
4113 case DW_CFA_offset_extended:
4114 case DW_CFA_def_cfa:
4115 size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4116 size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4117 break;
4118 case DW_CFA_restore_extended:
4119 case DW_CFA_undefined:
4120 size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4121 break;
4122 case DW_CFA_same_value:
4123 case DW_CFA_def_cfa_register:
4124 size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4125 break;
4126 case DW_CFA_register:
4127 size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4128 size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4129 break;
4130 case DW_CFA_def_cfa_offset:
4131 size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_offset);
4132 break;
4133 default:
4134 break;
4135 }
4136 return size;
4137}
4138
4139/* Return the size of an FDE sans the length word. */
4140inline unsigned long
4141size_of_fde (fde, npad)
4142 dw_fde_ref fde;
4143 unsigned long *npad;
4144{
4145 register dw_cfi_ref cfi;
4146 register unsigned long aligned_size;
4147 register unsigned long size;
4148 size = DWARF_FDE_HEADER_SIZE;
4149 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
4150 {
4151 size += size_of_cfi(cfi);
4152 }
7e23cb16
JM		 4153 /* Round the size up to a word boundary. */
4154 aligned_size = DWARF_ROUND (size, PTR_SIZE);
a3f97cbb
JW		 4155 *npad = aligned_size - size;
4156 return aligned_size;
4157}
4158
4159/* Calculate the size of the FDE table, and establish the offset
4160 of each FDE in the .debug_frame section. */
4161static void
4162calc_fde_sizes ()
4163{
4164 register unsigned long i;
4165 register dw_fde_ref fde;
4166 register unsigned long fde_size;
a94dbf2c 4167 register dw_cfi_ref cfi;
a3f97cbb 4168 unsigned long fde_pad;
a94dbf2c
JM		 4169
4170 cie_size = DWARF_CIE_HEADER_SIZE;
4171 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
4172 cie_size += size_of_cfi (cfi);
4173
4174 /* Initialize the beginning FDE offset. */
4175 next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
4176
a3f97cbb
JW		 4177 for (i = 0; i < fde_table_in_use; ++i)
4178 {
4179 fde = &fde_table[i];
4180 fde->dw_fde_offset = next_fde_offset;
4181 fde_size = size_of_fde (fde, &fde_pad);
4182 next_fde_offset += fde_size;
4183 }
4184}
4185
4186/* Output a Call Frame Information opcode and its operand(s). */
4187static void
4188output_cfi (cfi, fde)
4189 register dw_cfi_ref cfi;
4190 register dw_fde_ref fde;
4191{
4192 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
4193 {
4194 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4195 cfi->dw_cfi_opc
4196 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
4197 if (flag_verbose_asm)
469ac993
JM		 4198 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%x",
4199 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
a3f97cbb
JW		 4200 fputc ('\n', asm_out_file);
4201 }
4202 else if (cfi->dw_cfi_opc == DW_CFA_offset)
4203 {
4204 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4205 cfi->dw_cfi_opc
4206 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
4207 if (flag_verbose_asm)
469ac993
JM		 4208 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%x",
4209 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
a3f97cbb
JW		 4210 fputc ('\n', asm_out_file);
4211 output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4212 fputc ('\n', asm_out_file);
4213 }
4214 else if (cfi->dw_cfi_opc == DW_CFA_restore)
4215 {
4216 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4217 cfi->dw_cfi_opc
4218 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
4219 if (flag_verbose_asm)
469ac993
JM		 4220 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%x",
4221 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
a3f97cbb
JW		 4222 fputc ('\n', asm_out_file);
4223 }
4224 else
4225 {
4226 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
4227 if (flag_verbose_asm)
4228 {
4229 fprintf (asm_out_file, "\t%s %s",
4230 ASM_COMMENT_START,
4231 dwarf_cfi_name (cfi->dw_cfi_opc));
4232 }
4233 fputc ('\n', asm_out_file);
4234 switch (cfi->dw_cfi_opc)
4235 {
4236 case DW_CFA_set_loc:
4237 ASM_OUTPUT_DWARF_ADDR (asm_out_file,
4238 cfi->dw_cfi_oprnd1.dw_cfi_addr);
4239 fputc ('\n', asm_out_file);
4240 break;
4241 case DW_CFA_advance_loc1:
4242 /* TODO: not currently implemented. */
4243 abort ();
4244 break;
4245 case DW_CFA_advance_loc2:
4246 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
4247 cfi->dw_cfi_oprnd1.dw_cfi_addr,
a94dbf2c 4248 fde->dw_fde_current_label);
a3f97cbb 4249 fputc ('\n', asm_out_file);
a94dbf2c 4250 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
a3f97cbb
JW		 4251 break;
4252 case DW_CFA_advance_loc4:
4253 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
4254 cfi->dw_cfi_oprnd1.dw_cfi_addr,
a94dbf2c 4255 fde->dw_fde_current_label);
a3f97cbb 4256 fputc ('\n', asm_out_file);
a94dbf2c 4257 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
a3f97cbb
JW		 4258 break;
4259#ifdef MIPS_DEBUGGING_INFO
4260 case DW_CFA_MIPS_advance_loc8:
4261 /* TODO: not currently implemented. */
4262 abort ();
4263 break;
4264#endif
4265 case DW_CFA_offset_extended:
4266 case DW_CFA_def_cfa:
4267 output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4268 fputc ('\n', asm_out_file);
4269 output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4270 fputc ('\n', asm_out_file);
4271 break;
4272 case DW_CFA_restore_extended:
4273 case DW_CFA_undefined:
4274 output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4275 fputc ('\n', asm_out_file);
4276 break;
4277 case DW_CFA_same_value:
4278 case DW_CFA_def_cfa_register:
4279 output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4280 fputc ('\n', asm_out_file);
4281 break;
4282 case DW_CFA_register:
4283 output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4284 fputc ('\n', asm_out_file);
4285 output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4286 fputc ('\n', asm_out_file);
4287 break;
4288 case DW_CFA_def_cfa_offset:
4289 output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_offset);
4290 fputc ('\n', asm_out_file);
4291 break;
4292 default:
4293 break;
4294 }
4295 }
4296}
4297
4298/* Output the call frame information used to used to record information
4299 that relates to calculating the frame pointer, and records the
4300 location of saved registers. */
4301static void
4302output_call_frame_info ()
4303{
4304 register unsigned long i, j;
4305 register dw_fde_ref fde;
4306 register unsigned long fde_size;
a3f97cbb
JW		 4307 register dw_cfi_ref cfi;
4308 unsigned long fde_pad;
4309
b2932ae5
JM		 4310 /* Only output the info if it will be interesting. */
4311 for (i = 0; i < fde_table_in_use; ++i)
4312 if (fde_table[i].dw_fde_cfi != NULL)
4313 break;
4314 if (i == fde_table_in_use)
4315 return;
4316
a94dbf2c
JM		 4317 /* (re-)initialize the beginning FDE offset. */
4318 next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
4319
b2932ae5
JM		 4320 fputc ('\n', asm_out_file);
4321 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
4322
a3f97cbb 4323 /* Output the CIE. */
a94dbf2c 4324 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_fde_offset - DWARF_OFFSET_SIZE);
a3f97cbb
JW		 4325 if (flag_verbose_asm)
4326 {
4327 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
4328 ASM_COMMENT_START);
4329 }
4330 fputc ('\n', asm_out_file);
4331 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
4332 if (flag_verbose_asm)
4333 {
4334 fprintf (asm_out_file, "\t%s CIE Identifier Tag",
4335 ASM_COMMENT_START);
4336 }
4337 fputc ('\n', asm_out_file);
7e23cb16
JM		 4338 if (DWARF_OFFSET_SIZE == 8)
4339 {
4340 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
4341 fputc ('\n', asm_out_file);
4342 }
a3f97cbb
JW		 4343 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
4344 if (flag_verbose_asm)
4345 {
4346 fprintf (asm_out_file, "\t%s CIE Version",
4347 ASM_COMMENT_START);
4348 }
4349 fputc ('\n', asm_out_file);
4350 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4351 if (flag_verbose_asm)
4352 {
4353 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
4354 ASM_COMMENT_START);
4355 }
4356 fputc ('\n', asm_out_file);
4357 output_uleb128 (1);
4358 if (flag_verbose_asm)
b2932ae5 4359 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
a3f97cbb
JW		 4360 fputc ('\n', asm_out_file);
4361 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
4362 if (flag_verbose_asm)
b2932ae5 4363 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
a3f97cbb 4364 fputc ('\n', asm_out_file);
c8cc5c4a 4365 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
a3f97cbb
JW		 4366 if (flag_verbose_asm)
4367 {
4368 fprintf (asm_out_file, "\t%s CIE RA Column",
4369 ASM_COMMENT_START);
4370 }
4371 fputc ('\n', asm_out_file);
4372
a94dbf2c
JM		 4373 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
4374 output_cfi (cfi);
a3f97cbb
JW		 4375
4376 /* Pad the CIE out to an address sized boundary. */
a94dbf2c 4377 for (i = next_fde_offset - cie_size; i; --i)
a3f97cbb
JW		 4378 {
4379 /* Pad out to a pointer size boundary */
4380 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CFA_nop);
4381 if (flag_verbose_asm)
4382 {
4383 fprintf (asm_out_file, "\t%s CIE DW_CFA_nop (pad)",
4384 ASM_COMMENT_START);
4385 }
4386 fputc ('\n', asm_out_file);
4387 }
4388
4389 /* Loop through all of the FDE's. */
4390 for (i = 0; i < fde_table_in_use; ++i)
4391 {
4392 fde = &fde_table[i];
b2932ae5
JM		 4393 if (fde->dw_fde_cfi == NULL)
4394 continue;
a3f97cbb 4395 fde_size = size_of_fde (fde, &fde_pad);
7e23cb16 4396 ASM_OUTPUT_DWARF_DATA (asm_out_file, fde_size - DWARF_OFFSET_SIZE);
a3f97cbb
JW		 4397 if (flag_verbose_asm)
4398 {
4399 fprintf (asm_out_file, "\t%s FDE Length",
4400 ASM_COMMENT_START);
4401 }
4402 fputc ('\n', asm_out_file);
7e23cb16 4403 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
a3f97cbb
JW		 4404 if (flag_verbose_asm)
4405 {
4406 fprintf (asm_out_file, "\t%s FDE CIE offset",
4407 ASM_COMMENT_START);
4408 }
4409 fputc ('\n', asm_out_file);
4410 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
4411 if (flag_verbose_asm)
4412 {
4413 fprintf (asm_out_file, "\t%s FDE initial location",
4414 ASM_COMMENT_START);
4415 }
4416 fputc ('\n', asm_out_file);
7e23cb16
JM		 4417 ASM_OUTPUT_DWARF_ADDR_DELTA
4418 (asm_out_file, fde->dw_fde_end, fde->dw_fde_begin);
a3f97cbb
JW		 4419 if (flag_verbose_asm)
4420 {
4421 fprintf (asm_out_file, "\t%s FDE address range",
4422 ASM_COMMENT_START);
4423 }
4424 fputc ('\n', asm_out_file);
4425
4426 /* Loop through the Call Frame Instructions associated with
4427 this FDE. */
a94dbf2c 4428 fde->dw_fde_current_label = fde->dw_fde_begin;
a3f97cbb 4429 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
a94dbf2c 4430 output_cfi (cfi, fde);
a3f97cbb
JW		 4431
4432 /* Pad to a double word boundary. */
4433 for (j = 0; j < fde_pad; ++j)
4434 {
4435 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CFA_nop);
4436 if (flag_verbose_asm)
4437 {
4438 fprintf (asm_out_file, "\t%s CIE DW_CFA_nop (pad)",
4439 ASM_COMMENT_START);
4440 }
4441 fputc ('\n', asm_out_file);
4442 }
4443 }
4444}
4445
d291dd49
JM		 4446/* Add a new entry to .debug_pubnames if appropriate. */
4447static void
4448add_pubname (decl, die)
4449 tree decl;
4450 dw_die_ref die;
4451{
4452 pubname_ref p;
4453
4454 if (! TREE_PUBLIC (decl))
4455 return;
4456
4457 if (pubname_table_in_use == pubname_table_allocated)
4458 {
4459 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
4460 pubname_table = (pubname_ref) xrealloc
4461 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
4462 }
4463 p = &pubname_table[pubname_table_in_use++];
4464 p->die = die;
4465 p->name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4466}
4467
a3f97cbb
JW		 4468/* Output the public names table used to speed up access to externally
4469 visible names. For now, only generate entries for externally
4470 visible procedures. */
4471static void
4472output_pubnames ()
4473{
d291dd49
JM		 4474 register unsigned i;
4475 {
4476 register unsigned long pubnames_length = size_of_pubnames ();
7e23cb16 4477 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
d291dd49 4478 }
a3f97cbb
JW		 4479 if (flag_verbose_asm)
4480 {
4481 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
4482 ASM_COMMENT_START);
4483 }
4484 fputc ('\n', asm_out_file);
4485 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4486 if (flag_verbose_asm)
4487 {
4488 fprintf (asm_out_file, "\t%s DWARF Version",
4489 ASM_COMMENT_START);
4490 }
4491 fputc ('\n', asm_out_file);
7e23cb16 4492 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_SECTION));
a3f97cbb
JW		 4493 if (flag_verbose_asm)
4494 {
4495 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
4496 ASM_COMMENT_START);
4497 }
4498 fputc ('\n', asm_out_file);
7e23cb16 4499 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
a3f97cbb
JW		 4500 if (flag_verbose_asm)
4501 {
4502 fprintf (asm_out_file, "\t%s Compilation Unit Length",
4503 ASM_COMMENT_START);
4504 }
4505 fputc ('\n', asm_out_file);
d291dd49 4506 for (i = 0; i < pubname_table_in_use; ++i)
a3f97cbb 4507 {
d291dd49 4508 register pubname_ref pub = &pubname_table[i];
7e23cb16 4509 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
d291dd49 4510 if (flag_verbose_asm)
a3f97cbb 4511 {
d291dd49
JM		 4512 fprintf (asm_out_file, "\t%s DIE offset",
4513 ASM_COMMENT_START);
a3f97cbb 4514 }
d291dd49
JM		 4515 fputc ('\n', asm_out_file);
4516
4517 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
4518 if (flag_verbose_asm)
4519 {
4520 fprintf (asm_out_file, "%s external name",
4521 ASM_COMMENT_START);
4522 }
4523 fputc ('\n', asm_out_file);
a3f97cbb 4524 }
7e23cb16 4525 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
a3f97cbb
JW		 4526 fputc ('\n', asm_out_file);
4527}
4528
d291dd49
JM		 4529/* Add a new entry to .debug_aranges if appropriate. */
4530static void
4531add_arange (decl, die)
4532 tree decl;
4533 dw_die_ref die;
4534{
4535 if (! DECL_SECTION_NAME (decl))
4536 return;
4537
4538 if (arange_table_in_use == arange_table_allocated)
4539 {
4540 arange_table_allocated += ARANGE_TABLE_INCREMENT;
4541 arange_table = (arange_ref) xrealloc
4542 (arange_table, arange_table_allocated * sizeof (dw_die_ref));
4543 }
4544 arange_table[arange_table_in_use++] = die;
4545}
4546
a3f97cbb
JW		 4547/* Output the information that goes into the .debug_aranges table.
4548 Namely, define the beginning and ending address range of the
4549 text section generated for this compilation unit. */
4550static void
4551output_aranges ()
4552{
d291dd49
JM		 4553 register unsigned i;
4554 {
4555 register unsigned long aranges_length = size_of_aranges ();
7e23cb16 4556 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
d291dd49 4557 }
a3f97cbb
JW		 4558 if (flag_verbose_asm)
4559 {
4560 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
4561 ASM_COMMENT_START);
4562 }
4563 fputc ('\n', asm_out_file);
4564 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4565 if (flag_verbose_asm)
4566 {
4567 fprintf (asm_out_file, "\t%s DWARF Version",
4568 ASM_COMMENT_START);
4569 }
4570 fputc ('\n', asm_out_file);
7e23cb16 4571 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_SECTION));
a3f97cbb
JW		 4572 if (flag_verbose_asm)
4573 {
4574 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
4575 ASM_COMMENT_START);
4576 }
4577 fputc ('\n', asm_out_file);
4578 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
4579 if (flag_verbose_asm)
4580 {
4581 fprintf (asm_out_file, "\t%s Size of Address",
4582 ASM_COMMENT_START);
4583 }
4584 fputc ('\n', asm_out_file);
4585 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4586 if (flag_verbose_asm)
4587 {
4588 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
4589 ASM_COMMENT_START);
4590 }
4591 fputc ('\n', asm_out_file);
4592 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
7e23cb16
JM		 4593 if (PTR_SIZE == 8)
4594 fprintf (asm_out_file, ",0,0");
a3f97cbb
JW		 4595 if (flag_verbose_asm)
4596 {
7e23cb16
JM		 4597 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
4598 ASM_COMMENT_START, 2 * PTR_SIZE);
a3f97cbb
JW		 4599 }
4600 fputc ('\n', asm_out_file);
bdb669cb 4601 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
a3f97cbb
JW		 4602 if (flag_verbose_asm)
4603 {
4604 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
4605 }
4606 fputc ('\n', asm_out_file);
5c90448c 4607 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, TEXT_SECTION);
a3f97cbb
JW		 4608 if (flag_verbose_asm)
4609 {
4610 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
4611 }
4612 fputc ('\n', asm_out_file);
d291dd49
JM		 4613 for (i = 0; i < arange_table_in_use; ++i)
4614 {
4615 dw_die_ref a = arange_table[i];
4616 if (a->die_tag == DW_TAG_subprogram)
4617 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
4618 else
4619 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_string (a, DW_AT_name));
4620 if (flag_verbose_asm)
4621 {
4622 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
4623 }
4624 fputc ('\n', asm_out_file);
4625 if (a->die_tag == DW_TAG_subprogram)
7e23cb16
JM		 4626 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
4627 get_AT_low_pc (a));
d291dd49 4628 else
7e23cb16
JM		 4629 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
4630 get_AT_unsigned (a, DW_AT_byte_size));
d291dd49
JM		 4631 if (flag_verbose_asm)
4632 {
4633 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
4634 }
4635 fputc ('\n', asm_out_file);
4636 }
a3f97cbb 4637 /* Output the terminator words. */
7e23cb16 4638 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
a3f97cbb 4639 fputc ('\n', asm_out_file);
7e23cb16 4640 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
a3f97cbb
JW		 4641 fputc ('\n', asm_out_file);
4642}
4643
4644/* Output the source line number correspondence information. This
4645 information goes into the .debug_line section. */
4646static void
4647output_line_info ()
4648{
a3f97cbb
JW		 4649 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
4650 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
4651 register unsigned opc;
4652 register unsigned n_op_args;
a3f97cbb
JW		 4653 register unsigned long ft_index;
4654 register unsigned long lt_index;
4655 register unsigned long current_line;
4656 register long line_offset;
4657 register long line_delta;
4658 register unsigned long current_file;
e90b62db 4659 register unsigned long function;
7e23cb16 4660 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
a3f97cbb
JW		 4661 if (flag_verbose_asm)
4662 {
4663 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
4664 ASM_COMMENT_START);
4665 }
4666 fputc ('\n', asm_out_file);
4667 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4668 if (flag_verbose_asm)
4669 {
4670 fprintf (asm_out_file, "\t%s DWARF Version",
4671 ASM_COMMENT_START);
4672 }
4673 fputc ('\n', asm_out_file);
7e23cb16 4674 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
a3f97cbb
JW		 4675 if (flag_verbose_asm)
4676 {
4677 fprintf (asm_out_file, "\t%s Prolog Length",
4678 ASM_COMMENT_START);
4679 }
4680 fputc ('\n', asm_out_file);
4681 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
4682 if (flag_verbose_asm)
4683 {
4684 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
4685 ASM_COMMENT_START);
4686 }
4687 fputc ('\n', asm_out_file);
4688 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
4689 if (flag_verbose_asm)
4690 {
4691 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
4692 ASM_COMMENT_START);
4693 }
4694 fputc ('\n', asm_out_file);
4695 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
4696 if (flag_verbose_asm)
4697 {
4698 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
4699 ASM_COMMENT_START);
4700 }
4701 fputc ('\n', asm_out_file);
4702 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
4703 if (flag_verbose_asm)
4704 {
4705 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
4706 ASM_COMMENT_START);
4707 }
4708 fputc ('\n', asm_out_file);
4709 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
4710 if (flag_verbose_asm)
4711 {
4712 fprintf (asm_out_file, "\t%s Special Opcode Base",
4713 ASM_COMMENT_START);
4714 }
4715 fputc ('\n', asm_out_file);
4716 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
4717 {
4718 switch (opc)
4719 {
4720 case DW_LNS_advance_pc:
4721 case DW_LNS_advance_line:
4722 case DW_LNS_set_file:
4723 case DW_LNS_set_column:
4724 case DW_LNS_fixed_advance_pc:
4725 n_op_args = 1;
4726 break;
4727 default:
4728 n_op_args = 0;
4729 break;
4730 }
4731 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
4732 if (flag_verbose_asm)
4733 {
4734 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
4735 ASM_COMMENT_START, opc, n_op_args);
4736 }
4737 fputc ('\n', asm_out_file);
4738 }
4739 if (flag_verbose_asm)
4740 {
4741 fprintf (asm_out_file, "%s Include Directory Table\n",
4742 ASM_COMMENT_START);
4743 }
4744 /* Include directory table is empty, at present */
4745 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4746 fputc ('\n', asm_out_file);
4747 if (flag_verbose_asm)
4748 {
4749 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
4750 }
4751 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4752 {
4753 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
4754 if (flag_verbose_asm)
4755 {
4756 fprintf (asm_out_file, "%s File Entry: 0x%x",
4757 ASM_COMMENT_START, ft_index);
4758 }
4759 fputc ('\n', asm_out_file);
4760 /* Include directory index */
4761 output_uleb128 (0);
4762 fputc ('\n', asm_out_file);
4763 /* Modification time */
4764 output_uleb128 (0);
4765 fputc ('\n', asm_out_file);
4766 /* File length in bytes */
4767 output_uleb128 (0);
4768 fputc ('\n', asm_out_file);
4769 }
4770 /* Terminate the file name table */
4771 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4772 fputc ('\n', asm_out_file);
4773
4774 /* Set the address register to the first location in the text section */
4775 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4776 if (flag_verbose_asm)
4777 {
4778 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
4779 }
4780 fputc ('\n', asm_out_file);
4781 output_uleb128 (1 + PTR_SIZE);
4782 fputc ('\n', asm_out_file);
4783 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
4784 fputc ('\n', asm_out_file);
bdb669cb 4785 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
a3f97cbb
JW		 4786 fputc ('\n', asm_out_file);
4787
4788 /* Generate the line number to PC correspondence table, encoded as
4789 a series of state machine operations. */
4790 current_file = 1;
4791 current_line = 1;
bdb669cb 4792 strcpy (prev_line_label, TEXT_SECTION);
a3f97cbb
JW		 4793 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4794 {
e90b62db 4795 register dw_line_info_ref line_info;
a3f97cbb
JW		 4796 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4797 if (flag_verbose_asm)
4798 {
4799 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4800 ASM_COMMENT_START);
4801 }
4802 fputc ('\n', asm_out_file);
5c90448c 4803 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
a3f97cbb
JW		 4804 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4805 fputc ('\n', asm_out_file);
4806 line_info = &line_info_table[lt_index];
4807 if (line_info->dw_file_num != current_file)
4808 {
4809 current_file = line_info->dw_file_num;
4810 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
4811 if (flag_verbose_asm)
4812 {
4813 fprintf (asm_out_file,
4814 "\t%s DW_LNS_set_file", ASM_COMMENT_START);
4815 }
4816 fputc ('\n', asm_out_file);
4817 output_uleb128 (current_file);
4818 if (flag_verbose_asm)
b2932ae5 4819 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
a3f97cbb
JW		 4820 fputc ('\n', asm_out_file);
4821 }
a94dbf2c
JM		 4822 line_offset = line_info->dw_line_num - current_line;
4823 line_delta = line_offset - DWARF_LINE_BASE;
4824 current_line = line_info->dw_line_num;
4825 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
a3f97cbb 4826 {
a94dbf2c
JM		 4827 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4828 DWARF_LINE_OPCODE_BASE + line_delta);
4829 if (flag_verbose_asm)
a3f97cbb 4830 {
a94dbf2c
JM		 4831 fprintf (asm_out_file,
4832 "\t%s line %d", ASM_COMMENT_START, current_line);
a3f97cbb 4833 }
a94dbf2c
JM		 4834 fputc ('\n', asm_out_file);
4835 }
4836 else
4837 {
4838 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
4839 if (flag_verbose_asm)
a3f97cbb 4840 {
a94dbf2c
JM		 4841 fprintf (asm_out_file,
4842 "\t%s advance to line %d",
4843 ASM_COMMENT_START, current_line);
a3f97cbb 4844 }
a94dbf2c
JM		 4845 fputc ('\n', asm_out_file);
4846 output_sleb128 (line_offset);
4847 fputc ('\n', asm_out_file);
4848 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
4849 fputc ('\n', asm_out_file);
a3f97cbb
JW		 4850 }
4851 strcpy (prev_line_label, line_label);
4852 }
4853
bdb669cb 4854 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
a3f97cbb
JW		 4855 if (flag_verbose_asm)
4856 {
bdb669cb
JM		 4857 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4858 ASM_COMMENT_START);
a3f97cbb
JW		 4859 }
4860 fputc ('\n', asm_out_file);
5c90448c 4861 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
a3f97cbb 4862 fputc ('\n', asm_out_file);
bdb669cb 4863
a3f97cbb
JW		 4864 /* Output the marker for the end of the line number info. */
4865 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4866 if (flag_verbose_asm)
4867 {
4868 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
4869 }
4870 fputc ('\n', asm_out_file);
4871 output_uleb128 (1);
4872 fputc ('\n', asm_out_file);
4873 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
4874 fputc ('\n', asm_out_file);
e90b62db
JM		 4875
4876 function = 0;
4877 current_file = 1;
4878 current_line = 1;
4879 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4880 {
4881 register dw_separate_line_info_ref line_info
4882 = &separate_line_info_table[lt_index];
5c90448c
JM		 4883 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
4884 lt_index);
e90b62db
JM		 4885 if (function != line_info->function)
4886 {
4887 function = line_info->function;
4888 /* Set the address register to the first line in the function */
4889 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4890 if (flag_verbose_asm)
4891 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
4892 ASM_COMMENT_START);
4893 fputc ('\n', asm_out_file);
4894 output_uleb128 (1 + PTR_SIZE);
4895 fputc ('\n', asm_out_file);
4896 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
4897 fputc ('\n', asm_out_file);
4898 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
4899 fputc ('\n', asm_out_file);
4900 }
4901 else
4902 {
4903 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4904 if (flag_verbose_asm)
4905 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4906 ASM_COMMENT_START);
4907 fputc ('\n', asm_out_file);
4908 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4909 fputc ('\n', asm_out_file);
4910 }
4911 if (line_info->dw_file_num != current_file)
4912 {
4913 current_file = line_info->dw_file_num;
4914 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
4915 if (flag_verbose_asm)
4916 {
4917 fprintf (asm_out_file,
4918 "\t%s DW_LNS_set_file", ASM_COMMENT_START);
4919 }
4920 fputc ('\n', asm_out_file);
4921 output_uleb128 (current_file);
4922 if (flag_verbose_asm)
b2932ae5 4923 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
e90b62db
JM		 4924 fputc ('\n', asm_out_file);
4925 }
4926 if (line_info->dw_line_num != current_line)
4927 {
4928 line_offset = line_info->dw_line_num - current_line;
4929 line_delta = line_offset - DWARF_LINE_BASE;
4930 current_line = line_info->dw_line_num;
4931 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4932 {
4933 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4934 DWARF_LINE_OPCODE_BASE + line_delta);
4935 if (flag_verbose_asm)
4936 {
4937 fprintf (asm_out_file,
4938 "\t%s line %d", ASM_COMMENT_START, current_line);
4939 }
4940 fputc ('\n', asm_out_file);
4941 }
4942 else
4943 {
4944 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
4945 if (flag_verbose_asm)
4946 {
4947 fprintf (asm_out_file,
4948 "\t%s advance to line %d",
4949 ASM_COMMENT_START, current_line);
4950 }
4951 fputc ('\n', asm_out_file);
4952 output_sleb128 (line_offset);
4953 fputc ('\n', asm_out_file);
4954 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
4955 fputc ('\n', asm_out_file);
4956 }
4957 }
4958 ++lt_index;
4959 strcpy (prev_line_label, line_label);
4960
4961 /* If we're done with a function, end its sequence. */
4962 if (lt_index == separate_line_info_table_in_use
4963 || separate_line_info_table[lt_index].function != function)
4964 {
4965 current_file = 1;
4966 current_line = 1;
4967 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4968 if (flag_verbose_asm)
4969 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4970 ASM_COMMENT_START);
4971 fputc ('\n', asm_out_file);
5c90448c 4972 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
e90b62db
JM		 4973 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4974 fputc ('\n', asm_out_file);
4975
4976 /* Output the marker for the end of this sequence. */
4977 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4978 if (flag_verbose_asm)
4979 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
4980 ASM_COMMENT_START);
4981 fputc ('\n', asm_out_file);
4982 output_uleb128 (1);
4983 fputc ('\n', asm_out_file);
4984 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
4985 fputc ('\n', asm_out_file);
4986 }
4987 }
a3f97cbb
JW		 4988}
4989\f
4990/**************** attribute support utilities ********************************/
4991
4992/*
4993 * Given a pointer to a BLOCK node return non-zero if (and only if) the node
4994 * in question represents the outermost pair of curly braces (i.e. the "body
4995 * block") of a function or method.
4996 *
4997 * For any BLOCK node representing a "body block" of a function or method, the
4998 * BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
4999 * represents the outermost (function) scope for the function or method (i.e.
5000 * the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
5001 * *that* node in turn will point to the relevant FUNCTION_DECL node.
5002 */
5003inline int
5004is_body_block (stmt)
5005 register tree stmt;
5006{
5007 if (TREE_CODE (stmt) == BLOCK)
5008 {
5009 register tree parent = BLOCK_SUPERCONTEXT (stmt);
5010
5011 if (TREE_CODE (parent) == BLOCK)
5012 {
5013 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
5014
5015 if (TREE_CODE (grandparent) == FUNCTION_DECL)
5016 return 1;
5017 }
5018 }
5019 return 0;
5020}
5021
a3f97cbb
JW		 5022/* Given a pointer to a tree node for some base type, return a pointer to
5023 a DIE that describes the given type.
5024
5025 This routine must only be called for GCC type nodes that correspond to
5026 Dwarf base (fundamental) types. */
5027static dw_die_ref
5028base_type_die (type)
5029 register tree type;
5030{
a9d38797
JM		 5031 register dw_die_ref base_type_result;
5032 register char *type_name;
5033 register enum dwarf_type encoding;
a3f97cbb 5034
a9d38797
JM		 5035 if (TREE_CODE (type) == ERROR_MARK
5036 || TREE_CODE (type) == VOID_TYPE)
a3f97cbb
JW		 5037 return 0;
5038
a9d38797
JM		 5039 {
5040 register tree name = TYPE_NAME (type);
5041 if (TREE_CODE (name) == TYPE_DECL)
5042 name = DECL_NAME (name);
5043 type_name = IDENTIFIER_POINTER (name);
5044 }
5045
a3f97cbb
JW		 5046 switch (TREE_CODE (type))
5047 {
a3f97cbb 5048 case INTEGER_TYPE:
a9d38797 5049 /* Carefully distinguish the C character types, without messing
a3f97cbb
JW		 5050 up if the language is not C. Note that we check only for the names
5051 that contain spaces; other names might occur by coincidence in other
5052 languages. */
a9d38797
JM		 5053 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
5054 && (type == char_type_node
5055 || ! strcmp (type_name, "signed char")
5056 || ! strcmp (type_name, "unsigned char"))))
a3f97cbb 5057 {
a9d38797
JM		 5058 if (TREE_UNSIGNED (type))
5059 encoding = DW_ATE_unsigned;
5060 else
5061 encoding = DW_ATE_signed;
5062 break;
a3f97cbb 5063 }
a9d38797 5064 /* else fall through */
a3f97cbb 5065
a9d38797
JM		 5066 case CHAR_TYPE:
5067 /* GNU Pascal/Ada CHAR type. Not used in C. */
5068 if (TREE_UNSIGNED (type))
5069 encoding = DW_ATE_unsigned_char;
5070 else
5071 encoding = DW_ATE_signed_char;
a3f97cbb
JW		 5072 break;
5073
5074 case REAL_TYPE:
a9d38797 5075 encoding = DW_ATE_float;
a3f97cbb
JW		 5076 break;
5077
5078 case COMPLEX_TYPE:
a9d38797 5079 encoding = DW_ATE_complex_float;
a3f97cbb
JW		 5080 break;
5081
5082 case BOOLEAN_TYPE:
a9d38797
JM		 5083 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
5084 encoding = DW_ATE_boolean;
a3f97cbb
JW		 5085 break;
5086
5087 default:
a9d38797 5088 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
a3f97cbb
JW		 5089 }
5090
a9d38797
JM		 5091 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
5092 add_AT_string (base_type_result, DW_AT_name, type_name);
5093 add_AT_unsigned (base_type_result, DW_AT_byte_size,
5094 TYPE_PRECISION (type) / BITS_PER_UNIT);
5095 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
a3f97cbb
JW		 5096
5097 return base_type_result;
5098}
5099
5100/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
5101 the Dwarf "root" type for the given input type. The Dwarf "root" type of
5102 a given type is generally the same as the given type, except that if the
5103 given type is a pointer or reference type, then the root type of the given
5104 type is the root type of the "basis" type for the pointer or reference
5105 type. (This definition of the "root" type is recursive.) Also, the root
5106 type of a `const' qualified type or a `volatile' qualified type is the
5107 root type of the given type without the qualifiers. */
5108static tree
5109root_type (type)
5110 register tree type;
5111{
5112 if (TREE_CODE (type) == ERROR_MARK)
5113 return error_mark_node;
5114
5115 switch (TREE_CODE (type))
5116 {
5117 case ERROR_MARK:
5118 return error_mark_node;
5119
5120 case POINTER_TYPE:
5121 case REFERENCE_TYPE:
5122 return type_main_variant (root_type (TREE_TYPE (type)));
5123
5124 default:
5125 return type_main_variant (type);
5126 }
5127}
5128
5129/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
5130 given input type is a Dwarf "fundamental" type. Otherwise return null. */
5131inline int
5132is_base_type (type)
5133 register tree type;
5134{
5135 switch (TREE_CODE (type))
5136 {
5137 case ERROR_MARK:
5138 case VOID_TYPE:
5139 case INTEGER_TYPE:
5140 case REAL_TYPE:
5141 case COMPLEX_TYPE:
5142 case BOOLEAN_TYPE:
5143 case CHAR_TYPE:
5144 return 1;
5145
5146 case SET_TYPE:
5147 case ARRAY_TYPE:
5148 case RECORD_TYPE:
5149 case UNION_TYPE:
5150 case QUAL_UNION_TYPE:
5151 case ENUMERAL_TYPE:
5152 case FUNCTION_TYPE:
5153 case METHOD_TYPE:
5154 case POINTER_TYPE:
5155 case REFERENCE_TYPE:
5156 case FILE_TYPE:
5157 case OFFSET_TYPE:
5158 case LANG_TYPE:
5159 return 0;
5160
5161 default:
5162 abort ();
5163 }
5164 return 0;
5165}
5166
5167/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
5168 entry that chains various modifiers in front of the given type. */
5169static dw_die_ref
5170modified_type_die (type, is_const_type, is_volatile_type, context_die)
5171 register tree type;
5172 register int is_const_type;
5173 register int is_volatile_type;
5174 register dw_die_ref context_die;
5175{
5176 register enum tree_code code = TREE_CODE (type);
5177 register dw_die_ref mod_type_die = NULL;
5178 register dw_die_ref sub_die = NULL;
5179 register tree item_type;
5180
5181 if (code != ERROR_MARK)
5182 {
a94dbf2c 5183 type = build_type_variant (type, is_const_type, is_volatile_type);
bdb669cb
JM		 5184
5185 mod_type_die = lookup_type_die (type);
5186 if (mod_type_die)
5187 return mod_type_die;
5188
a94dbf2c
JM		 5189 /* Handle C typedef types. */
5190 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5191 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
5192 {
5193 tree dtype = TREE_TYPE (TYPE_NAME (type));
5194 if (type == dtype)
5195 {
5196 /* For a named type, use the typedef. */
5197 gen_type_die (type, context_die);
5198 mod_type_die = lookup_type_die (type);
5199 }
5200 else if (is_const_type < TYPE_READONLY (dtype)
5201 || is_volatile_type < TYPE_VOLATILE (dtype))
5202 /* cv-unqualified version of named type. Just use the unnamed
5203 type to which it refers. */
5204 mod_type_die = modified_type_die
5205 (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
5206 is_const_type, is_volatile_type);
5207 /* else cv-qualified version of named type; fall through. */
5208 }
5209
5210 if (mod_type_die)
5211 /* OK */;
5212 else if (is_const_type)
a3f97cbb 5213 {
ab72d377 5214 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
a9d38797 5215 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
a3f97cbb
JW		 5216 }
5217 else if (is_volatile_type)
5218 {
ab72d377 5219 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
a9d38797 5220 sub_die = modified_type_die (type, 0, 0, context_die);
a3f97cbb
JW		 5221 }
5222 else if (code == POINTER_TYPE)
5223 {
ab72d377 5224 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
a3f97cbb 5225 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
61b32c02 5226#if 0
a3f97cbb 5227 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
61b32c02 5228#endif
a3f97cbb
JW		 5229 item_type = TREE_TYPE (type);
5230 sub_die = modified_type_die (item_type,
5231 TYPE_READONLY (item_type),
5232 TYPE_VOLATILE (item_type),
5233 context_die);
5234 }
5235 else if (code == REFERENCE_TYPE)
5236 {
ab72d377 5237 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
a3f97cbb 5238 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
61b32c02 5239#if 0
a3f97cbb 5240 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
61b32c02 5241#endif
a3f97cbb
JW		 5242 item_type = TREE_TYPE (type);
5243 sub_die = modified_type_die (item_type,
5244 TYPE_READONLY (item_type),
5245 TYPE_VOLATILE (item_type),
5246 context_die);
5247 }
5248 else if (is_base_type (type))
5249 {
5250 mod_type_die = base_type_die (type);
5251 }
5252 else
5253 {
4b674448
JM		 5254 gen_type_die (type, context_die);
5255
a3f97cbb
JW		 5256 /* We have to get the type_main_variant here (and pass that to the
5257 `lookup_type_die' routine) because the ..._TYPE node we have
5258 might simply be a *copy* of some original type node (where the
5259 copy was created to help us keep track of typedef names) and
5260 that copy might have a different TYPE_UID from the original
a94dbf2c 5261 ..._TYPE node. */
a3f97cbb 5262 mod_type_die = lookup_type_die (type_main_variant (type));
a94dbf2c 5263 assert (mod_type_die != NULL);
a3f97cbb
JW		 5264 }
5265 }
5266 if (sub_die != NULL)
5267 {
5268 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
5269 }
bdb669cb 5270 equate_type_number_to_die (type, mod_type_die);
a3f97cbb
JW		 5271 return mod_type_die;
5272}
5273
a3f97cbb
JW		 5274/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
5275 an enumerated type. */
5276inline int
5277type_is_enum (type)
5278 register tree type;
5279{
5280 return TREE_CODE (type) == ENUMERAL_TYPE;
5281}
5282
5283/* Return the register number described by a given RTL node. */
5284static unsigned
5285reg_number (rtl)
5286 register rtx rtl;
5287{
5288 register unsigned regno = REGNO (rtl);
5289
5290 if (regno >= FIRST_PSEUDO_REGISTER)
5291 {
5292 warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
5293 regno);
5294 regno = 0;
5295 }
5296 regno = DBX_REGISTER_NUMBER (regno);
5297 return regno;
5298}
5299
5300/* Return a location descriptor that designates a machine register. */
5301static dw_loc_descr_ref
5302reg_loc_descriptor (rtl)
5303 register rtx rtl;
5304{
5305 register dw_loc_descr_ref loc_result = NULL;
5306 register unsigned reg = reg_number (rtl);
5307 if (reg >= 0 && reg <= 31)
5308 {
5309 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0);
5310 }
5311 else
5312 {
5313 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
5314 }
5315 return loc_result;
5316}
5317
5318/* Return a location descriptor that designates a base+offset location. */
5319static dw_loc_descr_ref
5320based_loc_descr (reg, offset)
5321 unsigned reg;
5322 long int offset;
5323{
5324 register dw_loc_descr_ref loc_result;
810429b7
JM		 5325 /* For the "frame base", we use the frame pointer or stack pointer
5326 registers, since the RTL for local variables is relative to one of
5327 them. */
5328 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
5329 ? FRAME_POINTER_REGNUM
5330 : STACK_POINTER_REGNUM);
a3f97cbb
JW		 5331 if (reg == fp_reg)
5332 {
810429b7 5333 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
a3f97cbb
JW		 5334 }
5335 else if (reg >= 0 && reg <= 31)
5336 {
5337 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset);
5338 }
5339 else
5340 {
5341 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
5342 }
5343 return loc_result;
5344}
5345
5346/* Return true if this RTL expression describes a base+offset calculation. */
5347inline int
5348is_based_loc (rtl)
5349 register rtx rtl;
5350{
5351 return GET_CODE (rtl) == PLUS
5352 && ((GET_CODE (XEXP (rtl, 0)) == REG
5353 && GET_CODE (XEXP (rtl, 1)) == CONST_INT));
5354}
5355
5356/* The following routine converts the RTL for a variable or parameter
5357 (resident in memory) into an equivalent Dwarf representation of a
5358 mechanism for getting the address of that same variable onto the top of a
5359 hypothetical "address evaluation" stack.
5360 When creating memory location descriptors, we are effectively transforming
5361 the RTL for a memory-resident object into its Dwarf postfix expression
5362 equivalent. This routine recursively descends an RTL tree, turning
5363 it into Dwarf postfix code as it goes. */
5364static dw_loc_descr_ref
5365mem_loc_descriptor (rtl)
5366 register rtx rtl;
5367{
5368 dw_loc_descr_ref mem_loc_result = NULL;
5369 /* Note that for a dynamically sized array, the location we will generate a
5370 description of here will be the lowest numbered location which is
5371 actually within the array. That's *not* necessarily the same as the
5372 zeroth element of the array. */
5373 switch (GET_CODE (rtl))
5374 {
5375 case SUBREG:
5376 /* The case of a subreg may arise when we have a local (register)
5377 variable or a formal (register) parameter which doesn't quite fill
5378 up an entire register. For now, just assume that it is
5379 legitimate to make the Dwarf info refer to the whole register which
5380 contains the given subreg. */
5381 rtl = XEXP (rtl, 0);
5382 /* Drop thru. */
5383
5384 case REG:
5385 /* Whenever a register number forms a part of the description of the
5386 method for calculating the (dynamic) address of a memory resident
5387 object, DWARF rules require the register number be referred to as
5388 a "base register". This distinction is not based in any way upon
5389 what category of register the hardware believes the given register
5390 belongs to. This is strictly DWARF terminology we're dealing with
5391 here. Note that in cases where the location of a memory-resident
5392 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
5393 OP_CONST (0)) the actual DWARF location descriptor that we generate
5394 may just be OP_BASEREG (basereg). This may look deceptively like
5395 the object in question was allocated to a register (rather than in
5396 memory) so DWARF consumers need to be aware of the subtle
5397 distinction between OP_REG and OP_BASEREG. */
5398 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
5399 break;
5400
5401 case MEM:
5402 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
5403 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
5404 break;
5405
5406 case CONST:
5407 case SYMBOL_REF:
5408 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
5409 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
5410 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
5411 break;
5412
5413 case PLUS:
5414 if (is_based_loc (rtl))
5415 {
5416 mem_loc_result = based_loc_descr (
5417 reg_number (XEXP (rtl, 0)),
5418 INTVAL (XEXP (rtl, 1)));
5419 }
5420 else
5421 {
5422 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
5423 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
5424 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
5425 }
5426 break;
5427
dd2478ae
JW		 5428 case MULT:
5429 /* If a pseudo-reg is optimized away, it is possible for it to
5430 be replaced with a MEM containing a multiply. */
5431 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
5432 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
5433 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
5434 break;
5435
a3f97cbb
JW		 5436 case CONST_INT:
5437 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
5438 break;
5439
5440 default:
5441 abort ();
5442 }
5443 return mem_loc_result;
5444}
5445
5446/* Output a proper Dwarf location descriptor for a variable or parameter
5447 which is either allocated in a register or in a memory location. For a
5448 register, we just generate an OP_REG and the register number. For a
5449 memory location we provide a Dwarf postfix expression describing how to
5450 generate the (dynamic) address of the object onto the address stack. */
5451static dw_loc_descr_ref
5452loc_descriptor (rtl)
5453 register rtx rtl;
5454{
5455 dw_loc_descr_ref loc_result = NULL;
5456 switch (GET_CODE (rtl))
5457 {
5458 case SUBREG:
5459
5460 /* The case of a subreg may arise when we have a local (register)
5461 variable or a formal (register) parameter which doesn't quite fill
5462 up an entire register. For now, just assume that it is
5463 legitimate to make the Dwarf info refer to the whole register which
5464 contains the given subreg. */
5465
5466 rtl = XEXP (rtl, 0);
5c90448c 5467 /* fall through */
a3f97cbb
JW		 5468
5469 case REG:
5c90448c 5470 loc_result = reg_loc_descriptor (rtl);
a3f97cbb
JW		 5471 break;
5472
5473 case MEM:
5474 loc_result = mem_loc_descriptor (XEXP (rtl, 0));
5475 break;
5476
5477 default:
5478 abort (); /* Should never happen */
5479 }
5480 return loc_result;
5481}
5482
5483/* Given an unsigned value, round it up to the lowest multiple of `boundary'
5484 which is not less than the value itself. */
5485inline unsigned
5486ceiling (value, boundary)
5487 register unsigned value;
5488 register unsigned boundary;
5489{
5490 return (((value + boundary - 1) / boundary) * boundary);
5491}
5492
5493/* Given a pointer to what is assumed to be a FIELD_DECL node, return a
5494 pointer to the declared type for the relevant field variable, or return
5495 `integer_type_node' if the given node turns out to be an
5496 ERROR_MARK node. */
5497inline tree
5498field_type (decl)
5499 register tree decl;
5500{
5501 register tree type;
5502
5503 if (TREE_CODE (decl) == ERROR_MARK)
5504 return integer_type_node;
5505
5506 type = DECL_BIT_FIELD_TYPE (decl);
5507 if (type == NULL)
5508 type = TREE_TYPE (decl);
5509
5510 return type;
5511}
5512
5513/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
5514 node, return the alignment in bits for the type, or else return
5515 BITS_PER_WORD if the node actually turns out to be an
5516 ERROR_MARK node. */
5517inline unsigned
5518simple_type_align_in_bits (type)
5519 register tree type;
5520{
5521 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
5522}
5523
5524/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
5525 node, return the size in bits for the type if it is a constant, or else
5526 return the alignment for the type if the type's size is not constant, or
5527 else return BITS_PER_WORD if the type actually turns out to be an
5528 ERROR_MARK node. */
5529inline unsigned
5530simple_type_size_in_bits (type)
5531 register tree type;
5532{
5533 if (TREE_CODE (type) == ERROR_MARK)
5534 return BITS_PER_WORD;
5535 else
5536 {
5537 register tree type_size_tree = TYPE_SIZE (type);
5538
5539 if (TREE_CODE (type_size_tree) != INTEGER_CST)
5540 return TYPE_ALIGN (type);
5541
5542 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
5543 }
5544}
5545
5546/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
5547 return the byte offset of the lowest addressed byte of the "containing
5548 object" for the given FIELD_DECL, or return 0 if we are unable to
5549 determine what that offset is, either because the argument turns out to
5550 be a pointer to an ERROR_MARK node, or because the offset is actually
5551 variable. (We can't handle the latter case just yet). */
5552static unsigned
5553field_byte_offset (decl)
5554 register tree decl;
5555{
5556 register unsigned type_align_in_bytes;
5557 register unsigned type_align_in_bits;
5558 register unsigned type_size_in_bits;
5559 register unsigned object_offset_in_align_units;
5560 register unsigned object_offset_in_bits;
5561 register unsigned object_offset_in_bytes;
5562 register tree type;
5563 register tree bitpos_tree;
5564 register tree field_size_tree;
5565 register unsigned bitpos_int;
5566 register unsigned deepest_bitpos;
5567 register unsigned field_size_in_bits;
5568
5569 if (TREE_CODE (decl) == ERROR_MARK)
5570 return 0;
5571
5572 if (TREE_CODE (decl) != FIELD_DECL)
5573 abort ();
5574
5575 type = field_type (decl);
5576
5577 bitpos_tree = DECL_FIELD_BITPOS (decl);
5578 field_size_tree = DECL_SIZE (decl);
5579
5580 /* We cannot yet cope with fields whose positions or sizes are variable, so
5581 for now, when we see such things, we simply return 0. Someday, we may
5582 be able to handle such cases, but it will be damn difficult. */
5583 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
5584 return 0;
5585 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
5586
5587 if (TREE_CODE (field_size_tree) != INTEGER_CST)
5588 return 0;
5589 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
5590
5591 type_size_in_bits = simple_type_size_in_bits (type);
5592
5593 type_align_in_bits = simple_type_align_in_bits (type);
5594 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
5595
5596 /* Note that the GCC front-end doesn't make any attempt to keep track of
5597 the starting bit offset (relative to the start of the containing
5598 structure type) of the hypothetical "containing object" for a bit-
5599 field. Thus, when computing the byte offset value for the start of the
5600 "containing object" of a bit-field, we must deduce this information on
5601 our own. This can be rather tricky to do in some cases. For example,
5602 handling the following structure type definition when compiling for an
5603 i386/i486 target (which only aligns long long's to 32-bit boundaries)
5604 can be very tricky:
5605
5606 struct S { int field1; long long field2:31; };
5607
5608 Fortunately, there is a simple rule-of-thumb which can be
5609 used in such cases. When compiling for an i386/i486, GCC will allocate
5610 8 bytes for the structure shown above. It decides to do this based upon
5611 one simple rule for bit-field allocation. Quite simply, GCC allocates
5612 each "containing object" for each bit-field at the first (i.e. lowest
5613 addressed) legitimate alignment boundary (based upon the required
5614 minimum alignment for the declared type of the field) which it can
5615 possibly use, subject to the condition that there is still enough
5616 available space remaining in the containing object (when allocated at
5617 the selected point) to fully accommodate all of the bits of the
5618 bit-field itself. This simple rule makes it obvious why GCC allocates
5619 8 bytes for each object of the structure type shown above. When looking
5620 for a place to allocate the "containing object" for `field2', the
5621 compiler simply tries to allocate a 64-bit "containing object" at each
5622 successive 32-bit boundary (starting at zero) until it finds a place to
5623 allocate that 64- bit field such that at least 31 contiguous (and
5624 previously unallocated) bits remain within that selected 64 bit field.
5625 (As it turns out, for the example above, the compiler finds that it is
5626 OK to allocate the "containing object" 64-bit field at bit-offset zero
5627 within the structure type.) Here we attempt to work backwards from the
5628 limited set of facts we're given, and we try to deduce from those facts,
5629 where GCC must have believed that the containing object started (within
5630 the structure type). The value we deduce is then used (by the callers of
5631 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
5632 for fields (both bit-fields and, in the case of DW_AT_location, regular
5633 fields as well). */
5634
5635 /* Figure out the bit-distance from the start of the structure to the
5636 "deepest" bit of the bit-field. */
5637 deepest_bitpos = bitpos_int + field_size_in_bits;
5638
5639 /* This is the tricky part. Use some fancy footwork to deduce where the
5640 lowest addressed bit of the containing object must be. */
5641 object_offset_in_bits
5642 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
5643
5644 /* Compute the offset of the containing object in "alignment units". */
5645 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
5646
5647 /* Compute the offset of the containing object in bytes. */
5648 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
5649
5650 return object_offset_in_bytes;
5651}
5652
5653
5654\f
5655/****************************** attributes *********************************/
5656
5657/* The following routines define various Dwarf attributes
5658 (and any data associated with them). */
5659
5660
5661/* Output the form of location attributes suitable for whole variables and
5662 whole parameters. Note that the location attributes for struct fields are
5663 generated by the routine `data_member_location_attribute' below. */
5664static void
5665add_location_attribute (die, rtl)
5666 dw_die_ref die;
5667 register rtx rtl;
5668{
5669 dw_loc_descr_ref loc_descr = NULL;
5670
5671 /* Handle a special case. If we are about to output a location descriptor
5672 for a variable or parameter which has been optimized out of existence,
5673 don't do that. Instead we output a null location descriptor value as
5674 part of the location attribute. A variable which has been optimized out
5675 of existence will have a DECL_RTL value which denotes a pseudo-reg.
5676 Currently, in some rare cases, variables can have DECL_RTL values which
5677 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
5678 elsewhere in the compiler. We treat such cases as if the variable(s) in
5679 question had been optimized out of existence. Note that in all cases
5680 where we wish to express the fact that a variable has been optimized out
5681 of existence, we do not simply suppress the generation of the entire
5682 location attribute because the absence of a location attribute in
5683 certain kinds of DIEs is used to indicate something else entirely...
5684 i.e. that the DIE represents an object declaration, but not a
5685 definition. So sayeth the PLSIG. */
5686 if (!is_pseudo_reg (rtl)
5687 && (GET_CODE (rtl) != MEM
5688 || !is_pseudo_reg (XEXP (rtl, 0))))
5689 {
5690 loc_descr = loc_descriptor (eliminate_regs (rtl, 0, NULL_RTX));
5691 }
5692
5693#ifdef MIPS_DEBUGGING_INFO
5694 /* ??? SGI's dwarf reader is buggy, and will not accept a zero size
5695 location descriptor. Lets just use r0 for now to represent a
5696 variable that has been optimized away. */
5697 if (loc_descr == NULL)
5698 {
5699 loc_descr = loc_descriptor (gen_rtx (REG, word_mode, 0));
5700 }
5701#endif
5702
5703 add_AT_loc (die, DW_AT_location, loc_descr);
5704}
5705
5706/* Attach the specialized form of location attribute used for data
5707 members of struct and union types. In the special case of a
5708 FIELD_DECL node which represents a bit-field, the "offset" part
5709 of this special location descriptor must indicate the distance
5710 in bytes from the lowest-addressed byte of the containing struct
5711 or union type to the lowest-addressed byte of the "containing
5712 object" for the bit-field. (See the `field_byte_offset' function
5713 above).. For any given bit-field, the "containing object" is a
5714 hypothetical object (of some integral or enum type) within which
5715 the given bit-field lives. The type of this hypothetical
5716 "containing object" is always the same as the declared type of
5717 the individual bit-field itself (for GCC anyway... the DWARF
5718 spec doesn't actually mandate this). Note that it is the size
5719 (in bytes) of the hypothetical "containing object" which will
5720 be given in the DW_AT_byte_size attribute for this bit-field.
5721 (See the `byte_size_attribute' function below.) It is also used
5722 when calculating the value of the DW_AT_bit_offset attribute.
5723 (See the `bit_offset_attribute' function below). */
5724static void
5725add_data_member_location_attribute (die, decl)
5726 register dw_die_ref die;
5727 register tree decl;
5728{
61b32c02 5729 register unsigned long offset;
a3f97cbb
JW		 5730 register dw_loc_descr_ref loc_descr;
5731 register enum dwarf_location_atom op;
5732
61b32c02
JM		 5733 if (TREE_CODE (decl) == TREE_VEC)
5734 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
5735 else
5736 offset = field_byte_offset (decl);
5737
a3f97cbb
JW		 5738 /* The DWARF2 standard says that we should assume that the structure address
5739 is already on the stack, so we can specify a structure field address
5740 by using DW_OP_plus_uconst. */
5741#ifdef MIPS_DEBUGGING_INFO
5742 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
5743 correctly. It works only if we leave the offset on the stack. */
5744 op = DW_OP_constu;
5745#else
5746 op = DW_OP_plus_uconst;
5747#endif
5748 loc_descr = new_loc_descr (op, offset, 0);
5749 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
5750}
5751
5752/* Attach an DW_AT_const_value attribute for a variable or a parameter which
5753 does not have a "location" either in memory or in a register. These
5754 things can arise in GNU C when a constant is passed as an actual parameter
5755 to an inlined function. They can also arise in C++ where declared
5756 constants do not necessarily get memory "homes". */
5757static void
5758add_const_value_attribute (die, rtl)
5759 register dw_die_ref die;
5760 register rtx rtl;
5761{
5762 switch (GET_CODE (rtl))
5763 {
5764 case CONST_INT:
5765 /* Note that a CONST_INT rtx could represent either an integer or a
5766 floating-point constant. A CONST_INT is used whenever the constant
5767 will fit into a single word. In all such cases, the original mode
5768 of the constant value is wiped out, and the CONST_INT rtx is
5769 assigned VOIDmode. */
5770 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
5771 break;
5772
5773 case CONST_DOUBLE:
5774 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
5775 floating-point constant. A CONST_DOUBLE is used whenever the
5776 constant requires more than one word in order to be adequately
469ac993
JM		 5777 represented. We output CONST_DOUBLEs as blocks. */
5778 {
5779 register enum machine_mode mode = GET_MODE (rtl);
5780
5781 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
5782 {
5783 union real_extract u;
5784 jmp_buf handler;
5785 register unsigned length = GET_MODE_SIZE (mode) / 4;
5786 register long *array = (long *) xmalloc (length * sizeof (long));
5787
5788 bcopy ((char *) &CONST_DOUBLE_LOW (rtl), (char *) &u, sizeof u);
5789
5790 if (setjmp (handler))
5791 {
5792 error ("floating point trap outputting debug info");
5793 u.d = dconst0;
5794 }
5795
5796 set_float_handler (handler);
5797
5798 switch (mode)
5799 {
5800 case SFmode:
5801 REAL_VALUE_TO_TARGET_SINGLE (u.d, array[0]);
5802 break;
5803
5804 case DFmode:
5805 REAL_VALUE_TO_TARGET_DOUBLE (u.d, array);
5806 break;
5807
5808 case XFmode:
5809 case TFmode:
5810 REAL_VALUE_TO_TARGET_LONG_DOUBLE (u.d, array);
5811 break;
5812
5813 default:
5814 abort ();
5815 }
5816
5817 set_float_handler (NULL_PTR);
5818
5819 add_AT_float (die, DW_AT_const_value, length, array);
5820 }
5821 else
5822 add_AT_long_long (die, DW_AT_const_value,
5823 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
5824 }
a3f97cbb
JW		 5825 break;
5826
5827 case CONST_STRING:
5828 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
5829 break;
5830
5831 case SYMBOL_REF:
5832 case LABEL_REF:
5833 case CONST:
5834 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
5835 break;
5836
5837 case PLUS:
5838 /* In cases where an inlined instance of an inline function is passed
5839 the address of an `auto' variable (which is local to the caller) we
5840 can get a situation where the DECL_RTL of the artificial local
5841 variable (for the inlining) which acts as a stand-in for the
5842 corresponding formal parameter (of the inline function) will look
5843 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
5844 exactly a compile-time constant expression, but it isn't the address
5845 of the (artificial) local variable either. Rather, it represents the
5846 *value* which the artificial local variable always has during its
5847 lifetime. We currently have no way to represent such quasi-constant
5848 values in Dwarf, so for now we just punt and generate an
5849 DW_AT_const_value attribute with null address. */
5850 add_AT_addr (die, DW_AT_const_value, addr_to_string (const0_rtx));
5851 break;
5852
5853 default:
5854 /* No other kinds of rtx should be possible here. */
5855 abort ();
5856 }
5857
5858}
5859
5860/* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
5861 data attribute for a variable or a parameter. We generate the
5862 DW_AT_const_value attribute only in those cases where the given variable
5863 or parameter does not have a true "location" either in memory or in a
5864 register. This can happen (for example) when a constant is passed as an
5865 actual argument in a call to an inline function. (It's possible that
5866 these things can crop up in other ways also.) Note that one type of
5867 constant value which can be passed into an inlined function is a constant
5868 pointer. This can happen for example if an actual argument in an inlined
5869 function call evaluates to a compile-time constant address. */
5870static void
5871add_location_or_const_value_attribute (die, decl)
5872 register dw_die_ref die;
5873 register tree decl;
5874{
5875 register rtx rtl;
5876 register tree declared_type;
5877 register tree passed_type;
5878
5879 if (TREE_CODE (decl) == ERROR_MARK)
5880 {
5881 return;
5882 }
5883 if ((TREE_CODE (decl) != VAR_DECL)
5884 && (TREE_CODE (decl) != PARM_DECL))
5885 {
5886 /* Should never happen. */
5887 abort ();
5888 return;
5889 }
5890 /* Here we have to decide where we are going to say the parameter "lives"
5891 (as far as the debugger is concerned). We only have a couple of
5892 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
5893 DECL_RTL normally indicates where the parameter lives during most of the
5894 activa- tion of the function. If optimization is enabled however, this
5895 could be either NULL or else a pseudo-reg. Both of those cases indicate
5896 that the parameter doesn't really live anywhere (as far as the code
5897 generation parts of GCC are concerned) during most of the function's
5898 activation. That will happen (for example) if the parameter is never
5899 referenced within the function. We could just generate a location
5900 descriptor here for all non-NULL non-pseudo values of DECL_RTL and
5901 ignore all of the rest, but we can be a little nicer than that if we
5902 also consider DECL_INCOMING_RTL in cases where DECL_RTL is NULL or is a
5903 pseudo-reg. Note however that we can only get away with using
5904 DECL_INCOMING_RTL as a backup substitute for DECL_RTL in certain limited
5905 cases. In cases where DECL_ARG_TYPE(decl) indicates the same type as
5906 TREE_TYPE(decl) we can be sure that the parameter was passed using the
5907 same type as it is declared to have within the function, and that its
5908 DECL_INCOMING_RTL points us to a place where a value of that type is
5909 passed. In cases where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are
5910 different types however, we cannot (in general) use DECL_INCOMING_RTL as
5911 a backup substitute for DECL_RTL because in these cases,
5912 DECL_INCOMING_RTL points us to a value of some type which is *different*
5913 from the type of the parameter itself. Thus, if we tried to use
5914 DECL_INCOMING_RTL to generate a location attribute in such cases, the
5915 debugger would end up (for example) trying to fetch a `float' from a
5916 place which actually contains the first part of a `double'. That would
5917 lead to really incorrect and confusing output at debug-time, and we
5918 don't want that now do we? So in general, we DO NOT use
5919 DECL_INCOMING_RTL as a backup for DECL_RTL in cases where
5920 DECL_ARG_TYPE(decl) != TREE_TYPE(decl). There are a couple of cute
5921 exceptions however. On little-endian machines we can get away with
5922 using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is not the same as
5923 TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is an integral type
5924 which is smaller than TREE_TYPE(decl). These cases arise when (on a
5925 little-endian machine) a non-prototyped function has a parameter
5926 declared to be of type `short' or `char'. In such cases,
5927 TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be
5928 `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
5929 passed `int' value. If the debugger then uses that address to fetch a
5930 `short' or a `char' (on a little-endian machine) the result will be the
5931 correct data, so we allow for such exceptional cases below. Note that
5932 our goal here is to describe the place where the given formal parameter
5933 lives during most of the function's activation (i.e. between the end of
5934 the prologue and the start of the epilogue). We'll do that as best as
5935 we can. Note however that if the given formal parameter is modified
5936 sometime during the execution of the function, then a stack backtrace
5937 (at debug-time) will show the function as having been called with the
5938 *new* value rather than the value which was originally passed in. This
5939 happens rarely enough that it is not a major problem, but it *is* a
9a666dda 5940 problem, and I'd like to fix it. A future version of dwarf2out.c may
a3f97cbb
JW		 5941 generate two additional attributes for any given DW_TAG_formal_parameter
5942 DIE which will describe the "passed type" and the "passed location" for
5943 the given formal parameter in addition to the attributes we now generate
5944 to indicate the "declared type" and the "active location" for each
5945 parameter. This additional set of attributes could be used by debuggers
5946 for stack backtraces. Separately, note that sometimes DECL_RTL can be
5947 NULL and DECL_INCOMING_RTL can be NULL also. This happens (for example)
5948 for inlined-instances of inline function formal parameters which are
5949 never referenced. This really shouldn't be happening. All PARM_DECL
5950 nodes should get valid non-NULL DECL_INCOMING_RTL values, but
5951 integrate.c doesn't currently generate these values for inlined
5952 instances of inline function parameters, so when we see such cases, we
5953 are just SOL (shit-out-of-luck) for the time being (until integrate.c
5954 gets fixed). */
5955
5956 /* Use DECL_RTL as the "location" unless we find something better. */
5957 rtl = DECL_RTL (decl);
5958
5959 if (TREE_CODE (decl) == PARM_DECL)
5960 {
5961 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
5962 {
5963 declared_type = type_main_variant (TREE_TYPE (decl));
5964 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
5965 /* This decl represents a formal parameter which was
5966 optimized out.
5967
5968 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
5969 all* cases where (rtl == NULL_RTX) just below. */
5970 if (declared_type == passed_type)
5971 {
5972 rtl = DECL_INCOMING_RTL (decl);
5973 }
5974 else if (!BYTES_BIG_ENDIAN)
5975 {
5976 if (TREE_CODE (declared_type) == INTEGER_TYPE)
5977 {
5978 if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
5979 {
5980 rtl = DECL_INCOMING_RTL (decl);
5981 }
5982 }
5983 }
a3f97cbb
JW		 5984 }
5985 }
61b32c02
JM		 5986 if (rtl == NULL_RTX)
5987 return;
5988
a3f97cbb
JW		 5989 switch (GET_CODE (rtl))
5990 {
5991 case CONST_INT:
5992 case CONST_DOUBLE:
5993 case CONST_STRING:
5994 case SYMBOL_REF:
5995 case LABEL_REF:
5996 case CONST:
5997 case PLUS:
5998 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
5999 add_const_value_attribute (die, rtl);
6000 break;
6001
6002 case MEM:
6003 case REG:
6004 case SUBREG:
6005 add_location_attribute (die, rtl);
6006 break;
6007
6008 default:
6009 abort (); /* Should never happen. */
6010 }
6011}
6012
6013/* Generate an DW_AT_name attribute given some string value to be included as
6014 the value of the attribute. */
6015inline void
6016add_name_attribute (die, name_string)
6017 register dw_die_ref die;
6018 register char *name_string;
6019{
6020 if (name_string && *name_string)
6021 {
6022 add_AT_string (die, DW_AT_name, name_string);
6023 }
6024}
6025
6026/* Given a tree node describing an array bound (either lower or upper) output
a9d38797
JM		 6027 a representation for that bound.
6028
6029 FIXME: This uses location descriptions for variable bounds, whereas the
6030 DWARF-2 spec only allowes for constants or DIE references. */
a3f97cbb
JW		 6031static void
6032add_bound_info (subrange_die, bound_attr, bound)
6033 register dw_die_ref subrange_die;
6034 register enum dwarf_attribute bound_attr;
6035 register tree bound;
6036{
6037 register dw_loc_descr_ref bound_loc = NULL;
6038 register unsigned bound_value = 0;
6039 switch (TREE_CODE (bound))
6040 {
6041 case ERROR_MARK:
6042 return;
6043
6044 /* All fixed-bounds are represented by INTEGER_CST nodes. */
6045 case INTEGER_CST:
6046 bound_value = TREE_INT_CST_LOW (bound);
141719a8
JM		 6047 if (bound_attr == DW_AT_lower_bound
6048 && ((is_c_family () && bound_value == 0)
6049 || (is_fortran () && bound_value == 1)))
6050 /* use the default */;
6051 else
6052 add_AT_unsigned (subrange_die, bound_attr, bound_value);
a3f97cbb
JW		 6053 break;
6054
6055 /* Dynamic bounds may be represented by NOP_EXPR nodes containing
6056 SAVE_EXPR nodes. */
6057 case NOP_EXPR:
6058 bound = TREE_OPERAND (bound, 0);
6059 /* ... fall thru... */
6060
6061 case SAVE_EXPR:
141719a8
JM		 6062 /* Handle the simple case of `int ar[i];'. */
6063 if (bound_attr == DW_AT_upper_bound && is_c_family ()
6064 && TREE_CODE (TREE_OPERAND (bound, 0)) == MINUS_EXPR)
6065 {
6066 tree t = TREE_OPERAND (bound, 0);
6067 if (integer_onep (TREE_OPERAND (bound, 1)))
6068 t = TREE_OPERAND (t, 0);
6069 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
6070 {
6071 add_AT_die_ref (subrange_die, DW_AT_count, lookup_decl_die (t));
6072 return;
6073 }
6074 }
6075
a3f97cbb
JW		 6076 /* If optimization is turned on, the SAVE_EXPRs that describe how to
6077 access the upper bound values are essentially bogus. They only
6078 describe (at best) how to get at these values at the points in the
141719a8
JM		 6079 generated code right after they have just been computed. Worse
6080 yet, in the typical case, the upper bound values will not even
6081 *be* computed in the optimized code, so these SAVE_EXPRs are
6082 entirely bogus. In order to compensate for this fact, we check
6083 here to see if optimization is enabled, and if so, we don't add an
6084 attribute for the (unknown and unknowable) upper bound. This
6085 should not cause too much trouble for existing (stupid?)
6086 debuggers because they have to deal with empty upper bounds
6087 location descriptions anyway in order to be able to deal with
6088 incomplete array types. Of course an intelligent debugger (GDB?)
6089 should be able to comprehend that a missing upper bound
6090 specification in a array type used for a storage class `auto'
6091 local array variable indicates that the upper bound is both
6092 unknown (at compile- time) and unknowable (at run-time) due to
6093 optimization. */
a3f97cbb
JW		 6094 if (!optimize)
6095 {
141719a8
JM		 6096 bound_loc = mem_loc_descriptor
6097 (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
6098 add_AT_loc (subrange_die, bound_attr, bound_loc);
a3f97cbb 6099 }
141719a8 6100 /* else leave out the attribute. */
a3f97cbb
JW		 6101 break;
6102
6103 default:
6104 abort ();
6105 }
6106}
6107
6108/* Note that the block of subscript information for an array type also
6109 includes information about the element type of type given array type. */
6110static void
6111add_subscript_info (type_die, type)
6112 register dw_die_ref type_die;
6113 register tree type;
6114{
6115 register unsigned dimension_number;
6116 register tree lower, upper;
6117 register dw_die_ref subrange_die;
6118
6119 /* The GNU compilers represent multidimensional array types as sequences of
6120 one dimensional array types whose element types are themselves array
6121 types. Here we squish that down, so that each multidimensional array
6122 type gets only one array_type DIE in the Dwarf debugging info. The draft
6123 Dwarf specification say that we are allowed to do this kind of
6124 compression in C (because there is no difference between an array or
6125 arrays and a multidimensional array in C) but for other source languages
6126 (e.g. Ada) we probably shouldn't do this. */
6127 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
6128 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
6129 We work around this by disabling this feature. See also
6130 gen_array_type_die. */
6131#ifndef MIPS_DEBUGGING_INFO
6132 for (dimension_number = 0;
6133 TREE_CODE (type) == ARRAY_TYPE;
6134 type = TREE_TYPE (type), dimension_number++)
6135 {
6136#endif
6137 register tree domain = TYPE_DOMAIN (type);
6138
6139 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
6140 and (in GNU C only) variable bounds. Handle all three forms
6141 here. */
6142 subrange_die = new_die (DW_TAG_subrange_type, type_die);
6143 if (domain)
6144 {
6145 /* We have an array type with specified bounds. */
6146 lower = TYPE_MIN_VALUE (domain);
6147 upper = TYPE_MAX_VALUE (domain);
6148
a9d38797
JM		 6149 /* define the index type. */
6150 if (TREE_TYPE (domain))
6151 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
6152 type_die);
6153
141719a8 6154 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
a3f97cbb
JW		 6155 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
6156 }
6157 else
6158 {
a9d38797
JM		 6159 /* We have an array type with an unspecified length. The DWARF-2
6160 spec does not say how to handle this; let's just leave out the
6161 bounds. */
a3f97cbb
JW		 6162 }
6163#ifndef MIPS_DEBUGGING_INFO
6164 }
6165#endif
6166}
6167
6168static void
6169add_byte_size_attribute (die, tree_node)
6170 dw_die_ref die;
6171 register tree tree_node;
6172{
6173 register unsigned size;
6174
6175 switch (TREE_CODE (tree_node))
6176 {
6177 case ERROR_MARK:
6178 size = 0;
6179 break;
6180 case ENUMERAL_TYPE:
6181 case RECORD_TYPE:
6182 case UNION_TYPE:
6183 case QUAL_UNION_TYPE:
6184 size = int_size_in_bytes (tree_node);
6185 break;
6186 case FIELD_DECL:
6187 /* For a data member of a struct or union, the DW_AT_byte_size is
6188 generally given as the number of bytes normally allocated for an
6189 object of the *declared* type of the member itself. This is true
6190 even for bit-fields. */
6191 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
6192 break;
6193 default:
6194 abort ();
6195 }
6196
6197 /* Note that `size' might be -1 when we get to this point. If it is, that
6198 indicates that the byte size of the entity in question is variable. We
6199 have no good way of expressing this fact in Dwarf at the present time,
6200 so just let the -1 pass on through. */
6201
6202 add_AT_unsigned (die, DW_AT_byte_size, size);
6203}
6204
6205/* For a FIELD_DECL node which represents a bit-field, output an attribute
6206 which specifies the distance in bits from the highest order bit of the
6207 "containing object" for the bit-field to the highest order bit of the
6208 bit-field itself.
6209
b2932ae5
JM		 6210 For any given bit-field, the "containing object" is a hypothetical
6211 object (of some integral or enum type) within which the given bit-field
6212 lives. The type of this hypothetical "containing object" is always the
6213 same as the declared type of the individual bit-field itself. The
6214 determination of the exact location of the "containing object" for a
6215 bit-field is rather complicated. It's handled by the
6216 `field_byte_offset' function (above).
a3f97cbb
JW		 6217
6218 Note that it is the size (in bytes) of the hypothetical "containing object"
6219 which will be given in the DW_AT_byte_size attribute for this bit-field.
6220 (See `byte_size_attribute' above). */
6221inline void
6222add_bit_offset_attribute (die, decl)
6223 register dw_die_ref die;
6224 register tree decl;
6225{
6226 register unsigned object_offset_in_bytes = field_byte_offset (decl);
6227 register tree type = DECL_BIT_FIELD_TYPE (decl);
6228 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
6229 register unsigned bitpos_int;
6230 register unsigned highest_order_object_bit_offset;
6231 register unsigned highest_order_field_bit_offset;
6232 register unsigned bit_offset;
6233
6234 assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */
6235 assert (type); /* Must be a bit field. */
6236
6237 /* We can't yet handle bit-fields whose offsets are variable, so if we
6238 encounter such things, just return without generating any attribute
6239 whatsoever. */
6240 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6241 {
6242 return;
6243 }
6244 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6245
6246 /* Note that the bit offset is always the distance (in bits) from the
6247 highest-order bit of the "containing object" to the highest-order bit of
6248 the bit-field itself. Since the "high-order end" of any object or field
6249 is different on big-endian and little-endian machines, the computation
6250 below must take account of these differences. */
6251 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
6252 highest_order_field_bit_offset = bitpos_int;
6253
6254 if (!BYTES_BIG_ENDIAN)
6255 {
6256 highest_order_field_bit_offset
6257 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
6258
6259 highest_order_object_bit_offset += simple_type_size_in_bits (type);
6260 }
6261 bit_offset =
6262 (!BYTES_BIG_ENDIAN
6263 ? highest_order_object_bit_offset - highest_order_field_bit_offset
6264 : highest_order_field_bit_offset - highest_order_object_bit_offset);
6265
6266 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
6267}
6268
6269/* For a FIELD_DECL node which represents a bit field, output an attribute
6270 which specifies the length in bits of the given field. */
6271inline void
6272add_bit_size_attribute (die, decl)
6273 register dw_die_ref die;
6274 register tree decl;
6275{
6276 assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */
6277 assert (DECL_BIT_FIELD_TYPE (decl)); /* Must be a bit field. */
6278 add_AT_unsigned (die, DW_AT_bit_size,
6279 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
6280}
6281
88dad228 6282/* If the compiled language is ANSI C, then add a 'prototyped'
a3f97cbb
JW		 6283 attribute, if arg types are given for the parameters of a function. */
6284inline void
6285add_prototyped_attribute (die, func_type)
6286 register dw_die_ref die;
6287 register tree func_type;
6288{
88dad228
JM		 6289 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
6290 && TYPE_ARG_TYPES (func_type) != NULL)
6291 add_AT_flag (die, DW_AT_prototyped, 1);
a3f97cbb
JW		 6292}
6293
6294
6295/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
6296 by looking in either the type declaration or object declaration
6297 equate table. */
6298inline void
6299add_abstract_origin_attribute (die, origin)
6300 register dw_die_ref die;
6301 register tree origin;
6302{
6303 dw_die_ref origin_die = NULL;
6304 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
6305 {
6306 origin_die = lookup_decl_die (origin);
6307 }
6308 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
6309 {
6310 origin_die = lookup_type_die (origin);
6311 }
6312 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
6313}
6314
bdb669cb
JM		 6315/* We do not currently support the pure_virtual attribute. */
6316
a3f97cbb
JW		 6317inline void
6318add_pure_or_virtual_attribute (die, func_decl)
6319 register dw_die_ref die;
6320 register tree func_decl;
6321{
a94dbf2c 6322 if (DECL_VINDEX (func_decl))
a3f97cbb 6323 {
bdb669cb 6324 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
61b32c02
JM		 6325 add_AT_loc (die, DW_AT_vtable_elem_location, new_loc_descr
6326 (DW_OP_constu, TREE_INT_CST_LOW (DECL_VINDEX (func_decl))));
a94dbf2c
JM		 6327 /* GNU extension: Record what type this method came from originally. */
6328 if (debug_info_level > DINFO_LEVEL_TERSE)
6329 add_AT_die_ref (die, DW_AT_containing_type,
6330 lookup_type_die (DECL_CONTEXT (func_decl)));
a3f97cbb
JW		 6331 }
6332}
6333\f
6334/********************* utility routines for DIEs *************************/
6335
b2932ae5
JM		 6336/* Add source coordinate attributes for the given decl. */
6337static void
6338add_src_coords_attributes (die, decl)
6339 register dw_die_ref die;
6340 register tree decl;
6341{
6342 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
6343 add_AT_unsigned (die, DW_AT_decl_file, file_index);
6344 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
6345}
6346
a3f97cbb
JW		 6347/* Add an DW_AT_name attribute and source coordinate attribute for the
6348 given decl, but only if it actually has a name. */
6349static void
6350add_name_and_src_coords_attributes (die, decl)
6351 register dw_die_ref die;
6352 register tree decl;
6353{
61b32c02 6354 register tree decl_name;
273dbe67 6355 if (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
61b32c02
JM		 6356 decl_name = DECL_ASSEMBLER_NAME (decl);
6357 else
6358 decl_name = DECL_NAME (decl);
6359
a3f97cbb
JW		 6360 if (decl_name && IDENTIFIER_POINTER (decl_name))
6361 {
6362 add_name_attribute (die, IDENTIFIER_POINTER (decl_name));
b2932ae5 6363 add_src_coords_attributes (die, decl);
a3f97cbb
JW		 6364 }
6365}
6366
6367/* Push a new declaration scope. */
6368static void
6369push_decl_scope (scope)
6370 tree scope;
6371{
6372 /* Make room in the decl_scope_table, if necessary. */
6373 if (decl_scope_table_allocated == decl_scope_depth)
6374 {
6375 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
6376 decl_scope_table = (tree *) xrealloc (decl_scope_table,
6377 decl_scope_table_allocated * sizeof (tree));
6378 }
6379 decl_scope_table[decl_scope_depth++] = scope;
6380}
6381
6382/* Return the DIE for the scope the immediately contains this declaration. */
6383static dw_die_ref
ab72d377
JM		 6384scope_die_for (t, context_die)
6385 register tree t;
a3f97cbb
JW		 6386 register dw_die_ref context_die;
6387{
6388 register dw_die_ref scope_die = NULL;
6389 register tree containing_scope;
6390 register unsigned long i;
6391
88dad228
JM		 6392 /* Function-local tags and functions get stuck in limbo until they are
6393 fixed up by decls_for_scope. */
a94dbf2c
JM		 6394 if (context_die == NULL
6395 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
88dad228
JM		 6396 return NULL;
6397
a3f97cbb
JW		 6398 /* Walk back up the declaration tree looking for a place to define
6399 this type. */
ab72d377
JM		 6400 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
6401 containing_scope = TYPE_CONTEXT (t);
a94dbf2c 6402 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
ab72d377
JM		 6403 containing_scope = decl_class_context (t);
6404 else
6405 containing_scope = DECL_CONTEXT (t);
6406
a3f97cbb
JW		 6407 if (containing_scope == NULL)
6408 {
6409 scope_die = comp_unit_die;
6410 }
6411 else
6412 {
ab72d377
JM		 6413 for (i = decl_scope_depth, scope_die = context_die;
6414 i > 0 && decl_scope_table[i - 1] != containing_scope;
7d4440be
JM		 6415 scope_die = scope_die->die_parent, --i)
6416 /* nothing */ ;
ab72d377 6417 if (i == 0)
a3f97cbb 6418 {
ab72d377
JM		 6419 assert (scope_die == comp_unit_die);
6420 assert (TREE_CODE_CLASS (TREE_CODE (containing_scope)) == 't');
4927276d
JM		 6421 if (debug_info_level > DINFO_LEVEL_TERSE)
6422 assert (TREE_ASM_WRITTEN (containing_scope));
a3f97cbb
JW		 6423 }
6424 }
6425 return scope_die;
6426}
6427
6428/* Pop a declaration scope. */
6429inline void
6430pop_decl_scope ()
6431{
6432 assert (decl_scope_depth > 0);
6433 --decl_scope_depth;
6434}
6435
6436/* Many forms of DIEs require a "type description" attribute. This
6437 routine locates the proper "type descriptor" die for the type given
6438 by 'type', and adds an DW_AT_type attribute below the given die. */
6439static void
6440add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
6441 register dw_die_ref object_die;
6442 register tree type;
6443 register int decl_const;
6444 register int decl_volatile;
6445 register dw_die_ref context_die;
6446{
6447 register enum tree_code code = TREE_CODE (type);
a3f97cbb
JW		 6448 register dw_die_ref type_die = NULL;
6449
6450 if (code == ERROR_MARK)
6451 {
6452 return;
6453 }
6454
6455 /* Handle a special case. For functions whose return type is void, we
6456 generate *no* type attribute. (Note that no object may have type
6457 `void', so this only applies to function return types). */
6458 if (code == VOID_TYPE)
6459 {
6460 return;
6461 }
6462
a3f97cbb
JW		 6463 type_die = modified_type_die (type,
6464 decl_const || TYPE_READONLY (type),
6465 decl_volatile || TYPE_VOLATILE (type),
ab72d377 6466 context_die);
a3f97cbb
JW		 6467 if (type_die != NULL)
6468 {
6469 add_AT_die_ref (object_die, DW_AT_type, type_die);
6470 }
6471}
6472
6473/* Given a tree pointer to a struct, class, union, or enum type node, return
6474 a pointer to the (string) tag name for the given type, or zero if the type
6475 was declared without a tag. */
6476static char *
6477type_tag (type)
6478 register tree type;
6479{
6480 register char *name = 0;
6481
6482 if (TYPE_NAME (type) != 0)
6483 {
6484 register tree t = 0;
6485
6486 /* Find the IDENTIFIER_NODE for the type name. */
6487 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6488 t = TYPE_NAME (type);
bdb669cb 6489
a3f97cbb
JW		 6490 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
6491 a TYPE_DECL node, regardless of whether or not a `typedef' was
bdb669cb 6492 involved. */
a94dbf2c
JM		 6493 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6494 && ! DECL_IGNORED_P (TYPE_NAME (type)))
a3f97cbb 6495 t = DECL_NAME (TYPE_NAME (type));
bdb669cb 6496
a3f97cbb
JW		 6497 /* Now get the name as a string, or invent one. */
6498 if (t != 0)
a94dbf2c 6499 name = IDENTIFIER_POINTER (t);
a3f97cbb
JW		 6500 }
6501 return (name == 0 || *name == '\0') ? 0 : name;
6502}
6503
6504/* Return the type associated with a data member, make a special check
6505 for bit field types. */
6506inline tree
6507member_declared_type (member)
6508 register tree member;
6509{
6510 return (DECL_BIT_FIELD_TYPE (member))
6511 ? DECL_BIT_FIELD_TYPE (member)
6512 : TREE_TYPE (member);
6513}
6514
d291dd49 6515/* Get the decl's label, as described by its RTL. This may be different
a3f97cbb
JW		 6516 from the DECL_NAME name used in the source file. */
6517static char *
d291dd49 6518decl_start_label (decl)
a3f97cbb
JW		 6519 register tree decl;
6520{
6521 rtx x;
6522 char *fnname;
6523 x = DECL_RTL (decl);
6524 if (GET_CODE (x) != MEM)
6525 {
6526 abort ();
6527 }
6528 x = XEXP (x, 0);
6529 if (GET_CODE (x) != SYMBOL_REF)
6530 {
6531 abort ();
6532 }
6533 fnname = XSTR (x, 0);
6534 return fnname;
6535}
6536\f
6537/******************************* DIE Generation *************************/
6538
6539/* These routines generate the internnal representation of the DIE's for
6540 the compilation unit. Debugging information is collected by walking
88dad228 6541 the declaration trees passed in from dwarf2out_decl(). */
a3f97cbb
JW		 6542
6543static void
6544gen_array_type_die (type, context_die)
6545 register tree type;
6546 register dw_die_ref context_die;
6547{
ab72d377 6548 register dw_die_ref scope_die = scope_die_for (type, context_die);
a9d38797 6549 register dw_die_ref array_die;
a3f97cbb 6550 register tree element_type;
bdb669cb 6551
a9d38797
JM		 6552 /* ??? The SGI dwarf reader fails for array of array of enum types unless
6553 the inner array type comes before the outer array type. Thus we must
6554 call gen_type_die before we call new_die. See below also. */
6555#ifdef MIPS_DEBUGGING_INFO
6556 gen_type_die (TREE_TYPE (type), context_die);
6557#endif
6558
6559 array_die = new_die (DW_TAG_array_type, scope_die);
6560
a3f97cbb
JW		 6561#if 0
6562 /* We default the array ordering. SDB will probably do
6563 the right things even if DW_AT_ordering is not present. It's not even
6564 an issue until we start to get into multidimensional arrays anyway. If
6565 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
6566 then we'll have to put the DW_AT_ordering attribute back in. (But if
6567 and when we find out that we need to put these in, we will only do so
6568 for multidimensional arrays. */
6569 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
6570#endif
6571
a9d38797 6572#ifdef MIPS_DEBUGGING_INFO
4edb7b60
JM		 6573 /* The SGI compilers handle arrays of unknown bound by setting
6574 AT_declaration and not emitting any subrange DIEs. */
a9d38797
JM		 6575 if (! TYPE_DOMAIN (type))
6576 add_AT_unsigned (array_die, DW_AT_declaration, 1);
6577 else
6578#endif
6579 add_subscript_info (array_die, type);
a3f97cbb
JW		 6580
6581 equate_type_number_to_die (type, array_die);
6582
6583 /* Add representation of the type of the elements of this array type. */
6584 element_type = TREE_TYPE (type);
6585 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
6586 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
6587 We work around this by disabling this feature. See also
6588 add_subscript_info. */
6589#ifndef MIPS_DEBUGGING_INFO
6590 while (TREE_CODE (element_type) == ARRAY_TYPE)
6591 {
6592 element_type = TREE_TYPE (element_type);
6593 }
a3f97cbb 6594 gen_type_die (element_type, context_die);
a9d38797 6595#endif
a3f97cbb
JW		 6596
6597 add_type_attribute (array_die, element_type, 0, 0, context_die);
6598}
6599
6600static void
6601gen_set_type_die (type, context_die)
6602 register tree type;
6603 register dw_die_ref context_die;
6604{
ab72d377
JM		 6605 register dw_die_ref type_die = new_die
6606 (DW_TAG_set_type, scope_die_for (type, context_die));
a3f97cbb 6607 equate_type_number_to_die (type, type_die);
a3f97cbb
JW		 6608 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
6609}
6610
6611static void
6612gen_entry_point_die (decl, context_die)
6613 register tree decl;
6614 register dw_die_ref context_die;
6615{
6616 register tree origin = decl_ultimate_origin (decl);
6617 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
6618 if (origin != NULL)
6619 {
6620 add_abstract_origin_attribute (decl_die, origin);
6621 }
6622 else
6623 {
6624 add_name_and_src_coords_attributes (decl_die, decl);
a3f97cbb
JW		 6625 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
6626 0, 0, context_die);
6627 }
6628 if (DECL_ABSTRACT (decl))
6629 {
6630 equate_decl_number_to_die (decl, decl_die);
6631 }
6632 else
6633 {
d291dd49 6634 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
a3f97cbb
JW		 6635 }
6636}
6637
a94dbf2c
JM		 6638/* Remember a type in the pending_types_list. */
6639
6640static void
6641pend_type (type)
6642 register tree type;
6643{
6644 if (pending_types == pending_types_allocated)
6645 {
6646 pending_types_allocated += PENDING_TYPES_INCREMENT;
6647 pending_types_list
6648 = (tree *) xrealloc (pending_types_list,
6649 sizeof (tree) * pending_types_allocated);
6650 }
6651 pending_types_list[pending_types++] = type;
6652}
6653
6654/* Output any pending types (from the pending_types list) which we can output
6655 now (taking into account the scope that we are working on now).
6656
6657 For each type output, remove the given type from the pending_types_list
6658 *before* we try to output it. */
6659
6660static void
6661output_pending_types_for_scope (context_die)
6662 register dw_die_ref context_die;
6663{
6664 register tree type;
6665
6666 while (pending_types)
6667 {
6668 --pending_types;
6669 type = pending_types_list[pending_types];
6670 gen_type_die (type, context_die);
6671 assert (TREE_ASM_WRITTEN (type));
6672 }
6673}
6674
a3f97cbb
JW		 6675/* Generate a DIE to represent an inlined instance of an enumeration type. */
6676static void
6677gen_inlined_enumeration_type_die (type, context_die)
6678 register tree type;
6679 register dw_die_ref context_die;
6680{
6681 register dw_die_ref type_die;
6682 type_die = new_die (DW_TAG_enumeration_type,
ab72d377 6683 scope_die_for (type, context_die));
a3f97cbb
JW		 6684 assert (TREE_ASM_WRITTEN (type));
6685 add_abstract_origin_attribute (type_die, type);
6686}
6687
6688/* Generate a DIE to represent an inlined instance of a structure type. */
6689static void
6690gen_inlined_structure_type_die (type, context_die)
6691 register tree type;
6692 register dw_die_ref context_die;
6693{
6694 register dw_die_ref type_die;
6695 type_die = new_die (DW_TAG_structure_type,
ab72d377 6696 scope_die_for (type, context_die));
a3f97cbb
JW		 6697 assert (TREE_ASM_WRITTEN (type));
6698 add_abstract_origin_attribute (type_die, type);
6699}
6700
6701/* Generate a DIE to represent an inlined instance of a union type. */
6702static void
6703gen_inlined_union_type_die (type, context_die)
6704 register tree type;
6705 register dw_die_ref context_die;
6706{
6707 register dw_die_ref type_die;
6708 type_die = new_die (DW_TAG_union_type,
ab72d377 6709 scope_die_for (type, context_die));
a3f97cbb
JW		 6710 assert (TREE_ASM_WRITTEN (type));
6711 add_abstract_origin_attribute (type_die, type);
6712}
6713
6714/* Generate a DIE to represent an enumeration type. Note that these DIEs
6715 include all of the information about the enumeration values also. Each
273dbe67
JM		 6716 enumerated type name/value is listed as a child of the enumerated type
6717 DIE. */
a3f97cbb 6718static void
273dbe67 6719gen_enumeration_type_die (type, context_die)
a3f97cbb 6720 register tree type;
a3f97cbb
JW		 6721 register dw_die_ref context_die;
6722{
273dbe67
JM		 6723 register dw_die_ref type_die = lookup_type_die (type);
6724
a3f97cbb
JW		 6725 if (type_die == NULL)
6726 {
6727 type_die = new_die (DW_TAG_enumeration_type,
ab72d377 6728 scope_die_for (type, context_die));
a3f97cbb
JW		 6729 equate_type_number_to_die (type, type_die);
6730 add_name_attribute (type_die, type_tag (type));
a3f97cbb 6731 }
273dbe67
JM		 6732 else if (! TYPE_SIZE (type))
6733 return;
6734 else
6735 remove_AT (type_die, DW_AT_declaration);
6736
6737 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
6738 given enum type is incomplete, do not generate the DW_AT_byte_size
6739 attribute or the DW_AT_element_list attribute. */
6740 if (TYPE_SIZE (type))
a3f97cbb 6741 {
273dbe67 6742 register tree link;
a082c85a 6743 TREE_ASM_WRITTEN (type) = 1;
273dbe67 6744 add_byte_size_attribute (type_die, type);
b2932ae5
JM		 6745 if (type_tag (type))
6746 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
273dbe67
JM		 6747 for (link = TYPE_FIELDS (type);
6748 link != NULL; link = TREE_CHAIN (link))
a3f97cbb 6749 {
273dbe67
JM		 6750 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
6751 add_name_attribute (enum_die,
6752 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
6753 add_AT_unsigned (enum_die, DW_AT_const_value,
a3f97cbb 6754 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
a3f97cbb
JW		 6755 }
6756 }
273dbe67
JM		 6757 else
6758 add_AT_flag (type_die, DW_AT_declaration, 1);
a3f97cbb
JW		 6759}
6760
6761
6762/* Generate a DIE to represent either a real live formal parameter decl or to
6763 represent just the type of some formal parameter position in some function
6764 type.
6765 Note that this routine is a bit unusual because its argument may be a
6766 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
6767 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
6768 node. If it's the former then this function is being called to output a
6769 DIE to represent a formal parameter object (or some inlining thereof). If
6770 it's the latter, then this function is only being called to output a
6771 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
6772 argument type of some subprogram type. */
a94dbf2c 6773static dw_die_ref
a3f97cbb
JW		 6774gen_formal_parameter_die (node, context_die)
6775 register tree node;
6776 register dw_die_ref context_die;
6777{
6778 register dw_die_ref parm_die = new_die (DW_TAG_formal_parameter,
6779 context_die);
6780 register tree origin;
6781 switch (TREE_CODE_CLASS (TREE_CODE (node)))
6782 {
6783 /* We were called with some kind of a ..._DECL node. */
6784 case 'd':
6785 origin = decl_ultimate_origin (node);
6786 if (origin != NULL)
a94dbf2c 6787 add_abstract_origin_attribute (parm_die, origin);
a3f97cbb
JW		 6788 else
6789 {
6790 add_name_and_src_coords_attributes (parm_die, node);
6791 add_type_attribute (parm_die, TREE_TYPE (node),
6792 TREE_READONLY (node),
6793 TREE_THIS_VOLATILE (node),
6794 context_die);
bdb669cb
JM		 6795 if (DECL_ARTIFICIAL (node))
6796 add_AT_flag (parm_die, DW_AT_artificial, 1);
a3f97cbb 6797 }
141719a8
JM		 6798 equate_decl_number_to_die (node, parm_die);
6799 if (! DECL_ABSTRACT (node))
a94dbf2c 6800 add_location_or_const_value_attribute (parm_die, node);
a3f97cbb
JW		 6801 break;
6802
6803 /* We were called with some kind of a ..._TYPE node. */
6804 case 't':
6805 add_type_attribute (parm_die, node, 0, 0, context_die);
6806 break;
6807
6808 /* Should never happen. */
6809 default:
6810 abort ();
6811 }
a94dbf2c 6812 return parm_die;
a3f97cbb
JW		 6813}
6814
6815/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
6816 at the end of an (ANSI prototyped) formal parameters list. */
6817static void
6818gen_unspecified_parameters_die (decl_or_type, context_die)
6819 register tree decl_or_type;
6820 register dw_die_ref context_die;
6821{
6822 register dw_die_ref parm_die = new_die (DW_TAG_unspecified_parameters,
6823 context_die);
a3f97cbb
JW		 6824}
6825
6826/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
6827 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
6828 parameters as specified in some function type specification (except for
6829 those which appear as part of a function *definition*).
6830 Note that we must be careful here to output all of the parameter DIEs before*
6831 we output any DIEs needed to represent the types of the formal parameters.
6832 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
6833 non-parameter DIE it sees ends the formal parameter list. */
6834static void
6835gen_formal_types_die (function_or_method_type, context_die)
6836 register tree function_or_method_type;
6837 register dw_die_ref context_die;
6838{
6839 register tree link;
6840 register tree formal_type = NULL;
6841 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
6842
bdb669cb 6843#if 0
a3f97cbb
JW		 6844 /* In the case where we are generating a formal types list for a C++
6845 non-static member function type, skip over the first thing on the
6846 TYPE_ARG_TYPES list because it only represents the type of the hidden
6847 `this pointer'. The debugger should be able to figure out (without
6848 being explicitly told) that this non-static member function type takes a
6849 `this pointer' and should be able to figure what the type of that hidden
6850 parameter is from the DW_AT_member attribute of the parent
6851 DW_TAG_subroutine_type DIE. */
6852 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
6853 first_parm_type = TREE_CHAIN (first_parm_type);
bdb669cb 6854#endif
a3f97cbb
JW		 6855
6856 /* Make our first pass over the list of formal parameter types and output a
6857 DW_TAG_formal_parameter DIE for each one. */
6858 for (link = first_parm_type; link; link = TREE_CHAIN (link))
6859 {
a94dbf2c
JM		 6860 register dw_die_ref parm_die;
6861
a3f97cbb
JW		 6862 formal_type = TREE_VALUE (link);
6863 if (formal_type == void_type_node)
6864 break;
6865
6866 /* Output a (nameless) DIE to represent the formal parameter itself. */
a94dbf2c
JM		 6867 parm_die = gen_formal_parameter_die (formal_type, context_die);
6868 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
6869 && link == first_parm_type)
6870 add_AT_flag (parm_die, DW_AT_artificial, 1);
a3f97cbb
JW		 6871 }
6872
6873 /* If this function type has an ellipsis, add a
6874 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
6875 if (formal_type != void_type_node)
6876 gen_unspecified_parameters_die (function_or_method_type, context_die);
6877
6878 /* Make our second (and final) pass over the list of formal parameter types
6879 and output DIEs to represent those types (as necessary). */
6880 for (link = TYPE_ARG_TYPES (function_or_method_type);
6881 link;
6882 link = TREE_CHAIN (link))
6883 {
6884 formal_type = TREE_VALUE (link);
6885 if (formal_type == void_type_node)
6886 break;
6887
b50c02f9 6888 gen_type_die (formal_type, context_die);
a3f97cbb
JW		 6889 }
6890}
6891
6892/* Generate a DIE to represent a declared function (either file-scope or
6893 block-local). */
6894static void
6895gen_subprogram_die (decl, context_die)
6896 register tree decl;
6897 register dw_die_ref context_die;
6898{
6899 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
6900 register tree origin = decl_ultimate_origin (decl);
4b674448 6901 register dw_die_ref subr_die;
a3f97cbb
JW		 6902 register dw_loc_descr_ref fp_loc = NULL;
6903 register unsigned fp_reg;
a3f97cbb
JW		 6904 register tree fn_arg_types;
6905 register tree outer_scope;
a94dbf2c
JM		 6906 register dw_die_ref old_die = lookup_decl_die (decl);
6907 register int declaration = (current_function_decl != decl
6908 || context_die->die_tag == DW_TAG_structure_type
6909 || context_die->die_tag == DW_TAG_union_type);
a3f97cbb 6910
a3f97cbb
JW		 6911 if (origin != NULL)
6912 {
4b674448 6913 subr_die = new_die (DW_TAG_subprogram, context_die);
a3f97cbb
JW		 6914 add_abstract_origin_attribute (subr_die, origin);
6915 }
bdb669cb
JM		 6916 else if (old_die)
6917 {
4b674448
JM		 6918 register unsigned file_index
6919 = lookup_filename (DECL_SOURCE_FILE (decl));
a94dbf2c
JM		 6920
6921 assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
4b674448
JM		 6922
6923 /* If the definition comes from the same place as the declaration,
a94dbf2c
JM		 6924 maybe use the old DIE. We always want the DIE for this function
6925 that has the *_pc attributes to be under comp_unit_die so the
6926 debugger can find it. For inlines, that is the concrete instance,
6927 so we can use the old DIE here. For non-inline methods, we want a
6928 specification DIE at toplevel, so we need a new DIE. For local
6929 class methods, this does not apply. */
6930 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
6931 || context_die == NULL)
6932 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
4b674448
JM		 6933 && (get_AT_unsigned (old_die, DW_AT_decl_line)
6934 == DECL_SOURCE_LINE (decl)))
bdb669cb 6935 {
4b674448
JM		 6936 subr_die = old_die;
6937
6938 /* Clear out the declaration attribute and the parm types. */
6939 remove_AT (subr_die, DW_AT_declaration);
6940 remove_children (subr_die);
6941 }
6942 else
6943 {
6944 subr_die = new_die (DW_TAG_subprogram, context_die);
6945 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
bdb669cb
JM		 6946 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
6947 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
6948 if (get_AT_unsigned (old_die, DW_AT_decl_line)
6949 != DECL_SOURCE_LINE (decl))
6950 add_AT_unsigned
6951 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
6952 }
6953 }
a3f97cbb
JW		 6954 else
6955 {
4edb7b60
JM		 6956 register dw_die_ref scope_die;
6957
6958 if (DECL_CONTEXT (decl))
6959 scope_die = scope_die_for (decl, context_die);
6960 else
6961 /* Don't put block extern declarations under comp_unit_die. */
6962 scope_die = context_die;
6963
6964 subr_die = new_die (DW_TAG_subprogram, scope_die);
6965
273dbe67
JM		 6966 if (TREE_PUBLIC (decl))
6967 add_AT_flag (subr_die, DW_AT_external, 1);
a3f97cbb 6968 add_name_and_src_coords_attributes (subr_die, decl);
4927276d
JM		 6969 if (debug_info_level > DINFO_LEVEL_TERSE)
6970 {
6971 register tree type = TREE_TYPE (decl);
6972 add_prototyped_attribute (subr_die, type);
6973 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
6974 }
a3f97cbb 6975 add_pure_or_virtual_attribute (subr_die, decl);
273dbe67
JM		 6976 if (DECL_ARTIFICIAL (decl))
6977 add_AT_flag (subr_die, DW_AT_artificial, 1);
a94dbf2c
JM		 6978 if (TREE_PROTECTED (decl))
6979 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
6980 else if (TREE_PRIVATE (decl))
6981 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
a3f97cbb 6982 }
4edb7b60 6983
a94dbf2c
JM		 6984 if (declaration)
6985 {
6986 add_AT_flag (subr_die, DW_AT_declaration, 1);
6987
6988 /* The first time we see a member function, it is in the context of
6989 the class to which it belongs. We make sure of this by emitting
6990 the class first. The next time is the definition, which is
6991 handled above. The two may come from the same source text. */
6992 if (decl_class_context (decl))
6993 equate_decl_number_to_die (decl, subr_die);
6994 }
6995 else if (DECL_ABSTRACT (decl))
a3f97cbb 6996 {
61b32c02
JM		 6997 if (DECL_DEFER_OUTPUT (decl))
6998 {
6999 if (DECL_INLINE (decl))
7000 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
7001 else
7002 add_AT_unsigned (subr_die, DW_AT_inline,
7003 DW_INL_declared_not_inlined);
7004 }
7005 else if (DECL_INLINE (decl))
7006 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
4edb7b60
JM		 7007 else if (declaration)
7008 /* block extern declaration in an inline function. */
7009 add_AT_flag (subr_die, DW_AT_declaration, 1);
61b32c02
JM		 7010 else
7011 abort ();
7012
a3f97cbb
JW		 7013 equate_decl_number_to_die (decl, subr_die);
7014 }
7015 else if (!DECL_EXTERNAL (decl))
7016 {
ba7b35df
JW		 7017 if (origin == NULL)
7018 equate_decl_number_to_die (decl, subr_die);
5c90448c
JM		 7019 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
7020 current_funcdef_number);
7d4440be 7021 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
5c90448c
JM		 7022 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
7023 current_funcdef_number);
a3f97cbb
JW		 7024 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
7025
d291dd49
JM		 7026 add_pubname (decl, subr_die);
7027 add_arange (decl, subr_die);
7028
a3f97cbb 7029#ifdef MIPS_DEBUGGING_INFO
a3f97cbb
JW		 7030 /* Add a reference to the FDE for this routine. */
7031 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
7032#endif
7033
810429b7
JM		 7034 /* Define the "frame base" location for this routine. We use the
7035 frame pointer or stack pointer registers, since the RTL for local
7036 variables is relative to one of them. */
7037 fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
7038 ? FRAME_POINTER_REGNUM
7039 : STACK_POINTER_REGNUM);
a3f97cbb 7040 assert (fp_reg >= 0 && fp_reg <= 31);
810429b7 7041 fp_loc = new_loc_descr (DW_OP_reg0 + fp_reg);
a3f97cbb
JW		 7042 add_AT_loc (subr_die, DW_AT_frame_base, fp_loc);
7043
88dad228
JM		 7044 if (current_function_needs_context)
7045 add_AT_loc (subr_die, DW_AT_static_link,
7046 loc_descriptor (lookup_static_chain (decl)));
a3f97cbb
JW		 7047 }
7048
7049 /* Now output descriptions of the arguments for this function. This gets
7050 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
7051 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
7052 `...' at the end of the formal parameter list. In order to find out if
7053 there was a trailing ellipsis or not, we must instead look at the type
7054 associated with the FUNCTION_DECL. This will be a node of type
7055 FUNCTION_TYPE. If the chain of type nodes hanging off of this
7056 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
7057 an ellipsis at the end. */
7058
ab72d377 7059 push_decl_scope (decl);
a3f97cbb
JW		 7060 /* In the case where we are describing a mere function declaration, all we
7061 need to do here (and all we *can* do here) is to describe the *types* of
7062 its formal parameters. */
4927276d
JM		 7063 if (debug_info_level <= DINFO_LEVEL_TERSE)
7064 /* do nothing */;
4edb7b60
JM		 7065 else if (declaration)
7066 gen_formal_types_die (TREE_TYPE (decl), subr_die);
a3f97cbb
JW		 7067 else
7068 {
7069 /* Generate DIEs to represent all known formal parameters */
7070 register tree arg_decls = DECL_ARGUMENTS (decl);
7071 register tree parm;
7072
7073 /* When generating DIEs, generate the unspecified_parameters DIE
7074 instead if we come across the arg "__builtin_va_alist" */
7075 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
7076 {
7077 if (TREE_CODE (parm) == PARM_DECL)
7078 {
7079 if (DECL_NAME (parm) &&
7080 !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
7081 "__builtin_va_alist"))
7082 {
7083 gen_unspecified_parameters_die (parm, subr_die);
7084 }
7085 else
7086 {
7087 gen_decl_die (parm, subr_die);
7088 }
7089 }
7090 }
7091
7092 /* Decide whether we need a unspecified_parameters DIE at the end.
7093 There are 2 more cases to do this for: 1) the ansi ... declaration -
7094 this is detectable when the end of the arg list is not a
7095 void_type_node 2) an unprototyped function declaration (not a
7096 definition). This just means that we have no info about the
7097 parameters at all. */
7098 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
7099 if (fn_arg_types)
7100 {
7101 /* this is the prototyped case, check for ... */
7102 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
7103 {
7104 gen_unspecified_parameters_die (decl, subr_die);
7105 }
7106 }
7107 else
7108 {
7109 /* this is unprotoyped, check for undefined (just declaration) */
7110 if (!DECL_INITIAL (decl))
7111 {
7112 gen_unspecified_parameters_die (decl, subr_die);
7113 }
7114 }
7115 }
7116
7117 /* Output Dwarf info for all of the stuff within the body of the function
7118 (if it has one - it may be just a declaration). */
7119 outer_scope = DECL_INITIAL (decl);
7120
d7248bff
JM		 7121 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
7122 node created to represent a function. This outermost BLOCK actually
7123 represents the outermost binding contour for the function, i.e. the
7124 contour in which the function's formal parameters and labels get
7125 declared. Curiously, it appears that the front end doesn't actually
7126 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
7127 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
7128 list for the function instead.) The BLOCK_VARS list for the
7129 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
7130 the function however, and we output DWARF info for those in
7131 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
7132 node representing the function's outermost pair of curly braces, and
7133 any blocks used for the base and member initializers of a C++
7134 constructor function. */
4edb7b60 7135 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
7e23cb16
JM		 7136 {
7137 current_function_has_inlines = 0;
7138 decls_for_scope (outer_scope, subr_die, 0);
ce61cc73 7139#if 0 && defined (MIPS_DEBUGGING_INFO)
7e23cb16
JM		 7140 if (current_function_has_inlines)
7141 {
7142 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
7143 if (! comp_unit_has_inlines)
7144 {
7145 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
7146 comp_unit_has_inlines = 1;
7147 }
7148 }
7149#endif
7150 }
ab72d377 7151 pop_decl_scope ();
a3f97cbb
JW		 7152}
7153
7154/* Generate a DIE to represent a declared data object. */
7155static void
7156gen_variable_die (decl, context_die)
7157 register tree decl;
7158 register dw_die_ref context_die;
7159{
7160 register tree origin = decl_ultimate_origin (decl);
7161 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
bdb669cb 7162 dw_die_ref old_die = lookup_decl_die (decl);
4edb7b60
JM		 7163 int declaration
7164 = (DECL_EXTERNAL (decl)
a94dbf2c
JM		 7165 || current_function_decl != decl_function_context (decl)
7166 || context_die->die_tag == DW_TAG_structure_type
7167 || context_die->die_tag == DW_TAG_union_type);
4edb7b60 7168
a3f97cbb
JW		 7169 if (origin != NULL)
7170 {
7171 add_abstract_origin_attribute (var_die, origin);
7172 }
141719a8 7173 else if (old_die && TREE_STATIC (decl))
bdb669cb 7174 {
a94dbf2c 7175 assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
bdb669cb
JM		 7176 add_AT_die_ref (var_die, DW_AT_specification, old_die);
7177 if (DECL_NAME (decl))
7178 {
7179 register unsigned file_index
7180 = lookup_filename (DECL_SOURCE_FILE (decl));
7181 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
7182 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
7183 if (get_AT_unsigned (old_die, DW_AT_decl_line)
7184 != DECL_SOURCE_LINE (decl))
7185 add_AT_unsigned
7186 (var_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7187 }
7188 }
a3f97cbb
JW		 7189 else
7190 {
7191 add_name_and_src_coords_attributes (var_die, decl);
a3f97cbb
JW		 7192 add_type_attribute (var_die, TREE_TYPE (decl),
7193 TREE_READONLY (decl),
7194 TREE_THIS_VOLATILE (decl), context_die);
273dbe67
JM		 7195 if (TREE_PUBLIC (decl))
7196 add_AT_flag (var_die, DW_AT_external, 1);
7197 if (DECL_ARTIFICIAL (decl))
7198 add_AT_flag (var_die, DW_AT_artificial, 1);
a94dbf2c
JM		 7199 if (TREE_PROTECTED (decl))
7200 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
7201 else if (TREE_PRIVATE (decl))
7202 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
a3f97cbb 7203 }
4edb7b60
JM		 7204
7205 if (declaration)
7206 add_AT_flag (var_die, DW_AT_declaration, 1);
7207
7208 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
7209 equate_decl_number_to_die (decl, var_die);
7210
7211 if (! declaration && ! DECL_ABSTRACT (decl))
a3f97cbb 7212 {
141719a8 7213 equate_decl_number_to_die (decl, var_die);
a3f97cbb 7214 add_location_or_const_value_attribute (var_die, decl);
d291dd49 7215 add_pubname (decl, var_die);
a3f97cbb
JW		 7216 }
7217}
7218
7219/* Generate a DIE to represent a label identifier. */
7220static void
7221gen_label_die (decl, context_die)
7222 register tree decl;
7223 register dw_die_ref context_die;
7224{
7225 register tree origin = decl_ultimate_origin (decl);
7226 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
7227 register rtx insn;
7228 char label[MAX_ARTIFICIAL_LABEL_BYTES];
5c90448c 7229 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
a3f97cbb
JW		 7230 if (origin != NULL)
7231 {
7232 add_abstract_origin_attribute (lbl_die, origin);
7233 }
7234 else
7235 {
7236 add_name_and_src_coords_attributes (lbl_die, decl);
7237 }
7238 if (DECL_ABSTRACT (decl))
7239 {
7240 equate_decl_number_to_die (decl, lbl_die);
7241 }
7242 else
7243 {
7244 insn = DECL_RTL (decl);
7245 if (GET_CODE (insn) == CODE_LABEL)
7246 {
7247 /* When optimization is enabled (via -O) some parts of the compiler
7248 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
7249 represent source-level labels which were explicitly declared by
7250 the user. This really shouldn't be happening though, so catch
7251 it if it ever does happen. */
7252 if (INSN_DELETED_P (insn))
7253 {
7254 abort (); /* Should never happen. */
7255 }
5c90448c
JM		 7256 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
7257 ASM_GENERATE_INTERNAL_LABEL (label, label2,
7258 (unsigned) INSN_UID (insn));
a3f97cbb
JW		 7259 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
7260 }
7261 }
7262}
7263
7264/* Generate a DIE for a lexical block. */
7265static void
d7248bff 7266gen_lexical_block_die (stmt, context_die, depth)
a3f97cbb
JW		 7267 register tree stmt;
7268 register dw_die_ref context_die;
d7248bff 7269 int depth;
a3f97cbb
JW		 7270{
7271 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
7272 char label[MAX_ARTIFICIAL_LABEL_BYTES];
7273 if (!BLOCK_ABSTRACT (stmt))
7274 {
5c90448c
JM		 7275 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
7276 next_block_number);
a3f97cbb 7277 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
5c90448c 7278 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
a3f97cbb
JW		 7279 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
7280 }
7d4440be 7281 push_decl_scope (stmt);
d7248bff 7282 decls_for_scope (stmt, stmt_die, depth);
7d4440be 7283 pop_decl_scope ();
a3f97cbb
JW		 7284}
7285
7286/* Generate a DIE for an inlined subprogram. */
7287static void
d7248bff 7288gen_inlined_subroutine_die (stmt, context_die, depth)
a3f97cbb
JW		 7289 register tree stmt;
7290 register dw_die_ref context_die;
d7248bff 7291 int depth;
a3f97cbb 7292{
a3f97cbb
JW		 7293 if (!BLOCK_ABSTRACT (stmt))
7294 {
d7248bff 7295 register dw_die_ref subr_die = new_die (DW_TAG_inlined_subroutine,
7e23cb16 7296 context_die);
ab72d377 7297 register tree decl = block_ultimate_origin (stmt);
d7248bff 7298 char label[MAX_ARTIFICIAL_LABEL_BYTES];
ab72d377 7299 add_abstract_origin_attribute (subr_die, decl);
5c90448c
JM		 7300 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
7301 next_block_number);
a3f97cbb 7302 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
5c90448c 7303 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
a3f97cbb 7304 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
ab72d377 7305 push_decl_scope (decl);
d7248bff 7306 decls_for_scope (stmt, subr_die, depth);
ab72d377 7307 pop_decl_scope ();
7e23cb16 7308 current_function_has_inlines = 1;
a3f97cbb 7309 }
a3f97cbb
JW		 7310}
7311
7312/* Generate a DIE for a field in a record, or structure. */
7313static void
7314gen_field_die (decl, context_die)
7315 register tree decl;
7316 register dw_die_ref context_die;
7317{
7318 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
7319 add_name_and_src_coords_attributes (decl_die, decl);
a3f97cbb
JW		 7320 add_type_attribute (decl_die, member_declared_type (decl),
7321 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
7322 context_die);
7323 /* If this is a bit field... */
7324 if (DECL_BIT_FIELD_TYPE (decl))
7325 {
7326 add_byte_size_attribute (decl_die, decl);
7327 add_bit_size_attribute (decl_die, decl);
7328 add_bit_offset_attribute (decl_die, decl);
7329 }
a94dbf2c
JM		 7330 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
7331 add_data_member_location_attribute (decl_die, decl);
273dbe67
JM		 7332 if (DECL_ARTIFICIAL (decl))
7333 add_AT_flag (decl_die, DW_AT_artificial, 1);
a94dbf2c
JM		 7334 if (TREE_PROTECTED (decl))
7335 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
7336 else if (TREE_PRIVATE (decl))
7337 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
a3f97cbb
JW		 7338}
7339
ab72d377
JM		 7340#if 0
7341/* Don't generate either pointer_type DIEs or reference_type DIEs here.
7342 Use modified_type_die instead.
a3f97cbb
JW		 7343 We keep this code here just in case these types of DIEs may be needed to
7344 represent certain things in other languages (e.g. Pascal) someday. */
7345static void
7346gen_pointer_type_die (type, context_die)
7347 register tree type;
7348 register dw_die_ref context_die;
7349{
273dbe67
JM		 7350 register dw_die_ref ptr_die = new_die
7351 (DW_TAG_pointer_type, scope_die_for (type, context_die));
a3f97cbb 7352 equate_type_number_to_die (type, ptr_die);
a3f97cbb 7353 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
ab72d377 7354 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
a3f97cbb
JW		 7355}
7356
ab72d377
JM		 7357/* Don't generate either pointer_type DIEs or reference_type DIEs here.
7358 Use modified_type_die instead.
a3f97cbb
JW		 7359 We keep this code here just in case these types of DIEs may be needed to
7360 represent certain things in other languages (e.g. Pascal) someday. */
7361static void
7362gen_reference_type_die (type, context_die)
7363 register tree type;
7364 register dw_die_ref context_die;
7365{
273dbe67
JM		 7366 register dw_die_ref ref_die = new_die
7367 (DW_TAG_reference_type, scope_die_for (type, context_die));
a3f97cbb 7368 equate_type_number_to_die (type, ref_die);
a3f97cbb 7369 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
ab72d377 7370 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
a3f97cbb 7371}
ab72d377 7372#endif
a3f97cbb
JW		 7373
7374/* Generate a DIE for a pointer to a member type. */
7375static void
7376gen_ptr_to_mbr_type_die (type, context_die)
7377 register tree type;
7378 register dw_die_ref context_die;
7379{
ab72d377 7380 register dw_die_ref ptr_die = new_die
273dbe67 7381 (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
a3f97cbb 7382 equate_type_number_to_die (type, ptr_die);
a3f97cbb 7383 add_AT_die_ref (ptr_die, DW_AT_containing_type,
bdb669cb 7384 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
a3f97cbb
JW		 7385 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
7386}
7387
7388/* Generate the DIE for the compilation unit. */
7389static void
7390gen_compile_unit_die (main_input_filename)
7391 register char *main_input_filename;
7392{
7393 char producer[250];
a3f97cbb
JW		 7394 char *wd = getpwd ();
7395
7396 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
7397
bdb669cb
JM		 7398 add_name_attribute (comp_unit_die, main_input_filename);
7399
7400 if (wd)
a3f97cbb 7401 {
bdb669cb 7402 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
a3f97cbb
JW		 7403 }
7404
7405 sprintf (producer, "%s %s", language_string, version_string);
7406
7407#ifdef MIPS_DEBUGGING_INFO
7408 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
7409 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
7410 not appear in the producer string, the debugger reaches the conclusion
7411 that the object file is stripped and has no debugging information.
7412 To get the MIPS/SGI debugger to believe that there is debugging
7413 information in the object file, we add a -g to the producer string. */
4927276d
JM		 7414 if (debug_info_level > DINFO_LEVEL_TERSE)
7415 strcat (producer, " -g");
a3f97cbb
JW		 7416#endif
7417
7418 add_AT_string (comp_unit_die, DW_AT_producer, producer);
a9d38797 7419
a3f97cbb 7420 if (strcmp (language_string, "GNU C++") == 0)
a9d38797 7421 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
a3f97cbb 7422 else if (strcmp (language_string, "GNU Ada") == 0)
a9d38797
JM		 7423 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
7424 else if (strcmp (language_string, "GNU F77") == 0)
7425 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
a3f97cbb 7426 else if (flag_traditional)
a9d38797 7427 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
a3f97cbb 7428 else
a9d38797
JM		 7429 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
7430
7431#if 0 /* unimplemented */
e90b62db 7432 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
a9d38797
JM		 7433 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
7434#endif
a3f97cbb
JW		 7435}
7436
7437/* Generate a DIE for a string type. */
7438static void
7439gen_string_type_die (type, context_die)
7440 register tree type;
7441 register dw_die_ref context_die;
7442{
ab72d377
JM		 7443 register dw_die_ref type_die = new_die
7444 (DW_TAG_string_type, scope_die_for (type, context_die));
bdb669cb 7445 equate_type_number_to_die (type, type_die);
a3f97cbb
JW		 7446
7447 /* Fudge the string length attribute for now. */
7448
7449 /* TODO: add string length info.
7450 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
7451 bound_representation (upper_bound, 0, 'u'); */
7452}
7453
61b32c02
JM		 7454/* Generate the DIE for a base class. */
7455static void
7456gen_inheritance_die (binfo, context_die)
7457 register tree binfo;
7458 register dw_die_ref context_die;
7459{
7460 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
7461 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
7462 add_data_member_location_attribute (die, binfo);
7463 if (TREE_VIA_VIRTUAL (binfo))
7464 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7465 if (TREE_VIA_PUBLIC (binfo))
7466 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
7467 else if (TREE_VIA_PROTECTED (binfo))
7468 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
7469}
7470
a3f97cbb
JW		 7471/* Genearate a DIE for a class member. */
7472static void
7473gen_member_die (type, context_die)
7474 register tree type;
7475 register dw_die_ref context_die;
7476{
61b32c02 7477 register tree member;
a3f97cbb
JW		 7478 /* If this is not an incomplete type, output descriptions of each of its
7479 members. Note that as we output the DIEs necessary to represent the
7480 members of this record or union type, we will also be trying to output
7481 DIEs to represent the *types* of those members. However the `type'
7482 function (above) will specifically avoid generating type DIEs for member
7483 types *within* the list of member DIEs for this (containing) type execpt
7484 for those types (of members) which are explicitly marked as also being
7485 members of this (containing) type themselves. The g++ front- end can
7486 force any given type to be treated as a member of some other
7487 (containing) type by setting the TYPE_CONTEXT of the given (member) type
7488 to point to the TREE node representing the appropriate (containing)
7489 type. */
7490
61b32c02
JM		 7491 /* First output info about the base classes. */
7492 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
a3f97cbb 7493 {
61b32c02
JM		 7494 register tree bases = TYPE_BINFO_BASETYPES (type);
7495 register int n_bases = TREE_VEC_LENGTH (bases);
7496 register int i;
7497
7498 for (i = 0; i < n_bases; i++)
7499 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
a3f97cbb
JW		 7500 }
7501
61b32c02
JM		 7502 /* Now output info about the data members and type members. */
7503 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
7504 gen_decl_die (member, context_die);
7505
a3f97cbb 7506 /* Now output info about the function members (if any). */
61b32c02
JM		 7507 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
7508 gen_decl_die (member, context_die);
a3f97cbb
JW		 7509}
7510
7511/* Generate a DIE for a structure or union type. */
7512static void
273dbe67 7513gen_struct_or_union_type_die (type, context_die)
a3f97cbb 7514 register tree type;
a3f97cbb
JW		 7515 register dw_die_ref context_die;
7516{
273dbe67 7517 register dw_die_ref type_die = lookup_type_die (type);
a082c85a
JM		 7518 register dw_die_ref scope_die = 0;
7519 register int nested = 0;
273dbe67
JM		 7520
7521 if (type_die && ! TYPE_SIZE (type))
7522 return;
a082c85a
JM		 7523
7524 if (TYPE_CONTEXT (type)
7525 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't')
7526 nested = 1;
7527
a94dbf2c 7528 scope_die = scope_die_for (type, context_die);
a082c85a
JM		 7529
7530 if (! type_die || (nested && scope_die == comp_unit_die))
273dbe67 7531 /* First occurrence of type or toplevel definition of nested class. */
a3f97cbb 7532 {
273dbe67 7533 register dw_die_ref old_die = type_die;
a3f97cbb
JW		 7534 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
7535 ? DW_TAG_structure_type : DW_TAG_union_type,
a082c85a 7536 scope_die);
a3f97cbb
JW		 7537 equate_type_number_to_die (type, type_die);
7538 add_name_attribute (type_die, type_tag (type));
273dbe67
JM		 7539 if (old_die)
7540 add_AT_die_ref (type_die, DW_AT_specification, old_die);
a3f97cbb 7541 }
4b674448 7542 else
273dbe67 7543 remove_AT (type_die, DW_AT_declaration);
a3f97cbb 7544
a94dbf2c
JM		 7545 /* If we're not in the right context to be defining this type, defer to
7546 avoid tricky recursion. */
7547 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
7548 {
7549 add_AT_flag (type_die, DW_AT_declaration, 1);
7550 pend_type (type);
7551 }
a3f97cbb
JW		 7552 /* If this type has been completed, then give it a byte_size attribute and
7553 then give a list of members. */
a94dbf2c 7554 else if (TYPE_SIZE (type))
a3f97cbb
JW		 7555 {
7556 /* Prevent infinite recursion in cases where the type of some member of
7557 this type is expressed in terms of this type itself. */
7558 TREE_ASM_WRITTEN (type) = 1;
273dbe67 7559 add_byte_size_attribute (type_die, type);
b2932ae5
JM		 7560 if (type_tag (type))
7561 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
273dbe67
JM		 7562 push_decl_scope (type);
7563 gen_member_die (type, type_die);
7564 pop_decl_scope ();
a94dbf2c
JM		 7565 /* GNU extension: Record what type our vtable lives in. */
7566 if (TYPE_VFIELD (type))
7567 {
7568 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
7569 gen_type_die (vtype, context_die);
7570 add_AT_die_ref (type_die, DW_AT_containing_type,
7571 lookup_type_die (vtype));
7572 }
a3f97cbb 7573 }
4b674448
JM		 7574 else
7575 add_AT_flag (type_die, DW_AT_declaration, 1);
a3f97cbb
JW		 7576}
7577
7578/* Generate a DIE for a subroutine _type_. */
7579static void
7580gen_subroutine_type_die (type, context_die)
7581 register tree type;
7582 register dw_die_ref context_die;
7583{
7584 register tree return_type = TREE_TYPE (type);
273dbe67
JM		 7585 register dw_die_ref subr_die = new_die
7586 (DW_TAG_subroutine_type, scope_die_for (type, context_die));
a3f97cbb
JW		 7587 equate_type_number_to_die (type, subr_die);
7588 add_prototyped_attribute (subr_die, type);
a3f97cbb 7589 add_type_attribute (subr_die, return_type, 0, 0, context_die);
a94dbf2c 7590 gen_formal_types_die (type, subr_die);
a3f97cbb
JW		 7591}
7592
7593/* Generate a DIE for a type definition */
7594static void
7595gen_typedef_die (decl, context_die)
7596 register tree decl;
7597 register dw_die_ref context_die;
7598{
a3f97cbb 7599 register dw_die_ref type_die;
a94dbf2c
JM		 7600 register tree origin;
7601
7602 if (TREE_ASM_WRITTEN (decl))
7603 return;
7604 TREE_ASM_WRITTEN (decl) = 1;
7605
ab72d377 7606 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
a94dbf2c 7607 origin = decl_ultimate_origin (decl);
a3f97cbb 7608 if (origin != NULL)
a94dbf2c 7609 add_abstract_origin_attribute (type_die, origin);
a3f97cbb
JW		 7610 else
7611 {
a94dbf2c 7612 register tree type;
a3f97cbb 7613 add_name_and_src_coords_attributes (type_die, decl);
a94dbf2c
JM		 7614 if (DECL_ORIGINAL_TYPE (decl))
7615 {
7616 type = DECL_ORIGINAL_TYPE (decl);
7617 equate_type_number_to_die (TREE_TYPE (decl), type_die);
7618 }
7619 else
7620 type = TREE_TYPE (decl);
7621 add_type_attribute (type_die, type, TREE_READONLY (decl),
7622 TREE_THIS_VOLATILE (decl), context_die);
a3f97cbb
JW		 7623 }
7624 if (DECL_ABSTRACT (decl))
a94dbf2c 7625 equate_decl_number_to_die (decl, type_die);
a3f97cbb
JW		 7626}
7627
7628/* Generate a type description DIE. */
7629static void
7630gen_type_die (type, context_die)
7631 register tree type;
7632 register dw_die_ref context_die;
7633{
a3f97cbb
JW		 7634 if (type == 0 || type == error_mark_node)
7635 {
7636 return;
7637 }
7638
7639 /* We are going to output a DIE to represent the unqualified version of of
7640 this type (i.e. without any const or volatile qualifiers) so get the
7641 main variant (i.e. the unqualified version) of this type now. */
7642 type = type_main_variant (type);
7643
7644 if (TREE_ASM_WRITTEN (type))
7645 {
7646 return;
7647 }
7648
a94dbf2c
JM		 7649 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7650 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
7651 {
7652 TREE_ASM_WRITTEN (type) = 1;
7653 gen_decl_die (TYPE_NAME (type), context_die);
7654 return;
7655 }
7656
a3f97cbb
JW		 7657 switch (TREE_CODE (type))
7658 {
7659 case ERROR_MARK:
7660 break;
7661
7662 case POINTER_TYPE:
7663 case REFERENCE_TYPE:
7664 /* For these types, all that is required is that we output a DIE (or a
7665 set of DIEs) to represent the "basis" type. */
7666 gen_type_die (TREE_TYPE (type), context_die);
7667 break;
7668
7669 case OFFSET_TYPE:
7670 /* This code is used for C++ pointer-to-data-member types. */
7671 /* Output a description of the relevant class type. */
7672 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
7673 /* Output a description of the type of the object pointed to. */
7674 gen_type_die (TREE_TYPE (type), context_die);
7675 /* Now output a DIE to represent this pointer-to-data-member type
7676 itself. */
7677 gen_ptr_to_mbr_type_die (type, context_die);
7678 break;
7679
7680 case SET_TYPE:
7681 gen_type_die (TYPE_DOMAIN (type), context_die);
7682 gen_set_type_die (type, context_die);
7683 break;
7684
7685 case FILE_TYPE:
7686 gen_type_die (TREE_TYPE (type), context_die);
7687 abort (); /* No way to represent these in Dwarf yet! */
7688 break;
7689
7690 case FUNCTION_TYPE:
7691 /* Force out return type (in case it wasn't forced out already). */
7692 gen_type_die (TREE_TYPE (type), context_die);
7693 gen_subroutine_type_die (type, context_die);
7694 break;
7695
7696 case METHOD_TYPE:
7697 /* Force out return type (in case it wasn't forced out already). */
7698 gen_type_die (TREE_TYPE (type), context_die);
7699 gen_subroutine_type_die (type, context_die);
7700 break;
7701
7702 case ARRAY_TYPE:
7703 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
7704 {
7705 gen_type_die (TREE_TYPE (type), context_die);
7706 gen_string_type_die (type, context_die);
7707 }
7708 else
7709 {
7710 gen_array_type_die (type, context_die);
7711 }
7712 break;
7713
7714 case ENUMERAL_TYPE:
7715 case RECORD_TYPE:
7716 case UNION_TYPE:
7717 case QUAL_UNION_TYPE:
a082c85a
JM		 7718 /* If this is a nested type whose containing class hasn't been
7719 written out yet, writing it out will cover this one, too. */
7720 if (TYPE_CONTEXT (type)
7721 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
7722 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
a94dbf2c
JM		 7723 {
7724 gen_type_die (TYPE_CONTEXT (type), context_die);
7725
7726 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
7727 return;
7728
7729 /* If that failed, attach ourselves to the stub. */
7730 push_decl_scope (TYPE_CONTEXT (type));
7731 context_die = lookup_type_die (TYPE_CONTEXT (type));
7732 }
7733
7734 if (TREE_CODE (type) == ENUMERAL_TYPE)
273dbe67 7735 gen_enumeration_type_die (type, context_die);
a3f97cbb 7736 else
273dbe67 7737 gen_struct_or_union_type_die (type, context_die);
4b674448 7738
a94dbf2c
JM		 7739 if (TYPE_CONTEXT (type)
7740 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
7741 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
7742 pop_decl_scope ();
7743
4b674448 7744 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
a082c85a
JM		 7745 it up if it is ever completed. gen_*_type_die will set it for us
7746 when appropriate. */
7747 return;
a3f97cbb
JW		 7748
7749 case VOID_TYPE:
7750 case INTEGER_TYPE:
7751 case REAL_TYPE:
7752 case COMPLEX_TYPE:
7753 case BOOLEAN_TYPE:
7754 case CHAR_TYPE:
7755 /* No DIEs needed for fundamental types. */
7756 break;
7757
7758 case LANG_TYPE:
7759 /* No Dwarf representation currently defined. */
7760 break;
7761
7762 default:
7763 abort ();
7764 }
7765
7766 TREE_ASM_WRITTEN (type) = 1;
7767}
7768
7769/* Generate a DIE for a tagged type instantiation. */
7770static void
7771gen_tagged_type_instantiation_die (type, context_die)
7772 register tree type;
7773 register dw_die_ref context_die;
7774{
7775 if (type == 0 || type == error_mark_node)
7776 {
7777 return;
7778 }
7779
7780 /* We are going to output a DIE to represent the unqualified version of of
7781 this type (i.e. without any const or volatile qualifiers) so make sure
7782 that we have the main variant (i.e. the unqualified version) of this
7783 type now. */
7784 assert (type == type_main_variant (type));
7785 assert (TREE_ASM_WRITTEN (type));
7786
7787 switch (TREE_CODE (type))
7788 {
7789 case ERROR_MARK:
7790 break;
7791
7792 case ENUMERAL_TYPE:
7793 gen_inlined_enumeration_type_die (type, context_die);
7794 break;
7795
7796 case RECORD_TYPE:
7797 gen_inlined_structure_type_die (type, context_die);
7798 break;
7799
7800 case UNION_TYPE:
7801 case QUAL_UNION_TYPE:
7802 gen_inlined_union_type_die (type, context_die);
7803 break;
7804
7805 default:
7806 abort (); /* Should never happen. */
7807 }
7808}
7809
7810/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
7811 things which are local to the given block. */
7812static void
d7248bff 7813gen_block_die (stmt, context_die, depth)
a3f97cbb
JW		 7814 register tree stmt;
7815 register dw_die_ref context_die;
d7248bff 7816 int depth;
a3f97cbb
JW		 7817{
7818 register int must_output_die = 0;
7819 register tree origin;
7820 register tree decl;
7821 register enum tree_code origin_code;
7822
7823 /* Ignore blocks never really used to make RTL. */
7824
7825 if (!stmt || !TREE_USED (stmt))
7826 {
7827 return;
7828 }
7829
7830 /* Determine the "ultimate origin" of this block. This block may be an
7831 inlined instance of an inlined instance of inline function, so we have
7832 to trace all of the way back through the origin chain to find out what
7833 sort of node actually served as the original seed for the creation of
7834 the current block. */
7835 origin = block_ultimate_origin (stmt);
7836 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
7837
7838 /* Determine if we need to output any Dwarf DIEs at all to represent this
7839 block. */
7840 if (origin_code == FUNCTION_DECL)
7841 {
7842 /* The outer scopes for inlinings *must* always be represented. We
7843 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
7844 must_output_die = 1;
7845 }
7846 else
7847 {
7848 /* In the case where the current block represents an inlining of the
7849 "body block" of an inline function, we must *NOT* output any DIE for
7850 this block because we have already output a DIE to represent the
7851 whole inlined function scope and the "body block" of any function
7852 doesn't really represent a different scope according to ANSI C
7853 rules. So we check here to make sure that this block does not
7854 represent a "body block inlining" before trying to set the
7855 `must_output_die' flag. */
d7248bff 7856 if (! is_body_block (origin ? origin : stmt))
a3f97cbb
JW		 7857 {
7858 /* Determine if this block directly contains any "significant"
7859 local declarations which we will need to output DIEs for. */
7860 if (debug_info_level > DINFO_LEVEL_TERSE)
7861 {
7862 /* We are not in terse mode so *any* local declaration counts
7863 as being a "significant" one. */
7864 must_output_die = (BLOCK_VARS (stmt) != NULL);
7865 }
7866 else
7867 {
7868 /* We are in terse mode, so only local (nested) function
7869 definitions count as "significant" local declarations. */
7870 for (decl = BLOCK_VARS (stmt);
7871 decl != NULL; decl = TREE_CHAIN (decl))
7872 {
7873 if (TREE_CODE (decl) == FUNCTION_DECL
7874 && DECL_INITIAL (decl))
7875 {
7876 must_output_die = 1;
7877 break;
7878 }
7879 }
7880 }
7881 }
7882 }
7883
7884 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
7885 DIE for any block which contains no significant local declarations at
7886 all. Rather, in such cases we just call `decls_for_scope' so that any
7887 needed Dwarf info for any sub-blocks will get properly generated. Note
7888 that in terse mode, our definition of what constitutes a "significant"
7889 local declaration gets restricted to include only inlined function
7890 instances and local (nested) function definitions. */
7891 if (must_output_die)
7892 {
7893 if (origin_code == FUNCTION_DECL)
7894 {
d7248bff 7895 gen_inlined_subroutine_die (stmt, context_die, depth);
a3f97cbb
JW		 7896 }
7897 else
7898 {
d7248bff 7899 gen_lexical_block_die (stmt, context_die, depth);
a3f97cbb
JW		 7900 }
7901 }
7902 else
d7248bff 7903 decls_for_scope (stmt, context_die, depth);
a3f97cbb
JW		 7904}
7905
7906/* Generate all of the decls declared within a given scope and (recursively)
7907 all of it's sub-blocks. */
7908static void
d7248bff 7909decls_for_scope (stmt, context_die, depth)
a3f97cbb
JW		 7910 register tree stmt;
7911 register dw_die_ref context_die;
d7248bff 7912 int depth;
a3f97cbb
JW		 7913{
7914 register tree decl;
7915 register tree subblocks;
7916 /* Ignore blocks never really used to make RTL. */
7917 if (!stmt || !TREE_USED (stmt))
7918 {
7919 return;
7920 }
d7248bff 7921 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
a3f97cbb
JW		 7922 {
7923 next_block_number++;
7924 }
7925
88dad228
JM		 7926 /* Output the DIEs to represent all of the data objects and typedefs
7927 declared directly within this block but not within any nested
7928 sub-blocks. Also, nested function and tag DIEs have been
7929 generated with a parent of NULL; fix that up now. */
a3f97cbb
JW		 7930 for (decl = BLOCK_VARS (stmt);
7931 decl != NULL; decl = TREE_CHAIN (decl))
7932 {
a94dbf2c
JM		 7933 register dw_die_ref die;
7934
88dad228 7935 if (TREE_CODE (decl) == FUNCTION_DECL)
a94dbf2c 7936 die = lookup_decl_die (decl);
88dad228 7937 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
a94dbf2c
JM		 7938 die = lookup_type_die (TREE_TYPE (decl));
7939 else
7940 die = NULL;
7941
7942 if (die && die->die_parent == NULL)
88dad228 7943 {
a94dbf2c
JM		 7944 add_child_die (context_die, die);
7945 --limbo_die_count;
88dad228
JM		 7946 }
7947 else
7948 gen_decl_die (decl, context_die);
a3f97cbb
JW		 7949 }
7950
7951 /* Output the DIEs to represent all sub-blocks (and the items declared
7952 therein) of this block. */
7953 for (subblocks = BLOCK_SUBBLOCKS (stmt);
7954 subblocks != NULL;
7955 subblocks = BLOCK_CHAIN (subblocks))
7956 {
d7248bff 7957 gen_block_die (subblocks, context_die, depth + 1);
a3f97cbb
JW		 7958 }
7959}
7960
a94dbf2c
JM		 7961/* Is this a typedef we can avoid emitting? */
7962inline int
7963is_redundant_typedef (decl)
7964 register tree decl;
7965{
7966 if (TYPE_DECL_IS_STUB (decl))
7967 return 1;
7968 if (DECL_ARTIFICIAL (decl)
7969 && DECL_CONTEXT (decl)
7970 && is_tagged_type (DECL_CONTEXT (decl))
7971 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
7972 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
7973 /* Also ignore the artificial member typedef for the class name. */
7974 return 1;
7975 return 0;
7976}
7977
a3f97cbb
JW		 7978/* Generate Dwarf debug information for a decl described by DECL. */
7979static void
7980gen_decl_die (decl, context_die)
7981 register tree decl;
7982 register dw_die_ref context_die;
7983{
7984 register tree origin;
7985 /* Make a note of the decl node we are going to be working on. We may need
7986 to give the user the source coordinates of where it appeared in case we
7987 notice (later on) that something about it looks screwy. */
7988 dwarf_last_decl = decl;
7989
7990 if (TREE_CODE (decl) == ERROR_MARK)
7991 {
7992 return;
7993 }
7994
7995 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
7996 ignore a function definition, since that would screw up our count of
7997 blocks, and that it turn will completely screw up the the labels we will
7998 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
7999 subsequent blocks). */
8000 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
8001 {
8002 return;
8003 }
8004
a3f97cbb
JW		 8005 switch (TREE_CODE (decl))
8006 {
8007 case CONST_DECL:
8008 /* The individual enumerators of an enum type get output when we output
8009 the Dwarf representation of the relevant enum type itself. */
8010 break;
8011
8012 case FUNCTION_DECL:
4edb7b60
JM		 8013 /* Don't output any DIEs to represent mere function declarations,
8014 unless they are class members or explicit block externs. */
8015 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
8016 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
a3f97cbb
JW		 8017 {
8018 break;
8019 }
bdb669cb 8020
4927276d 8021 if (debug_info_level > DINFO_LEVEL_TERSE)
a94dbf2c
JM		 8022 {
8023 /* Before we describe the FUNCTION_DECL itself, make sure that we
8024 have described its return type. */
8025 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
8026
8027 /* And its containing type. */
8028 origin = decl_class_context (decl);
8029 if (origin)
8030 gen_type_die (origin, context_die);
8031
8032 /* And its virtual context. */
8033 if (DECL_VINDEX (decl))
8034 gen_type_die (DECL_CONTEXT (decl), context_die);
8035 }
a3f97cbb
JW		 8036
8037 /* Now output a DIE to represent the function itself. */
8038 gen_subprogram_die (decl, context_die);
8039 break;
8040
8041 case TYPE_DECL:
8042 /* If we are in terse mode, don't generate any DIEs to represent any
4927276d 8043 actual typedefs. */
a3f97cbb 8044 if (debug_info_level <= DINFO_LEVEL_TERSE)
4927276d 8045 break;
a3f97cbb 8046
5c90448c
JM		 8047 /* In the special case of a TYPE_DECL node representing the
8048 declaration of some type tag, if the given TYPE_DECL is marked as
a3f97cbb
JW		 8049 having been instantiated from some other (original) TYPE_DECL node
8050 (e.g. one which was generated within the original definition of an
8051 inline function) we have to generate a special (abbreviated)
8052 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration-type
8053 DIE here. */
5c90448c 8054 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl))
a3f97cbb
JW		 8055 {
8056 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
8057 break;
8058 }
a3f97cbb 8059
a94dbf2c
JM		 8060 if (is_redundant_typedef (decl))
8061 gen_type_die (TREE_TYPE (decl), context_die);
8062 else
a3f97cbb
JW		 8063 {
8064 /* Output a DIE to represent the typedef itself. */
8065 gen_typedef_die (decl, context_die);
8066 }
8067 break;
8068
8069 case LABEL_DECL:
8070 if (debug_info_level >= DINFO_LEVEL_NORMAL)
8071 {
8072 gen_label_die (decl, context_die);
8073 }
8074 break;
8075
8076 case VAR_DECL:
8077 /* If we are in terse mode, don't generate any DIEs to represent any
8078 variable declarations or definitions. */
8079 if (debug_info_level <= DINFO_LEVEL_TERSE)
8080 {
8081 break;
8082 }
8083
8084 /* Output any DIEs that are needed to specify the type of this data
8085 object. */
8086 gen_type_die (TREE_TYPE (decl), context_die);
8087
a94dbf2c
JM		 8088 /* And its containing type. */
8089 origin = decl_class_context (decl);
8090 if (origin)
8091 gen_type_die (origin, context_die);
8092
a3f97cbb
JW		 8093 /* Now output the DIE to represent the data object itself. This gets
8094 complicated because of the possibility that the VAR_DECL really
8095 represents an inlined instance of a formal parameter for an inline
8096 function. */
8097 origin = decl_ultimate_origin (decl);
8098 if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
8099 {
8100 gen_formal_parameter_die (decl, context_die);
8101 }
8102 else
8103 {
8104 gen_variable_die (decl, context_die);
8105 }
8106 break;
8107
8108 case FIELD_DECL:
a94dbf2c
JM		 8109 /* Ignore the nameless fields that are used to skip bits, but
8110 handle C++ anonymous unions. */
8111 if (DECL_NAME (decl) != 0 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
a3f97cbb
JW		 8112 {
8113 gen_type_die (member_declared_type (decl), context_die);
8114 gen_field_die (decl, context_die);
8115 }
8116 break;
8117
8118 case PARM_DECL:
8119 gen_type_die (TREE_TYPE (decl), context_die);
8120 gen_formal_parameter_die (decl, context_die);
8121 break;
8122
8123 default:
8124 abort ();
8125 }
a3f97cbb
JW		 8126}
8127\f
8128/***************** Debug Information Generation Hooks ***********************/
8129void
88dad228 8130dwarf2out_decl (decl)
a3f97cbb 8131 register tree decl;
a3f97cbb 8132{
88dad228
JM		 8133 register dw_die_ref context_die = comp_unit_die;
8134
a3f97cbb
JW		 8135 if (TREE_CODE (decl) == ERROR_MARK)
8136 {
8137 return;
8138 }
8139
8140 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
8141 hope that the node in question doesn't represent a function definition.
8142 If it does, then totally ignoring it is bound to screw up our count of
8143 blocks, and that it turn will completely screw up the the labels we will
8144 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
8145 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
8146 own sequence numbers with them!) */
8147 if (DECL_IGNORED_P (decl))
8148 {
8149 if (TREE_CODE (decl) == FUNCTION_DECL
8150 && DECL_INITIAL (decl) != NULL)
8151 {
8152 abort ();
8153 }
8154 return;
8155 }
8156
8157 switch (TREE_CODE (decl))
8158 {
8159 case FUNCTION_DECL:
8160 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
8161 builtin function. Explicit programmer-supplied declarations of
8162 these same functions should NOT be ignored however. */
8163 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
8164 {
8165 return;
8166 }
8167
8168 /* What we would really like to do here is to filter out all mere
8169 file-scope declarations of file-scope functions which are never
8170 referenced later within this translation unit (and keep all of ones
8171 that *are* referenced later on) but we aren't clarvoiant, so we have
8172 no idea which functions will be referenced in the future (i.e. later
8173 on within the current translation unit). So here we just ignore all
8174 file-scope function declarations which are not also definitions. If
8175 and when the debugger needs to know something about these funcstion,
8176 it wil have to hunt around and find the DWARF information associated
8177 with the definition of the function. Note that we can't just check
8178 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
8179 definitions and which ones represent mere declarations. We have to
8180 check `DECL_INITIAL' instead. That's because the C front-end
8181 supports some weird semantics for "extern inline" function
8182 definitions. These can get inlined within the current translation
8183 unit (an thus, we need to generate DWARF info for their abstract
8184 instances so that the DWARF info for the concrete inlined instances
8185 can have something to refer to) but the compiler never generates any
8186 out-of-lines instances of such things (despite the fact that they
8187 *are* definitions). The important point is that the C front-end
8188 marks these "extern inline" functions as DECL_EXTERNAL, but we need
273dbe67 8189 to generate DWARF for them anyway. Note that the C++ front-end also
a3f97cbb
JW		 8190 plays some similar games for inline function definitions appearing
8191 within include files which also contain
8192 `#pragma interface' pragmas. */
8193 if (DECL_INITIAL (decl) == NULL_TREE)
8194 {
8195 return;
8196 }
88dad228
JM		 8197
8198 /* If we're a nested function, initially use a parent of NULL; if we're
8199 a plain function, this will be fixed up in decls_for_scope. If
8200 we're a method, it will be ignored, since we already have a DIE. */
8201 if (decl_function_context (decl))
8202 context_die = NULL;
8203
a3f97cbb
JW		 8204 break;
8205
8206 case VAR_DECL:
8207 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
8208 declaration and if the declaration was never even referenced from
8209 within this entire compilation unit. We suppress these DIEs in
8210 order to save space in the .debug section (by eliminating entries
8211 which are probably useless). Note that we must not suppress
8212 block-local extern declarations (whether used or not) because that
8213 would screw-up the debugger's name lookup mechanism and cause it to
8214 miss things which really ought to be in scope at a given point. */
8215 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
8216 {
8217 return;
8218 }
8219
8220 /* If we are in terse mode, don't generate any DIEs to represent any
8221 variable declarations or definitions. */
8222 if (debug_info_level <= DINFO_LEVEL_TERSE)
8223 {
8224 return;
8225 }
8226 break;
8227
8228 case TYPE_DECL:
8229 /* Don't bother trying to generate any DIEs to represent any of the
a9d38797
JM		 8230 normal built-in types for the language we are compiling. */
8231 if (DECL_SOURCE_LINE (decl) == 0)
a94dbf2c
JM		 8232 {
8233 /* OK, we need to generate one for `bool' so GDB knows what type
8234 comparisons have. */
8235 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
8236 == DW_LANG_C_plus_plus)
8237 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
8238 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
8239 return;
8240 }
a3f97cbb 8241
88dad228 8242 /* If we are in terse mode, don't generate any DIEs for types. */
a3f97cbb 8243 if (debug_info_level <= DINFO_LEVEL_TERSE)
4927276d 8244 return;
88dad228
JM		 8245
8246 /* If we're a function-scope tag, initially use a parent of NULL;
8247 this will be fixed up in decls_for_scope. */
8248 if (decl_function_context (decl))
8249 context_die = NULL;
8250
a3f97cbb
JW		 8251 break;
8252
8253 default:
8254 return;
8255 }
8256
88dad228 8257 gen_decl_die (decl, context_die);
a94dbf2c 8258 output_pending_types_for_scope (comp_unit_die);
a3f97cbb
JW		 8259
8260 if (TREE_CODE (decl) == FUNCTION_DECL
8261 && DECL_INITIAL (decl) != NULL)
8262 {
8263 current_funcdef_number++;
8264 }
8265
8266}
8267
8268/* Output a marker (i.e. a label) for the beginning of the generated code for
8269 a lexical block. */
8270void
9a666dda 8271dwarf2out_begin_block (blocknum)
a3f97cbb
JW		 8272 register unsigned blocknum;
8273{
a3f97cbb 8274 function_section (current_function_decl);
5c90448c 8275 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
a3f97cbb
JW		 8276}
8277
8278/* Output a marker (i.e. a label) for the end of the generated code for a
8279 lexical block. */
8280void
9a666dda 8281dwarf2out_end_block (blocknum)
a3f97cbb
JW		 8282 register unsigned blocknum;
8283{
a3f97cbb 8284 function_section (current_function_decl);
5c90448c 8285 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
a3f97cbb
JW		 8286}
8287
8288/* Output a marker (i.e. a label) at a point in the assembly code which
8289 corresponds to a given source level label. */
8290void
9a666dda 8291dwarf2out_label (insn)
a3f97cbb
JW		 8292 register rtx insn;
8293{
8294 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8295 if (debug_info_level >= DINFO_LEVEL_NORMAL)
8296 {
8297 function_section (current_function_decl);
5c90448c
JM		 8298 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
8299 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
8300 (unsigned) INSN_UID (insn));
a3f97cbb
JW		 8301 }
8302}
8303
d291dd49
JM		 8304/* Output a marker (i.e. a label) for the beginning of a function, before
8305 the prologue. */
a3f97cbb 8306void
9a666dda 8307dwarf2out_begin_prologue ()
a3f97cbb
JW		 8308{
8309 char label[MAX_ARTIFICIAL_LABEL_BYTES];
a3f97cbb 8310 register dw_fde_ref fde;
a3f97cbb
JW		 8311
8312 function_section (current_function_decl);
5c90448c
JM		 8313 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
8314 current_funcdef_number);
a3f97cbb
JW		 8315 ASM_OUTPUT_LABEL (asm_out_file, label);
8316
8317 /* Expand the fde table if necessary. */
8318 if (fde_table_in_use == fde_table_allocated)
8319 {
8320 fde_table_allocated += FDE_TABLE_INCREMENT;
8321 fde_table = (dw_fde_ref) xrealloc (fde_table,
8322 fde_table_allocated * sizeof (dw_fde_node));
8323 }
8324
8325 /* Record the FDE associated with this function. */
8326 current_funcdef_fde = fde_table_in_use;
8327
8328 /* Add the new FDE at the end of the fde_table. */
8329 fde = &fde_table[fde_table_in_use++];
7d4440be 8330 fde->dw_fde_begin = xstrdup (label);
a94dbf2c 8331 fde->dw_fde_current_label = NULL;
a3f97cbb
JW		 8332 fde->dw_fde_end = NULL;
8333 fde->dw_fde_cfi = NULL;
d291dd49
JM		 8334}
8335
a3f97cbb
JW		 8336/* Output a marker (i.e. a label) for the absolute end of the generated code
8337 for a function definition. This gets called *after* the epilogue code has
8338 been generated. */
8339void
9a666dda 8340dwarf2out_end_epilogue ()
a3f97cbb
JW		 8341{
8342 dw_fde_ref fde;
8343 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8344 /* Output a label to mark the endpoint of the code generated for this
8345 function. */
5c90448c 8346 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
a3f97cbb
JW		 8347 ASM_OUTPUT_LABEL (asm_out_file, label);
8348 fde = &fde_table[fde_table_in_use - 1];
8349 fde->dw_fde_end = xstrdup (label);
8350}
8351
8352/* Lookup a filename (in the list of filenames that we know about here in
9a666dda 8353 dwarf2out.c) and return its "index". The index of each (known) filename is
a3f97cbb
JW		 8354 just a unique number which is associated with only that one filename.
8355 We need such numbers for the sake of generating labels
8356 (in the .debug_sfnames section) and references to those
8357 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
8358 If the filename given as an argument is not found in our current list,
8359 add it to the list and assign it the next available unique index number.
8360 In order to speed up searches, we remember the index of the filename
8361 was looked up last. This handles the majority of all searches. */
8362static unsigned
8363lookup_filename (file_name)
8364 char *file_name;
8365{
8366 static unsigned last_file_lookup_index = 0;
8367 register char *fn;
8368 register unsigned i;
8369
8370 /* Check to see if the file name that was searched on the previous call
8371 matches this file name. If so, return the index. */
8372 if (last_file_lookup_index != 0)
8373 {
8374 fn = file_table[last_file_lookup_index];
8375 if (strcmp (file_name, fn) == 0)
8376 {
8377 return last_file_lookup_index;
8378 }
8379 }
8380
8381 /* Didn't match the previous lookup, search the table */
8382 for (i = 1; i < file_table_in_use; ++i)
8383 {
8384 fn = file_table[i];
8385 if (strcmp (file_name, fn) == 0)
8386 {
8387 last_file_lookup_index = i;
8388 return i;
8389 }
8390 }
8391
8392 /* Prepare to add a new table entry by making sure there is enough space in
8393 the table to do so. If not, expand the current table. */
8394 if (file_table_in_use == file_table_allocated)
8395 {
8396 file_table_allocated += FILE_TABLE_INCREMENT;
8397 file_table
8398 = (char **)
8399 xrealloc (file_table, file_table_allocated * sizeof (char *));
8400 }
8401
8402 /* add the new entry to the end of the filename table. */
8403 file_table[file_table_in_use] = xstrdup (file_name);
8404 last_file_lookup_index = file_table_in_use++;
8405 return last_file_lookup_index;
8406}
8407
8408/* Output a label to mark the beginning of a source code line entry
8409 and record information relating to this source line, in
8410 'line_info_table' for later output of the .debug_line section. */
8411void
9a666dda 8412dwarf2out_line (filename, line)
a3f97cbb
JW		 8413 register char *filename;
8414 register unsigned line;
8415{
a3f97cbb
JW		 8416 if (debug_info_level >= DINFO_LEVEL_NORMAL)
8417 {
8418 function_section (current_function_decl);
a3f97cbb 8419
e90b62db 8420 if (DECL_SECTION_NAME (current_function_decl))
a3f97cbb 8421 {
e90b62db 8422 register dw_separate_line_info_ref line_info;
5c90448c
JM		 8423 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
8424 separate_line_info_table_in_use);
e90b62db
JM		 8425 fputc ('\n', asm_out_file);
8426
8427 /* expand the line info table if necessary */
8428 if (separate_line_info_table_in_use
8429 == separate_line_info_table_allocated)
8430 {
8431 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
8432 separate_line_info_table
8433 = (dw_separate_line_info_ref) xrealloc
8434 (separate_line_info_table,
8435 separate_line_info_table_allocated
8436 * sizeof (dw_separate_line_info_entry));
8437 }
8438 /* add the new entry at the end of the line_info_table. */
8439 line_info
8440 = &separate_line_info_table[separate_line_info_table_in_use++];
8441 line_info->dw_file_num = lookup_filename (filename);
8442 line_info->dw_line_num = line;
8443 line_info->function = current_funcdef_number;
8444 }
8445 else
8446 {
8447 register dw_line_info_ref line_info;
5c90448c
JM		 8448 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
8449 line_info_table_in_use);
e90b62db
JM		 8450 fputc ('\n', asm_out_file);
8451
8452 /* expand the line info table if necessary */
8453 if (line_info_table_in_use == line_info_table_allocated)
8454 {
8455 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
8456 line_info_table
8457 = (dw_line_info_ref) xrealloc
8458 (line_info_table,
8459 line_info_table_allocated * sizeof (dw_line_info_entry));
8460 }
8461 /* add the new entry at the end of the line_info_table. */
8462 line_info = &line_info_table[line_info_table_in_use++];
8463 line_info->dw_file_num = lookup_filename (filename);
8464 line_info->dw_line_num = line;
a3f97cbb 8465 }
a3f97cbb
JW		 8466 }
8467}
8468
8469/* Record the beginning of a new source file, for later output
8470 of the .debug_macinfo section. At present, unimplemented. */
8471void
9a666dda 8472dwarf2out_start_source_file (filename)
a3f97cbb
JW		 8473 register char *filename;
8474{
8475}
8476
9a666dda 8477/* Record the end of a source file, for later output
a3f97cbb
JW		 8478 of the .debug_macinfo section. At present, unimplemented. */
8479void
9a666dda 8480dwarf2out_end_source_file ()
a3f97cbb
JW		 8481{
8482}
8483
8484/* Called from check_newline in c-parse.y. The `buffer' parameter contains
8485 the tail part of the directive line, i.e. the part which is past the
8486 initial whitespace, #, whitespace, directive-name, whitespace part. */
8487void
9a666dda 8488dwarf2out_define (lineno, buffer)
a3f97cbb
JW		 8489 register unsigned lineno;
8490 register char *buffer;
8491{
8492 static int initialized = 0;
8493 if (!initialized)
8494 {
9a666dda 8495 dwarf2out_start_source_file (primary_filename);
a3f97cbb
JW		 8496 initialized = 1;
8497 }
8498}
8499
8500/* Called from check_newline in c-parse.y. The `buffer' parameter contains
8501 the tail part of the directive line, i.e. the part which is past the
8502 initial whitespace, #, whitespace, directive-name, whitespace part. */
8503void
9a666dda 8504dwarf2out_undef (lineno, buffer)
a3f97cbb
JW		 8505 register unsigned lineno;
8506 register char *buffer;
8507{
8508}
8509
8510/* Set up for Dwarf output at the start of compilation. */
8511void
9a666dda 8512dwarf2out_init (asm_out_file, main_input_filename)
a3f97cbb
JW		 8513 register FILE *asm_out_file;
8514 register char *main_input_filename;
8515{
a3f97cbb
JW		 8516 /* Remember the name of the primary input file. */
8517 primary_filename = main_input_filename;
8518
8519 /* Allocate the initial hunk of the file_table. */
8520 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
8521 bzero (file_table, FILE_TABLE_INCREMENT * sizeof (char *));
8522 file_table_allocated = FILE_TABLE_INCREMENT;
8523 /* skip the first entry - file numbers begin at 1 */
8524 file_table_in_use = 1;
8525
a3f97cbb
JW		 8526 /* Allocate the initial hunk of the decl_die_table. */
8527 decl_die_table
8528 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8529 bzero (decl_die_table, DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8530 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
8531 decl_die_table_in_use = 0;
8532
8533 /* Allocate the initial hunk of the decl_scope_table. */
8534 decl_scope_table
8535 = (tree *) xmalloc (DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
8536 bzero (decl_scope_table, DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
8537 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
8538 decl_scope_depth = 0;
8539
8540 /* Allocate the initial hunk of the abbrev_die_table. */
8541 abbrev_die_table
8542 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
8543 * sizeof (dw_die_ref));
8544 bzero (abbrev_die_table, ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8545 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
8546 /* zero-th entry is allocated, but unused */
8547 abbrev_die_table_in_use = 1;
8548
8549 /* Allocate the initial hunk of the line_info_table. */
8550 line_info_table
8551 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
8552 * sizeof (dw_line_info_entry));
8553 bzero (line_info_table, LINE_INFO_TABLE_INCREMENT
8554 * sizeof (dw_line_info_entry));
8555 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
8556 /* zero-th entry is allocated, but unused */
8557 line_info_table_in_use = 1;
8558
8559 /* Allocate the initial hunk of the fde_table. */
8560 fde_table = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
8561 bzero (fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
8562 fde_table_allocated = FDE_TABLE_INCREMENT;
8563 fde_table_in_use = 0;
8564
a3f97cbb
JW		 8565 /* Generate the initial DIE for the .debug section. Note that the (string)
8566 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
8567 will (typically) be a relative pathname and that this pathname should be
8568 taken as being relative to the directory from which the compiler was
8569 invoked when the given (base) source file was compiled. */
8570 gen_compile_unit_die (main_input_filename);
8571
5c90448c 8572 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
a94dbf2c
JM		 8573
8574 /* Generate the CFA instructions common to all FDE's. Do it now for the
8575 sake of lookup_cfa. */
a94dbf2c 8576
469ac993
JM		 8577#ifdef INCOMING_RETURN_ADDR_RTX
8578 /* On entry, the Canonical Frame Address is at SP+0. */
8579 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, 0);
8580 initial_return_save (INCOMING_RETURN_ADDR_RTX);
a94dbf2c 8581#endif
a3f97cbb
JW		 8582}
8583
8584/* Output stuff that dwarf requires at the end of every file,
8585 and generate the DWARF-2 debugging info. */
8586void
9a666dda 8587dwarf2out_finish ()
a3f97cbb 8588{
a3f97cbb
JW		 8589 /* Traverse the DIE tree and add sibling attributes to those DIE's
8590 that have children. */
8591 add_sibling_attributes (comp_unit_die);
8592
8593 /* Output a terminator label for the .text section. */
8594 fputc ('\n', asm_out_file);
8595 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
5c90448c 8596 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
a3f97cbb 8597
bdb669cb 8598#if 0
a3f97cbb
JW		 8599 /* Output a terminator label for the .data section. */
8600 fputc ('\n', asm_out_file);
8601 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
5c90448c 8602 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
a3f97cbb
JW		 8603
8604 /* Output a terminator label for the .bss section. */
8605 fputc ('\n', asm_out_file);
8606 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
5c90448c 8607 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
bdb669cb 8608#endif
a3f97cbb 8609
e90b62db
JM		 8610 /* Output the source line correspondence table. */
8611 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
8612 {
8613 fputc ('\n', asm_out_file);
8614 ASM_OUTPUT_SECTION (asm_out_file, LINE_SECTION);
8615 output_line_info ();
8616
8617 /* We can only use the low/high_pc attributes if all of the code
8618 was in .text. */
8619 if (separate_line_info_table_in_use == 0)
8620 {
8621 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_SECTION);
5c90448c 8622 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
e90b62db
JM		 8623 }
8624 add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, LINE_SECTION);
8625 }
8626
a3f97cbb
JW		 8627 /* Output the abbreviation table. */
8628 fputc ('\n', asm_out_file);
8629 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
8630 build_abbrev_table (comp_unit_die);
8631 output_abbrev_section ();
8632
a3f97cbb
JW		 8633 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8634 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8635 calc_die_sizes (comp_unit_die);
8636
a94dbf2c 8637 /* calculate sizes/offsets for FDEs. */
a3f97cbb
JW		 8638 calc_fde_sizes ();
8639
8640 /* Output debugging information. */
8641 fputc ('\n', asm_out_file);
8642 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_SECTION);
8643 output_compilation_unit_header ();
8644 output_die (comp_unit_die);
8645
d291dd49
JM		 8646 if (pubname_table_in_use)
8647 {
8648 /* Output public names table. */
8649 fputc ('\n', asm_out_file);
8650 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
8651 output_pubnames ();
8652 }
8653
a3f97cbb
JW		 8654 if (fde_table_in_use)
8655 {
8656 /* Output call frame information. */
a3f97cbb
JW		 8657 output_call_frame_info ();
8658
a3f97cbb
JW		 8659 /* Output the address range information. */
8660 fputc ('\n', asm_out_file);
8661 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
8662 output_aranges ();
8663 }
a94dbf2c
JM		 8664
8665 /* The only DIE we should have with a parent of NULL is comp_unit_die. */
8666 assert (limbo_die_count == 1);
a3f97cbb 8667}
9a666dda 8668#endif /* DWARF2_DEBUGGING_INFO */
Mirror of https://gcc.gnu.org/git/gcc.git