Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / gcc-4.4 / gcc / dbxout.c
CommitLineData
c251ad9e
SS
1/* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22
23/* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
31
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
36
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
43
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
48 end of its "name".
49
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
53 See `dbxout_symbol'.
54
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
59
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
65
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
68
69 For more on data type definitions, see `dbxout_type'. */
70
71#include "config.h"
72#include "system.h"
73#include "coretypes.h"
74#include "tm.h"
75
76#include "tree.h"
77#include "rtl.h"
78#include "flags.h"
79#include "regs.h"
80#include "insn-config.h"
81#include "reload.h"
82#include "output.h"
83#include "dbxout.h"
84#include "toplev.h"
85#include "tm_p.h"
86#include "ggc.h"
87#include "debug.h"
88#include "function.h"
89#include "target.h"
90#include "langhooks.h"
91#include "obstack.h"
92#include "expr.h"
93
94#ifdef XCOFF_DEBUGGING_INFO
95#include "xcoffout.h"
96#endif
97
98#define DBXOUT_DECR_NESTING \
99 if (--debug_nesting == 0 && symbol_queue_index > 0) \
100 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
101
102#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
103 do {--debug_nesting; return (x);} while (0)
104
105#ifndef ASM_STABS_OP
106# ifdef XCOFF_DEBUGGING_INFO
107# define ASM_STABS_OP "\t.stabx\t"
108# else
109# define ASM_STABS_OP "\t.stabs\t"
110# endif
111#endif
112
113#ifndef ASM_STABN_OP
114#define ASM_STABN_OP "\t.stabn\t"
115#endif
116
117#ifndef ASM_STABD_OP
118#define ASM_STABD_OP "\t.stabd\t"
119#endif
120
121#ifndef DBX_TYPE_DECL_STABS_CODE
122#define DBX_TYPE_DECL_STABS_CODE N_LSYM
123#endif
124
125#ifndef DBX_STATIC_CONST_VAR_CODE
126#define DBX_STATIC_CONST_VAR_CODE N_FUN
127#endif
128
129#ifndef DBX_REGPARM_STABS_CODE
130#define DBX_REGPARM_STABS_CODE N_RSYM
131#endif
132
133#ifndef DBX_REGPARM_STABS_LETTER
134#define DBX_REGPARM_STABS_LETTER 'P'
135#endif
136
137#ifndef NO_DBX_FUNCTION_END
138#define NO_DBX_FUNCTION_END 0
139#endif
140
141#ifndef NO_DBX_BNSYM_ENSYM
142#define NO_DBX_BNSYM_ENSYM 0
143#endif
144
145#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
146#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
147#endif
148
149#ifndef DBX_BLOCKS_FUNCTION_RELATIVE
150#define DBX_BLOCKS_FUNCTION_RELATIVE 0
151#endif
152
153#ifndef DBX_LINES_FUNCTION_RELATIVE
154#define DBX_LINES_FUNCTION_RELATIVE 0
155#endif
156
157#ifndef DBX_CONTIN_LENGTH
158#define DBX_CONTIN_LENGTH 80
159#endif
160
161#ifndef DBX_CONTIN_CHAR
162#define DBX_CONTIN_CHAR '\\'
163#endif
164
165enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
166
167/* Structure recording information about a C data type.
168 The status element says whether we have yet output
169 the definition of the type. TYPE_XREF says we have
170 output it as a cross-reference only.
171 The file_number and type_number elements are used if DBX_USE_BINCL
172 is defined. */
173
174struct typeinfo GTY(())
175{
176 enum typestatus status;
177 int file_number;
178 int type_number;
179};
180
181/* Vector recording information about C data types.
182 When we first notice a data type (a tree node),
183 we assign it a number using next_type_number.
184 That is its index in this vector. */
185
186static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
187
188/* Number of elements of space allocated in `typevec'. */
189
190static GTY(()) int typevec_len;
191
192/* In dbx output, each type gets a unique number.
193 This is the number for the next type output.
194 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
195
196static GTY(()) int next_type_number;
197
198/* The C front end may call dbxout_symbol before dbxout_init runs.
199 We save all such decls in this list and output them when we get
200 to dbxout_init. */
201
202static GTY(()) tree preinit_symbols;
203
204enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
205
206/* When using N_BINCL in dbx output, each type number is actually a
207 pair of the file number and the type number within the file.
208 This is a stack of input files. */
209
210struct dbx_file
211{
212 struct dbx_file *next;
213 int file_number;
214 int next_type_number;
215 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
216 const char *pending_bincl_name; /* Name of bincl. */
217 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
218};
219
220/* This is the top of the stack.
221
222 This is not saved for PCH, because restoring a PCH should not change it.
223 next_file_number does have to be saved, because the PCH may use some
224 file numbers; however, just before restoring a PCH, next_file_number
225 should always be 0 because we should not have needed any file numbers
226 yet. */
227
228#if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
229 && defined (DBX_USE_BINCL)
230static struct dbx_file *current_file;
231#endif
232
233/* This is the next file number to use. */
234
235static GTY(()) int next_file_number;
236
237/* A counter for dbxout_function_end. */
238
239static GTY(()) int scope_labelno;
240
241/* A counter for dbxout_source_line. */
242
243static GTY(()) int dbxout_source_line_counter;
244
245/* Number for the next N_SOL filename stabs label. The number 0 is reserved
246 for the N_SO filename stabs label. */
247
248static GTY(()) int source_label_number = 1;
249
250/* Last source file name mentioned in a NOTE insn. */
251
252static GTY(()) const char *lastfile;
253
254/* Used by PCH machinery to detect if 'lastfile' should be reset to
255 base_input_file. */
256static GTY(()) int lastfile_is_base;
257
258/* Typical USG systems don't have stab.h, and they also have
259 no use for DBX-format debugging info. */
260
261#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
262
263#ifdef DBX_USE_BINCL
264/* If zero then there is no pending BINCL. */
265static int pending_bincls = 0;
266#endif
267
268/* The original input file name. */
269static const char *base_input_file;
270
271#ifdef DEBUG_SYMS_TEXT
272#define FORCE_TEXT switch_to_section (current_function_section ())
273#else
274#define FORCE_TEXT
275#endif
276
277#include "gstab.h"
278
279#define STAB_CODE_TYPE enum __stab_debug_code
280
281/* 1 if PARM is passed to this function in memory. */
282
283#define PARM_PASSED_IN_MEMORY(PARM) \
284 (MEM_P (DECL_INCOMING_RTL (PARM)))
285
286/* A C expression for the integer offset value of an automatic variable
287 (N_LSYM) having address X (an RTX). */
288#ifndef DEBUGGER_AUTO_OFFSET
289#define DEBUGGER_AUTO_OFFSET(X) \
290 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
291#endif
292
293/* A C expression for the integer offset value of an argument (N_PSYM)
294 having address X (an RTX). The nominal offset is OFFSET. */
295#ifndef DEBUGGER_ARG_OFFSET
296#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
297#endif
298
299/* This obstack holds the stab string currently being constructed. We
300 build it up here, then write it out, so we can split long lines up
301 properly (see dbxout_finish_complex_stabs). */
302static struct obstack stabstr_ob;
303static size_t stabstr_last_contin_point;
304
305#ifdef DBX_USE_BINCL
306static void emit_bincl_stab (const char *c);
307static void emit_pending_bincls (void);
308#endif
309static inline void emit_pending_bincls_if_required (void);
310
311static void dbxout_init (const char *);
312
313static void dbxout_finish (const char *);
314static void dbxout_start_source_file (unsigned, const char *);
315static void dbxout_end_source_file (unsigned);
316static void dbxout_typedefs (tree);
317static void dbxout_type_index (tree);
318static void dbxout_args (tree);
319static void dbxout_type_fields (tree);
320static void dbxout_type_method_1 (tree);
321static void dbxout_type_methods (tree);
322static void dbxout_range_type (tree);
323static void dbxout_type (tree, int);
324static bool print_int_cst_bounds_in_octal_p (tree);
325static bool is_fortran (void);
326static void dbxout_type_name (tree);
327static void dbxout_class_name_qualifiers (tree);
328static int dbxout_symbol_location (tree, tree, const char *, rtx);
329static void dbxout_symbol_name (tree, const char *, int);
330static void dbxout_common_name (tree, const char *, STAB_CODE_TYPE);
331static const char *dbxout_common_check (tree, int *);
332static void dbxout_global_decl (tree);
333static void dbxout_type_decl (tree, int);
334static void dbxout_handle_pch (unsigned);
335\f
336/* The debug hooks structure. */
337#if defined (DBX_DEBUGGING_INFO)
338
339static void dbxout_source_line (unsigned int, const char *);
340static void dbxout_begin_prologue (unsigned int, const char *);
341static void dbxout_source_file (const char *);
342static void dbxout_function_end (tree);
343static void dbxout_begin_function (tree);
344static void dbxout_begin_block (unsigned, unsigned);
345static void dbxout_end_block (unsigned, unsigned);
346static void dbxout_function_decl (tree);
347
348const struct gcc_debug_hooks dbx_debug_hooks =
349{
350 dbxout_init,
351 dbxout_finish,
4b1e227d 352 debug_nothing_void,
c251ad9e
SS
353 debug_nothing_int_charstar,
354 debug_nothing_int_charstar,
355 dbxout_start_source_file,
356 dbxout_end_source_file,
357 dbxout_begin_block,
358 dbxout_end_block,
359 debug_true_const_tree, /* ignore_block */
360 dbxout_source_line, /* source_line */
361 dbxout_begin_prologue, /* begin_prologue */
362 debug_nothing_int_charstar, /* end_prologue */
363 debug_nothing_int_charstar, /* end_epilogue */
364#ifdef DBX_FUNCTION_FIRST
365 dbxout_begin_function,
366#else
367 debug_nothing_tree, /* begin_function */
368#endif
369 debug_nothing_int, /* end_function */
370 dbxout_function_decl,
371 dbxout_global_decl, /* global_decl */
372 dbxout_type_decl, /* type_decl */
373 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
374 debug_nothing_tree, /* deferred_inline_function */
375 debug_nothing_tree, /* outlining_inline_function */
376 debug_nothing_rtx, /* label */
377 dbxout_handle_pch, /* handle_pch */
378 debug_nothing_rtx, /* var_location */
379 debug_nothing_void, /* switch_text_section */
380 0 /* start_end_main_source_file */
381};
382#endif /* DBX_DEBUGGING_INFO */
383
384#if defined (XCOFF_DEBUGGING_INFO)
385const struct gcc_debug_hooks xcoff_debug_hooks =
386{
387 dbxout_init,
388 dbxout_finish,
4b1e227d 389 debug_nothing_void,
c251ad9e
SS
390 debug_nothing_int_charstar,
391 debug_nothing_int_charstar,
392 dbxout_start_source_file,
393 dbxout_end_source_file,
394 xcoffout_begin_block,
395 xcoffout_end_block,
396 debug_true_const_tree, /* ignore_block */
397 xcoffout_source_line,
398 xcoffout_begin_prologue, /* begin_prologue */
399 debug_nothing_int_charstar, /* end_prologue */
400 xcoffout_end_epilogue,
401 debug_nothing_tree, /* begin_function */
402 xcoffout_end_function,
403 debug_nothing_tree, /* function_decl */
404 dbxout_global_decl, /* global_decl */
405 dbxout_type_decl, /* type_decl */
406 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
407 debug_nothing_tree, /* deferred_inline_function */
408 debug_nothing_tree, /* outlining_inline_function */
409 debug_nothing_rtx, /* label */
410 dbxout_handle_pch, /* handle_pch */
411 debug_nothing_rtx, /* var_location */
412 debug_nothing_void, /* switch_text_section */
413 0 /* start_end_main_source_file */
414};
415#endif /* XCOFF_DEBUGGING_INFO */
416\f
417/* Numeric formatting helper macro. Note that this does not handle
418 hexadecimal. */
419#define NUMBER_FMT_LOOP(P, NUM, BASE) \
420 do \
421 { \
422 int digit = NUM % BASE; \
423 NUM /= BASE; \
424 *--P = digit + '0'; \
425 } \
426 while (NUM > 0)
427
428/* Utility: write a decimal integer NUM to asm_out_file. */
429void
430dbxout_int (int num)
431{
432 char buf[64];
433 char *p = buf + sizeof buf;
434 unsigned int unum;
435
436 if (num == 0)
437 {
438 putc ('0', asm_out_file);
439 return;
440 }
441 if (num < 0)
442 {
443 putc ('-', asm_out_file);
444 unum = -num;
445 }
446 else
447 unum = num;
448
449 NUMBER_FMT_LOOP (p, unum, 10);
450
451 while (p < buf + sizeof buf)
452 {
453 putc (*p, asm_out_file);
454 p++;
455 }
456}
457
458\f
459/* Primitives for emitting simple stabs directives. All other stabs
460 routines should use these functions instead of directly emitting
461 stabs. They are exported because machine-dependent code may need
462 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
463 forwards to code in CPU.c. */
464
465/* The following functions should all be called immediately after one
466 of the dbxout_begin_stab* functions (below). They write out
467 various things as the value of a stab. */
468
469/* Write out a literal zero as the value of a stab. */
470void
471dbxout_stab_value_zero (void)
472{
473 fputs ("0\n", asm_out_file);
474}
475
476/* Write out the label LABEL as the value of a stab. */
477void
478dbxout_stab_value_label (const char *label)
479{
480 assemble_name (asm_out_file, label);
481 putc ('\n', asm_out_file);
482}
483
484/* Write out the difference of two labels, LABEL - BASE, as the value
485 of a stab. */
486void
487dbxout_stab_value_label_diff (const char *label, const char *base)
488{
489 assemble_name (asm_out_file, label);
490 putc ('-', asm_out_file);
491 assemble_name (asm_out_file, base);
492 putc ('\n', asm_out_file);
493}
494
495/* Write out an internal label as the value of a stab, and immediately
496 emit that internal label. This should be used only when
497 dbxout_stabd will not work. STEM is the name stem of the label,
498 COUNTERP is a pointer to a counter variable which will be used to
499 guarantee label uniqueness. */
500void
501dbxout_stab_value_internal_label (const char *stem, int *counterp)
502{
503 char label[100];
504 int counter = counterp ? (*counterp)++ : 0;
505
506 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
507 dbxout_stab_value_label (label);
508 targetm.asm_out.internal_label (asm_out_file, stem, counter);
509}
510
511/* Write out the difference between BASE and an internal label as the
512 value of a stab, and immediately emit that internal label. STEM and
513 COUNTERP are as for dbxout_stab_value_internal_label. */
514void
515dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
516 const char *base)
517{
518 char label[100];
519 int counter = counterp ? (*counterp)++ : 0;
520
521 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
522 dbxout_stab_value_label_diff (label, base);
523 targetm.asm_out.internal_label (asm_out_file, stem, counter);
524}
525
526/* The following functions produce specific kinds of stab directives. */
527
528/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
529void
530dbxout_stabd (int stype, int sdesc)
531{
532 fputs (ASM_STABD_OP, asm_out_file);
533 dbxout_int (stype);
534 fputs (",0,", asm_out_file);
535 dbxout_int (sdesc);
536 putc ('\n', asm_out_file);
537}
538
539/* Write a .stabn directive with type STYPE. This function stops
540 short of emitting the value field, which is the responsibility of
541 the caller (normally it will be either a symbol or the difference
542 of two symbols). */
543
544void
545dbxout_begin_stabn (int stype)
546{
547 fputs (ASM_STABN_OP, asm_out_file);
548 dbxout_int (stype);
549 fputs (",0,0,", asm_out_file);
550}
551
552/* Write a .stabn directive with type N_SLINE and desc LINE. As above,
553 the value field is the responsibility of the caller. */
554void
555dbxout_begin_stabn_sline (int lineno)
556{
557 fputs (ASM_STABN_OP, asm_out_file);
558 dbxout_int (N_SLINE);
559 fputs (",0,", asm_out_file);
560 dbxout_int (lineno);
561 putc (',', asm_out_file);
562}
563
564/* Begin a .stabs directive with string "", type STYPE, and desc and
565 other fields 0. The value field is the responsibility of the
566 caller. This function cannot be used for .stabx directives. */
567void
568dbxout_begin_empty_stabs (int stype)
569{
570 fputs (ASM_STABS_OP, asm_out_file);
571 fputs ("\"\",", asm_out_file);
572 dbxout_int (stype);
573 fputs (",0,0,", asm_out_file);
574}
575
576/* Begin a .stabs directive with string STR, type STYPE, and desc 0.
577 The value field is the responsibility of the caller. */
578void
579dbxout_begin_simple_stabs (const char *str, int stype)
580{
581 fputs (ASM_STABS_OP, asm_out_file);
582 output_quoted_string (asm_out_file, str);
583 putc (',', asm_out_file);
584 dbxout_int (stype);
585 fputs (",0,0,", asm_out_file);
586}
587
588/* As above but use SDESC for the desc field. */
589void
590dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
591{
592 fputs (ASM_STABS_OP, asm_out_file);
593 output_quoted_string (asm_out_file, str);
594 putc (',', asm_out_file);
595 dbxout_int (stype);
596 fputs (",0,", asm_out_file);
597 dbxout_int (sdesc);
598 putc (',', asm_out_file);
599}
600
601/* The next set of functions are entirely concerned with production of
602 "complex" .stabs directives: that is, .stabs directives whose
603 strings have to be constructed piecemeal. dbxout_type,
604 dbxout_symbol, etc. use these routines heavily. The string is queued
605 up in an obstack, then written out by dbxout_finish_complex_stabs, which
606 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
607 (You might think it would be more efficient to go straight to stdio
608 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
609 out not to be the case, and anyway this needs fewer #ifdefs.) */
610
611/* Begin a complex .stabs directive. If we can, write the initial
612 ASM_STABS_OP to the asm_out_file. */
613
614static void
615dbxout_begin_complex_stabs (void)
616{
617 emit_pending_bincls_if_required ();
618 FORCE_TEXT;
619 fputs (ASM_STABS_OP, asm_out_file);
620 putc ('"', asm_out_file);
621 gcc_assert (stabstr_last_contin_point == 0);
622}
623
624/* As above, but do not force text or emit pending bincls. This is
625 used by dbxout_symbol_location, which needs to do something else. */
626static void
627dbxout_begin_complex_stabs_noforcetext (void)
628{
629 fputs (ASM_STABS_OP, asm_out_file);
630 putc ('"', asm_out_file);
631 gcc_assert (stabstr_last_contin_point == 0);
632}
633
634/* Add CHR, a single character, to the string being built. */
635#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
636
637/* Add STR, a normal C string, to the string being built. */
638#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
639
640/* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
641#define stabstr_I(id) obstack_grow (&stabstr_ob, \
642 IDENTIFIER_POINTER (id), \
643 IDENTIFIER_LENGTH (id))
644
645/* Add NUM, a signed decimal number, to the string being built. */
646static void
647stabstr_D (HOST_WIDE_INT num)
648{
649 char buf[64];
650 char *p = buf + sizeof buf;
651 unsigned int unum;
652
653 if (num == 0)
654 {
655 stabstr_C ('0');
656 return;
657 }
658 if (num < 0)
659 {
660 stabstr_C ('-');
661 unum = -num;
662 }
663 else
664 unum = num;
665
666 NUMBER_FMT_LOOP (p, unum, 10);
667
668 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
669}
670
671/* Add NUM, an unsigned decimal number, to the string being built. */
672static void
673stabstr_U (unsigned HOST_WIDE_INT num)
674{
675 char buf[64];
676 char *p = buf + sizeof buf;
677 if (num == 0)
678 {
679 stabstr_C ('0');
680 return;
681 }
682 NUMBER_FMT_LOOP (p, num, 10);
683 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
684}
685
686/* Add CST, an INTEGER_CST tree, to the string being built as an
687 unsigned octal number. This routine handles values which are
688 larger than a single HOST_WIDE_INT. */
689static void
690stabstr_O (tree cst)
691{
692 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
693 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
694
695 char buf[128];
696 char *p = buf + sizeof buf;
697
698 /* GDB wants constants with no extra leading "1" bits, so
699 we need to remove any sign-extension that might be
700 present. */
701 {
702 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
703 if (width == HOST_BITS_PER_WIDE_INT * 2)
704 ;
705 else if (width > HOST_BITS_PER_WIDE_INT)
706 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
707 else if (width == HOST_BITS_PER_WIDE_INT)
708 high = 0;
709 else
710 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
711 }
712
713 /* Leading zero for base indicator. */
714 stabstr_C ('0');
715
716 /* If the value is zero, the base indicator will serve as the value
717 all by itself. */
718 if (high == 0 && low == 0)
719 return;
720
721 /* If the high half is zero, we need only print the low half normally. */
722 if (high == 0)
723 NUMBER_FMT_LOOP (p, low, 8);
724 else
725 {
726 /* When high != 0, we need to print enough zeroes from low to
727 give the digits from high their proper place-values. Hence
728 NUMBER_FMT_LOOP cannot be used. */
729 const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
730 int i;
731
732 for (i = 1; i <= n_digits; i++)
733 {
734 unsigned int digit = low % 8;
735 low /= 8;
736 *--p = '0' + digit;
737 }
738
739 /* Octal digits carry exactly three bits of information. The
740 width of a HOST_WIDE_INT is not normally a multiple of three.
741 Therefore, the next digit printed probably needs to carry
742 information from both low and high. */
743 if (HOST_BITS_PER_WIDE_INT % 3 != 0)
744 {
745 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
746 const int n_bits_from_high = 3 - n_leftover_bits;
747
748 const unsigned HOST_WIDE_INT
749 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
750 const unsigned HOST_WIDE_INT
751 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
752
753 unsigned int digit;
754
755 /* At this point, only the bottom n_leftover_bits bits of low
756 should be set. */
757 gcc_assert (!(low & ~low_mask));
758
759 digit = (low | ((high & high_mask) << n_leftover_bits));
760 high >>= n_bits_from_high;
761
762 *--p = '0' + digit;
763 }
764
765 /* Now we can format high in the normal manner. However, if
766 the only bits of high that were set were handled by the
767 digit split between low and high, high will now be zero, and
768 we don't want to print extra digits in that case. */
769 if (high)
770 NUMBER_FMT_LOOP (p, high, 8);
771 }
772
773 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
774}
775
776/* Called whenever it is safe to break a stabs string into multiple
777 .stabs directives. If the current string has exceeded the limit
778 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
779 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
780 it is a backslash) and a null character. */
781static inline void
782stabstr_continue (void)
783{
784 if (DBX_CONTIN_LENGTH > 0
785 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
786 > DBX_CONTIN_LENGTH)
787 {
788 if (DBX_CONTIN_CHAR == '\\')
789 obstack_1grow (&stabstr_ob, '\\');
790 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
791 obstack_1grow (&stabstr_ob, '\0');
792 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
793 }
794}
795#define CONTIN stabstr_continue ()
796
797/* Macro subroutine of dbxout_finish_complex_stabs, which emits
798 all of the arguments to the .stabs directive after the string.
799 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
800 LINE is the source line to write into the desc field (in extended
801 mode); SYM is the symbol itself.
802
803 ADDR, LABEL, and NUMBER are three different ways to represent the
804 stabs value field. At most one of these should be nonzero.
805
806 ADDR is used most of the time; it represents the value as an
807 RTL address constant.
808
809 LABEL is used (currently) only for N_CATCH stabs; it represents
810 the value as a string suitable for assemble_name.
811
812 NUMBER is used when the value is an offset from an implicit base
813 pointer (e.g. for a stack variable), or an index (e.g. for a
814 register variable). It represents the value as a decimal integer. */
815
816#ifndef DBX_FINISH_STABS
817#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
818do { \
819 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
820 \
821 dbxout_int (CODE); \
822 fputs (",0,", asm_out_file); \
823 dbxout_int (line_); \
824 putc (',', asm_out_file); \
825 if (ADDR) \
826 output_addr_const (asm_out_file, ADDR); \
827 else if (LABEL) \
828 assemble_name (asm_out_file, LABEL); \
829 else \
830 dbxout_int (NUMBER); \
831 putc ('\n', asm_out_file); \
832} while (0)
833#endif
834
835/* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
836 is zero, this has only to emit the close quote and the remainder of
837 the arguments. When it is nonzero, the string has been marshalled in
838 stabstr_ob, and this routine is responsible for breaking it up into
839 DBX_CONTIN_LENGTH-sized chunks.
840
841 SYM is the DECL of the symbol under consideration; it is used only
842 for its DECL_SOURCE_LINE. The other arguments are all passed directly
843 to DBX_FINISH_STABS; see above for details. */
844
845static void
846dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
847 rtx addr, const char *label, int number)
848{
849 int line ATTRIBUTE_UNUSED;
850 char *str;
851 size_t len;
852
853 line = sym ? DECL_SOURCE_LINE (sym) : 0;
854 if (DBX_CONTIN_LENGTH > 0)
855 {
856 char *chunk;
857 size_t chunklen;
858
859 /* Nul-terminate the growing string, then get its size and
860 address. */
861 obstack_1grow (&stabstr_ob, '\0');
862
863 len = obstack_object_size (&stabstr_ob);
864 chunk = str = XOBFINISH (&stabstr_ob, char *);
865
866 /* Within the buffer are a sequence of NUL-separated strings,
867 each of which is to be written out as a separate stab
868 directive. */
869 for (;;)
870 {
871 chunklen = strlen (chunk);
872 fwrite (chunk, 1, chunklen, asm_out_file);
873 fputs ("\",", asm_out_file);
874
875 /* Must add an extra byte to account for the NUL separator. */
876 chunk += chunklen + 1;
877 len -= chunklen + 1;
878
879 /* Only put a line number on the last stab in the sequence. */
880 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
881 addr, label, number);
882 if (len == 0)
883 break;
884
885 fputs (ASM_STABS_OP, asm_out_file);
886 putc ('"', asm_out_file);
887 }
888 stabstr_last_contin_point = 0;
889 }
890 else
891 {
892 /* No continuations - we can put the whole string out at once.
893 It is faster to augment the string with the close quote and
894 comma than to do a two-character fputs. */
895 obstack_grow (&stabstr_ob, "\",", 2);
896 len = obstack_object_size (&stabstr_ob);
897 str = XOBFINISH (&stabstr_ob, char *);
898
899 fwrite (str, 1, len, asm_out_file);
900 DBX_FINISH_STABS (sym, code, line, addr, label, number);
901 }
902 obstack_free (&stabstr_ob, str);
903}
904
905#if defined (DBX_DEBUGGING_INFO)
906
907static void
908dbxout_function_end (tree decl)
909{
910 char lscope_label_name[100];
911
912 /* The Lscope label must be emitted even if we aren't doing anything
913 else; dbxout_block needs it. */
914 switch_to_section (function_section (current_function_decl));
915
916 /* Convert Lscope into the appropriate format for local labels in case
917 the system doesn't insert underscores in front of user generated
918 labels. */
919 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
920 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
921
922 /* The N_FUN tag at the end of the function is a GNU extension,
923 which may be undesirable, and is unnecessary if we do not have
924 named sections. */
925 if (!use_gnu_debug_info_extensions
926 || NO_DBX_FUNCTION_END
927 || !targetm.have_named_sections
928 || DECL_IGNORED_P (decl))
929 return;
930
931 /* By convention, GCC will mark the end of a function with an N_FUN
932 symbol and an empty string. */
933 if (flag_reorder_blocks_and_partition)
934 {
935 dbxout_begin_empty_stabs (N_FUN);
936 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
937 crtl->subsections.hot_section_label);
938 dbxout_begin_empty_stabs (N_FUN);
939 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
940 crtl->subsections.cold_section_label);
941 }
942 else
943 {
944 char begin_label[20];
945 /* Reference current function start using LFBB. */
946 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
947 dbxout_begin_empty_stabs (N_FUN);
948 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
949 }
950
951 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
952 dbxout_stabd (N_ENSYM, 0);
953}
954#endif /* DBX_DEBUGGING_INFO */
955
956/* Get lang description for N_SO stab. */
957static unsigned int ATTRIBUTE_UNUSED
958get_lang_number (void)
959{
960 const char *language_string = lang_hooks.name;
961
962 if (strcmp (language_string, "GNU C") == 0)
963 return N_SO_C;
964 else if (strcmp (language_string, "GNU C++") == 0)
965 return N_SO_CC;
966 else if (strcmp (language_string, "GNU F77") == 0)
967 return N_SO_FORTRAN;
968 else if (strcmp (language_string, "GNU Fortran") == 0)
969 return N_SO_FORTRAN90; /* CHECKME */
970 else if (strcmp (language_string, "GNU Pascal") == 0)
971 return N_SO_PASCAL;
972 else if (strcmp (language_string, "GNU Objective-C") == 0)
973 return N_SO_OBJC;
974 else if (strcmp (language_string, "GNU Objective-C++") == 0)
975 return N_SO_OBJCPLUS;
976 else
977 return 0;
978
979}
980
981static bool
982is_fortran (void)
983{
984 unsigned int lang = get_lang_number ();
985
986 return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
987}
988
989/* At the beginning of compilation, start writing the symbol table.
990 Initialize `typevec' and output the standard data types of C. */
991
992static void
993dbxout_init (const char *input_file_name)
994{
995 char ltext_label_name[100];
996 bool used_ltext_label_name = false;
997 tree syms = lang_hooks.decls.getdecls ();
998 const char *mapped_name;
999
1000 typevec_len = 100;
1001 typevec = GGC_CNEWVEC (struct typeinfo, typevec_len);
1002
1003 /* stabstr_ob contains one string, which will be just fine with
1004 1-byte alignment. */
1005 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
1006
1007 /* Convert Ltext into the appropriate format for local labels in case
1008 the system doesn't insert underscores in front of user generated
1009 labels. */
1010 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1011
1012 /* Put the current working directory in an N_SO symbol. */
1013 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1014 {
1015 static const char *cwd;
1016
1017 if (!cwd)
1018 {
1019 cwd = get_src_pwd ();
1020 if (cwd[0] == '\0')
1021 cwd = "/";
1022 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1023 cwd = concat (cwd, "/", NULL);
1024 cwd = remap_debug_filename (cwd);
1025 }
1026#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1027 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1028#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1029 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1030 dbxout_stab_value_label (ltext_label_name);
1031 used_ltext_label_name = true;
1032#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1033 }
1034
1035 mapped_name = remap_debug_filename (input_file_name);
1036#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1037 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1038#else
1039 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1040 dbxout_stab_value_label (ltext_label_name);
1041 used_ltext_label_name = true;
1042#endif
1043
1044 if (used_ltext_label_name)
1045 {
1046 switch_to_section (text_section);
1047 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1048 }
1049
1050 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1051 The string used is historical. */
1052#ifndef NO_DBX_GCC_MARKER
1053 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1054 dbxout_stab_value_zero ();
1055#endif
1056
1057 base_input_file = lastfile = input_file_name;
1058
1059 next_type_number = 1;
1060
1061#ifdef DBX_USE_BINCL
1062 current_file = XNEW (struct dbx_file);
1063 current_file->next = NULL;
1064 current_file->file_number = 0;
1065 current_file->next_type_number = 1;
1066 next_file_number = 1;
1067 current_file->prev = NULL;
1068 current_file->bincl_status = BINCL_NOT_REQUIRED;
1069 current_file->pending_bincl_name = NULL;
1070#endif
1071
1072 /* Get all permanent types that have typedef names, and output them
1073 all, except for those already output. Some language front ends
1074 put these declarations in the top-level scope; some do not;
1075 the latter are responsible for calling debug_hooks->type_decl from
1076 their record_builtin_type function. */
1077 dbxout_typedefs (syms);
1078
1079 if (preinit_symbols)
1080 {
1081 tree t;
1082 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1083 dbxout_symbol (TREE_VALUE (t), 0);
1084 preinit_symbols = 0;
1085 }
1086}
1087
1088/* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1089
1090static void
1091dbxout_typedefs (tree syms)
1092{
1093 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1094 {
1095 if (TREE_CODE (syms) == TYPE_DECL)
1096 {
1097 tree type = TREE_TYPE (syms);
1098 if (TYPE_NAME (type)
1099 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1100 && COMPLETE_OR_VOID_TYPE_P (type)
1101 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1102 dbxout_symbol (TYPE_NAME (type), 0);
1103 }
1104 }
1105}
1106
1107#ifdef DBX_USE_BINCL
1108/* Emit BINCL stab using given name. */
1109static void
1110emit_bincl_stab (const char *name)
1111{
1112 dbxout_begin_simple_stabs (name, N_BINCL);
1113 dbxout_stab_value_zero ();
1114}
1115
1116/* If there are pending bincls then it is time to emit all of them. */
1117
1118static inline void
1119emit_pending_bincls_if_required (void)
1120{
1121 if (pending_bincls)
1122 emit_pending_bincls ();
1123}
1124
1125/* Emit all pending bincls. */
1126
1127static void
1128emit_pending_bincls (void)
1129{
1130 struct dbx_file *f = current_file;
1131
1132 /* Find first pending bincl. */
1133 while (f->bincl_status == BINCL_PENDING)
1134 f = f->next;
1135
1136 /* Now emit all bincls. */
1137 f = f->prev;
1138
1139 while (f)
1140 {
1141 if (f->bincl_status == BINCL_PENDING)
1142 {
1143 emit_bincl_stab (f->pending_bincl_name);
1144
1145 /* Update file number and status. */
1146 f->file_number = next_file_number++;
1147 f->bincl_status = BINCL_PROCESSED;
1148 }
1149 if (f == current_file)
1150 break;
1151 f = f->prev;
1152 }
1153
1154 /* All pending bincls have been emitted. */
1155 pending_bincls = 0;
1156}
1157
1158#else
1159
1160static inline void
1161emit_pending_bincls_if_required (void) {}
1162#endif
1163
1164/* Change to reading from a new source file. Generate a N_BINCL stab. */
1165
1166static void
1167dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1168 const char *filename ATTRIBUTE_UNUSED)
1169{
1170#ifdef DBX_USE_BINCL
1171 struct dbx_file *n = XNEW (struct dbx_file);
1172
1173 n->next = current_file;
1174 n->next_type_number = 1;
1175 /* Do not assign file number now.
1176 Delay it until we actually emit BINCL. */
1177 n->file_number = 0;
1178 n->prev = NULL;
1179 current_file->prev = n;
1180 n->bincl_status = BINCL_PENDING;
1181 n->pending_bincl_name = remap_debug_filename (filename);
1182 pending_bincls = 1;
1183 current_file = n;
1184#endif
1185}
1186
1187/* Revert to reading a previous source file. Generate a N_EINCL stab. */
1188
1189static void
1190dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1191{
1192#ifdef DBX_USE_BINCL
1193 /* Emit EINCL stab only if BINCL is not pending. */
1194 if (current_file->bincl_status == BINCL_PROCESSED)
1195 {
1196 dbxout_begin_stabn (N_EINCL);
1197 dbxout_stab_value_zero ();
1198 }
1199 current_file->bincl_status = BINCL_NOT_REQUIRED;
1200 current_file = current_file->next;
1201#endif
1202}
1203
1204/* Handle a few odd cases that occur when trying to make PCH files work. */
1205
1206static void
1207dbxout_handle_pch (unsigned at_end)
1208{
1209 if (! at_end)
1210 {
1211 /* When using the PCH, this file will be included, so we need to output
1212 a BINCL. */
1213 dbxout_start_source_file (0, lastfile);
1214
1215 /* The base file when using the PCH won't be the same as
1216 the base file when it's being generated. */
1217 lastfile = NULL;
1218 }
1219 else
1220 {
1221 /* ... and an EINCL. */
1222 dbxout_end_source_file (0);
1223
1224 /* Deal with cases where 'lastfile' was never actually changed. */
1225 lastfile_is_base = lastfile == NULL;
1226 }
1227}
1228
1229#if defined (DBX_DEBUGGING_INFO)
1230
1231static void dbxout_block (tree, int, tree);
1232
1233/* Output debugging info to FILE to switch to sourcefile FILENAME. */
1234
1235static void
1236dbxout_source_file (const char *filename)
1237{
1238 if (lastfile == 0 && lastfile_is_base)
1239 {
1240 lastfile = base_input_file;
1241 lastfile_is_base = 0;
1242 }
1243
1244 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1245 {
1246 /* Don't change section amid function. */
1247 if (current_function_decl == NULL_TREE)
1248 switch_to_section (text_section);
1249
1250 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1251 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1252 lastfile = filename;
1253 }
1254}
1255
1256/* Output N_BNSYM, line number symbol entry, and local symbol at
1257 function scope */
1258
1259static void
1260dbxout_begin_prologue (unsigned int lineno, const char *filename)
1261{
1262 if (use_gnu_debug_info_extensions
1263 && !NO_DBX_FUNCTION_END
1264 && !NO_DBX_BNSYM_ENSYM
1265 && !flag_debug_only_used_symbols)
1266 dbxout_stabd (N_BNSYM, 0);
1267
1268 /* pre-increment the scope counter */
1269 scope_labelno++;
1270
1271 dbxout_source_line (lineno, filename);
1272 /* Output function begin block at function scope, referenced
1273 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1274 emit_pending_bincls_if_required ();
1275 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1276}
1277
1278/* Output a line number symbol entry for source file FILENAME and line
1279 number LINENO. */
1280
1281static void
1282dbxout_source_line (unsigned int lineno, const char *filename)
1283{
1284 dbxout_source_file (filename);
1285
1286#ifdef DBX_OUTPUT_SOURCE_LINE
1287 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1288#else
1289 if (DBX_LINES_FUNCTION_RELATIVE)
1290 {
1291 char begin_label[20];
1292 dbxout_begin_stabn_sline (lineno);
1293 /* Reference current function start using LFBB. */
1294 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1295 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1296 begin_label);
1297 }
1298 else
1299 dbxout_stabd (N_SLINE, lineno);
1300#endif
1301}
1302
1303/* Describe the beginning of an internal block within a function. */
1304
1305static void
1306dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1307{
1308 emit_pending_bincls_if_required ();
1309 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1310}
1311
1312/* Describe the end line-number of an internal block within a function. */
1313
1314static void
1315dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1316{
1317 emit_pending_bincls_if_required ();
1318 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1319}
1320
1321/* Output dbx data for a function definition.
1322 This includes a definition of the function name itself (a symbol),
1323 definitions of the parameters (locating them in the parameter list)
1324 and then output the block that makes up the function's body
1325 (including all the auto variables of the function). */
1326
1327static void
1328dbxout_function_decl (tree decl)
1329{
1330 emit_pending_bincls_if_required ();
1331#ifndef DBX_FUNCTION_FIRST
1332 dbxout_begin_function (decl);
1333#endif
1334 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1335 dbxout_function_end (decl);
1336}
1337
1338#endif /* DBX_DEBUGGING_INFO */
1339
1340/* Debug information for a global DECL. Called from toplev.c after
1341 compilation proper has finished. */
1342static void
1343dbxout_global_decl (tree decl)
1344{
1345 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1346 {
1347 int saved_tree_used = TREE_USED (decl);
1348 TREE_USED (decl) = 1;
1349 dbxout_symbol (decl, 0);
1350 TREE_USED (decl) = saved_tree_used;
1351 }
1352}
1353
1354/* This is just a function-type adapter; dbxout_symbol does exactly
1355 what we want but returns an int. */
1356static void
1357dbxout_type_decl (tree decl, int local)
1358{
1359 dbxout_symbol (decl, local);
1360}
1361
1362/* At the end of compilation, finish writing the symbol table.
1363 The default is to call debug_free_queue but do nothing else. */
1364
1365static void
1366dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1367{
1368#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1369 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1370#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1371 {
1372 switch_to_section (text_section);
1373 dbxout_begin_empty_stabs (N_SO);
1374 dbxout_stab_value_internal_label ("Letext", 0);
1375 }
1376#endif
1377 debug_free_queue ();
1378}
1379
1380/* Output the index of a type. */
1381
1382static void
1383dbxout_type_index (tree type)
1384{
1385#ifndef DBX_USE_BINCL
1386 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1387#else
1388 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1389 stabstr_C ('(');
1390 stabstr_D (t->file_number);
1391 stabstr_C (',');
1392 stabstr_D (t->type_number);
1393 stabstr_C (')');
1394#endif
1395}
1396
1397\f
1398
1399/* Used in several places: evaluates to '0' for a private decl,
1400 '1' for a protected decl, '2' for a public decl. */
1401#define DECL_ACCESSIBILITY_CHAR(DECL) \
1402(TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1403
1404/* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1405 This must be a separate function because anonymous unions require
1406 recursive calls. */
1407
1408static void
1409dbxout_type_fields (tree type)
1410{
1411 tree tem;
1412
1413 /* Output the name, type, position (in bits), size (in bits) of each
1414 field that we can support. */
1415 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1416 {
1417 /* If one of the nodes is an error_mark or its type is then
1418 return early. */
1419 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1420 return;
1421
1422 /* Omit here local type decls until we know how to support them. */
1423 if (TREE_CODE (tem) == TYPE_DECL
1424 /* Omit here the nameless fields that are used to skip bits. */
1425 || DECL_IGNORED_P (tem)
1426 /* Omit fields whose position or size are variable or too large to
1427 represent. */
1428 || (TREE_CODE (tem) == FIELD_DECL
1429 && (! host_integerp (bit_position (tem), 0)
1430 || ! DECL_SIZE (tem)
1431 || ! host_integerp (DECL_SIZE (tem), 1))))
1432 continue;
1433
1434 else if (TREE_CODE (tem) != CONST_DECL)
1435 {
1436 /* Continue the line if necessary,
1437 but not before the first field. */
1438 if (tem != TYPE_FIELDS (type))
1439 CONTIN;
1440
1441 if (DECL_NAME (tem))
1442 stabstr_I (DECL_NAME (tem));
1443 stabstr_C (':');
1444
1445 if (use_gnu_debug_info_extensions
1446 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1447 || TREE_CODE (tem) != FIELD_DECL))
1448 {
1449 stabstr_C ('/');
1450 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1451 }
1452
1453 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1454 && DECL_BIT_FIELD_TYPE (tem))
1455 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1456
1457 if (TREE_CODE (tem) == VAR_DECL)
1458 {
1459 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1460 {
1461 tree name = DECL_ASSEMBLER_NAME (tem);
1462
1463 stabstr_C (':');
1464 stabstr_I (name);
1465 stabstr_C (';');
1466 }
1467 else
1468 /* If TEM is non-static, GDB won't understand it. */
1469 stabstr_S (",0,0;");
1470 }
1471 else
1472 {
1473 stabstr_C (',');
1474 stabstr_D (int_bit_position (tem));
1475 stabstr_C (',');
1476 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1477 stabstr_C (';');
1478 }
1479 }
1480 }
1481}
1482\f
1483/* Subroutine of `dbxout_type_methods'. Output debug info about the
1484 method described DECL. */
1485
1486static void
1487dbxout_type_method_1 (tree decl)
1488{
1489 char c1 = 'A', c2;
1490
1491 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1492 c2 = '?';
1493 else /* it's a METHOD_TYPE. */
1494 {
1495 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1496 /* A for normal functions.
1497 B for `const' member functions.
1498 C for `volatile' member functions.
1499 D for `const volatile' member functions. */
1500 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1501 c1 += 1;
1502 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1503 c1 += 2;
1504
1505 if (DECL_VINDEX (decl))
1506 c2 = '*';
1507 else
1508 c2 = '.';
1509 }
1510
1511 /* ??? Output the mangled name, which contains an encoding of the
1512 method's type signature. May not be necessary anymore. */
1513 stabstr_C (':');
1514 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1515 stabstr_C (';');
1516 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1517 stabstr_C (c1);
1518 stabstr_C (c2);
1519
1520 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1521 {
1522 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1523 stabstr_C (';');
1524 dbxout_type (DECL_CONTEXT (decl), 0);
1525 stabstr_C (';');
1526 }
1527}
1528\f
1529/* Subroutine of `dbxout_type'. Output debug info about the methods defined
1530 in TYPE. */
1531
1532static void
1533dbxout_type_methods (tree type)
1534{
1535 /* C++: put out the method names and their parameter lists */
1536 tree methods = TYPE_METHODS (type);
1537 tree fndecl;
1538 tree last;
1539
1540 if (methods == NULL_TREE)
1541 return;
1542
1543 if (TREE_CODE (methods) != TREE_VEC)
1544 fndecl = methods;
1545 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1546 fndecl = TREE_VEC_ELT (methods, 0);
1547 else
1548 fndecl = TREE_VEC_ELT (methods, 1);
1549
1550 while (fndecl)
1551 {
1552 int need_prefix = 1;
1553
1554 /* Group together all the methods for the same operation.
1555 These differ in the types of the arguments. */
1556 for (last = NULL_TREE;
1557 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1558 fndecl = TREE_CHAIN (fndecl))
1559 /* Output the name of the field (after overloading), as
1560 well as the name of the field before overloading, along
1561 with its parameter list */
1562 {
1563 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1564 include TEMPLATE_DECLs.) The debugger doesn't know what
1565 to do with such entities anyhow. */
1566 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1567 continue;
1568
1569 CONTIN;
1570
1571 last = fndecl;
1572
1573 /* Also ignore abstract methods; those are only interesting to
1574 the DWARF backends. */
1575 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1576 continue;
1577
1578 /* Redundantly output the plain name, since that's what gdb
1579 expects. */
1580 if (need_prefix)
1581 {
1582 stabstr_I (DECL_NAME (fndecl));
1583 stabstr_S ("::");
1584 need_prefix = 0;
1585 }
1586
1587 dbxout_type (TREE_TYPE (fndecl), 0);
1588 dbxout_type_method_1 (fndecl);
1589 }
1590 if (!need_prefix)
1591 stabstr_C (';');
1592 }
1593}
1594
1595/* Emit a "range" type specification, which has the form:
1596 "r<index type>;<lower bound>;<upper bound>;".
1597 TYPE is an INTEGER_TYPE. */
1598
1599static void
1600dbxout_range_type (tree type)
1601{
1602 stabstr_C ('r');
1603 if (TREE_TYPE (type))
1604 dbxout_type (TREE_TYPE (type), 0);
1605 else if (TREE_CODE (type) != INTEGER_TYPE)
1606 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1607 else
1608 {
1609 /* Traditionally, we made sure 'int' was type 1, and builtin types
1610 were defined to be sub-ranges of int. Unfortunately, this
1611 does not allow us to distinguish true sub-ranges from integer
1612 types. So, instead we define integer (non-sub-range) types as
1613 sub-ranges of themselves. This matters for Chill. If this isn't
1614 a subrange type, then we want to define it in terms of itself.
1615 However, in C, this may be an anonymous integer type, and we don't
1616 want to emit debug info referring to it. Just calling
1617 dbxout_type_index won't work anyways, because the type hasn't been
1618 defined yet. We make this work for both cases by checked to see
1619 whether this is a defined type, referring to it if it is, and using
1620 'int' otherwise. */
1621 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1622 dbxout_type_index (type);
1623 else
1624 dbxout_type_index (integer_type_node);
1625 }
1626
1627 stabstr_C (';');
1628 if (TYPE_MIN_VALUE (type) != 0
1629 && host_integerp (TYPE_MIN_VALUE (type), 0))
1630 {
1631 if (print_int_cst_bounds_in_octal_p (type))
1632 stabstr_O (TYPE_MIN_VALUE (type));
1633 else
1634 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1635 }
1636 else
1637 stabstr_C ('0');
1638
1639 stabstr_C (';');
1640 if (TYPE_MAX_VALUE (type) != 0
1641 && host_integerp (TYPE_MAX_VALUE (type), 0))
1642 {
1643 if (print_int_cst_bounds_in_octal_p (type))
1644 stabstr_O (TYPE_MAX_VALUE (type));
1645 else
1646 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1647 stabstr_C (';');
1648 }
1649 else
1650 stabstr_S ("-1;");
1651}
1652\f
1653
1654/* Output a reference to a type. If the type has not yet been
1655 described in the dbx output, output its definition now.
1656 For a type already defined, just refer to its definition
1657 using the type number.
1658
1659 If FULL is nonzero, and the type has been described only with
1660 a forward-reference, output the definition now.
1661 If FULL is zero in this case, just refer to the forward-reference
1662 using the number previously allocated. */
1663
1664static void
1665dbxout_type (tree type, int full)
1666{
1667 tree tem;
1668 tree main_variant;
1669 static int anonymous_type_number = 0;
1670 bool vector_type = false;
1671
1672 if (TREE_CODE (type) == VECTOR_TYPE)
1673 {
1674 /* The frontend feeds us a representation for the vector as a struct
1675 containing an array. Pull out the array type. */
1676 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1677 vector_type = true;
1678 }
1679
1680 /* If there was an input error and we don't really have a type,
1681 avoid crashing and write something that is at least valid
1682 by assuming `int'. */
1683 if (type == error_mark_node)
1684 type = integer_type_node;
1685 else
1686 {
1687 if (TYPE_NAME (type)
1688 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1689 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1690 full = 0;
1691 }
1692
1693 /* Try to find the "main variant" with the same name. */
1694 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1695 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1696 main_variant = TREE_TYPE (TYPE_NAME (type));
1697 else
1698 main_variant = TYPE_MAIN_VARIANT (type);
1699
1700 /* If we are not using extensions, stabs does not distinguish const and
1701 volatile, so there is no need to make them separate types. */
1702 if (!use_gnu_debug_info_extensions)
1703 type = main_variant;
1704
1705 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1706 {
1707 /* Type has no dbx number assigned. Assign next available number. */
1708 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1709
1710 /* Make sure type vector is long enough to record about this type. */
1711
1712 if (next_type_number == typevec_len)
1713 {
1714 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1715 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1716 typevec_len *= 2;
1717 }
1718
1719#ifdef DBX_USE_BINCL
1720 emit_pending_bincls_if_required ();
1721 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1722 = current_file->file_number;
1723 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1724 = current_file->next_type_number++;
1725#endif
1726 }
1727
1728 if (flag_debug_only_used_symbols)
1729 {
1730 if ((TREE_CODE (type) == RECORD_TYPE
1731 || TREE_CODE (type) == UNION_TYPE
1732 || TREE_CODE (type) == QUAL_UNION_TYPE
1733 || TREE_CODE (type) == ENUMERAL_TYPE)
1734 && TYPE_STUB_DECL (type)
1735 && DECL_P (TYPE_STUB_DECL (type))
1736 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1737 debug_queue_symbol (TYPE_STUB_DECL (type));
1738 else if (TYPE_NAME (type)
1739 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1740 debug_queue_symbol (TYPE_NAME (type));
1741 }
1742
1743 /* Output the number of this type, to refer to it. */
1744 dbxout_type_index (type);
1745
1746#ifdef DBX_TYPE_DEFINED
1747 if (DBX_TYPE_DEFINED (type))
1748 return;
1749#endif
1750
1751 /* If this type's definition has been output or is now being output,
1752 that is all. */
1753
1754 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1755 {
1756 case TYPE_UNSEEN:
1757 break;
1758 case TYPE_XREF:
1759 /* If we have already had a cross reference,
1760 and either that's all we want or that's the best we could do,
1761 don't repeat the cross reference.
1762 Sun dbx crashes if we do. */
1763 if (! full || !COMPLETE_TYPE_P (type)
1764 /* No way in DBX fmt to describe a variable size. */
1765 || ! host_integerp (TYPE_SIZE (type), 1))
1766 return;
1767 break;
1768 case TYPE_DEFINED:
1769 return;
1770 }
1771
1772#ifdef DBX_NO_XREFS
1773 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1774 leave the type-number completely undefined rather than output
1775 a cross-reference. If we have already used GNU debug info extensions,
1776 then it is OK to output a cross reference. This is necessary to get
1777 proper C++ debug output. */
1778 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1779 || TREE_CODE (type) == QUAL_UNION_TYPE
1780 || TREE_CODE (type) == ENUMERAL_TYPE)
1781 && ! use_gnu_debug_info_extensions)
1782 /* We must use the same test here as we use twice below when deciding
1783 whether to emit a cross-reference. */
1784 if ((TYPE_NAME (type) != 0
1785 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1786 && DECL_IGNORED_P (TYPE_NAME (type)))
1787 && !full)
1788 || !COMPLETE_TYPE_P (type)
1789 /* No way in DBX fmt to describe a variable size. */
1790 || ! host_integerp (TYPE_SIZE (type), 1))
1791 {
1792 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1793 return;
1794 }
1795#endif
1796
1797 /* Output a definition now. */
1798 stabstr_C ('=');
1799
1800 /* Mark it as defined, so that if it is self-referent
1801 we will not get into an infinite recursion of definitions. */
1802
1803 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1804
1805 /* If this type is a variant of some other, hand off. Types with
1806 different names are usefully distinguished. We only distinguish
1807 cv-qualified types if we're using extensions. */
1808 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1809 {
1810 stabstr_C ('k');
1811 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1812 return;
1813 }
1814 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1815 {
1816 stabstr_C ('B');
1817 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1818 return;
1819 }
1820 else if (main_variant != TYPE_MAIN_VARIANT (type))
1821 {
1822 if (flag_debug_only_used_symbols)
1823 {
1824 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1825
1826 if ((TREE_CODE (orig_type) == RECORD_TYPE
1827 || TREE_CODE (orig_type) == UNION_TYPE
1828 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1829 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1830 && TYPE_STUB_DECL (orig_type)
1831 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1832 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1833 }
1834 /* 'type' is a typedef; output the type it refers to. */
1835 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1836 return;
1837 }
1838 /* else continue. */
1839
1840 switch (TREE_CODE (type))
1841 {
1842 case VOID_TYPE:
1843 case LANG_TYPE:
1844 /* For a void type, just define it as itself; i.e., "5=5".
1845 This makes us consider it defined
1846 without saying what it is. The debugger will make it
1847 a void type when the reference is seen, and nothing will
1848 ever override that default. */
1849 dbxout_type_index (type);
1850 break;
1851
1852 case INTEGER_TYPE:
1853 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1854 {
1855 /* Output the type `char' as a subrange of itself!
1856 I don't understand this definition, just copied it
1857 from the output of pcc.
1858 This used to use `r2' explicitly and we used to
1859 take care to make sure that `char' was type number 2. */
1860 stabstr_C ('r');
1861 dbxout_type_index (type);
1862 stabstr_S (";0;127;");
1863 }
1864
1865 /* If this is a subtype of another integer type, always prefer to
1866 write it as a subtype. */
1867 else if (TREE_TYPE (type) != 0
1868 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1869 {
1870 /* If the size is non-standard, say what it is if we can use
1871 GDB extensions. */
1872
1873 if (use_gnu_debug_info_extensions
1874 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1875 {
1876 stabstr_S ("@s");
1877 stabstr_D (TYPE_PRECISION (type));
1878 stabstr_C (';');
1879 }
1880
1881 dbxout_range_type (type);
1882 }
1883
1884 else
1885 {
1886 /* If the size is non-standard, say what it is if we can use
1887 GDB extensions. */
1888
1889 if (use_gnu_debug_info_extensions
1890 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1891 {
1892 stabstr_S ("@s");
1893 stabstr_D (TYPE_PRECISION (type));
1894 stabstr_C (';');
1895 }
1896
1897 if (print_int_cst_bounds_in_octal_p (type))
1898 {
1899 stabstr_C ('r');
1900
1901 /* If this type derives from another type, output type index of
1902 parent type. This is particularly important when parent type
1903 is an enumerated type, because not generating the parent type
1904 index would transform the definition of this enumerated type
1905 into a plain unsigned type. */
1906 if (TREE_TYPE (type) != 0)
1907 dbxout_type_index (TREE_TYPE (type));
1908 else
1909 dbxout_type_index (type);
1910
1911 stabstr_C (';');
1912 stabstr_O (TYPE_MIN_VALUE (type));
1913 stabstr_C (';');
1914 stabstr_O (TYPE_MAX_VALUE (type));
1915 stabstr_C (';');
1916 }
1917
1918 else
1919 /* Output other integer types as subranges of `int'. */
1920 dbxout_range_type (type);
1921 }
1922
1923 break;
1924
1925 case REAL_TYPE:
1926 case FIXED_POINT_TYPE:
1927 /* This used to say `r1' and we used to take care
1928 to make sure that `int' was type number 1. */
1929 stabstr_C ('r');
1930 dbxout_type_index (integer_type_node);
1931 stabstr_C (';');
1932 stabstr_D (int_size_in_bytes (type));
1933 stabstr_S (";0;");
1934 break;
1935
1936 case BOOLEAN_TYPE:
1937 if (use_gnu_debug_info_extensions)
1938 {
1939 stabstr_S ("@s");
1940 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1941 stabstr_S (";-16;");
1942 }
1943 else /* Define as enumeral type (False, True) */
1944 stabstr_S ("eFalse:0,True:1,;");
1945 break;
1946
1947 case COMPLEX_TYPE:
1948 /* Differs from the REAL_TYPE by its new data type number.
1949 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1950 codes since gdb doesn't care anyway. */
1951
1952 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1953 {
1954 stabstr_S ("R3;");
1955 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1956 stabstr_S (";0;");
1957 }
1958 else
1959 {
1960 /* Output a complex integer type as a structure,
1961 pending some other way to do it. */
1962 stabstr_C ('s');
1963 stabstr_D (int_size_in_bytes (type));
1964
1965 stabstr_S ("real:");
1966 dbxout_type (TREE_TYPE (type), 0);
1967 stabstr_S (",0,");
1968 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1969
1970 stabstr_S (";imag:");
1971 dbxout_type (TREE_TYPE (type), 0);
1972 stabstr_C (',');
1973 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1974 stabstr_C (',');
1975 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1976 stabstr_S (";;");
1977 }
1978 break;
1979
1980 case ARRAY_TYPE:
1981 /* Make arrays of packed bits look like bitstrings for chill. */
1982 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1983 {
1984 stabstr_S ("@s");
1985 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1986 stabstr_S (";@S;S");
1987 dbxout_type (TYPE_DOMAIN (type), 0);
1988 break;
1989 }
1990
1991 if (use_gnu_debug_info_extensions && vector_type)
1992 stabstr_S ("@V;");
1993
1994 /* Output "a" followed by a range type definition
1995 for the index type of the array
1996 followed by a reference to the target-type.
1997 ar1;0;N;M for a C array of type M and size N+1. */
1998 /* Check if a character string type, which in Chill is
1999 different from an array of characters. */
2000 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2001 {
2002 stabstr_S ("@S;");
2003 }
2004 tem = TYPE_DOMAIN (type);
2005 if (tem == NULL)
2006 {
2007 stabstr_S ("ar");
2008 dbxout_type_index (integer_type_node);
2009 stabstr_S (";0;-1;");
2010 }
2011 else
2012 {
2013 stabstr_C ('a');
2014 dbxout_range_type (tem);
2015 }
2016
2017 dbxout_type (TREE_TYPE (type), 0);
2018 break;
2019
2020 case RECORD_TYPE:
2021 case UNION_TYPE:
2022 case QUAL_UNION_TYPE:
2023 {
2024 tree binfo = TYPE_BINFO (type);
2025
2026 /* Output a structure type. We must use the same test here as we
2027 use in the DBX_NO_XREFS case above. */
2028 if ((TYPE_NAME (type) != 0
2029 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2030 && DECL_IGNORED_P (TYPE_NAME (type)))
2031 && !full)
2032 || !COMPLETE_TYPE_P (type)
2033 /* No way in DBX fmt to describe a variable size. */
2034 || ! host_integerp (TYPE_SIZE (type), 1))
2035 {
2036 /* If the type is just a cross reference, output one
2037 and mark the type as partially described.
2038 If it later becomes defined, we will output
2039 its real definition.
2040 If the type has a name, don't nest its definition within
2041 another type's definition; instead, output an xref
2042 and let the definition come when the name is defined. */
2043 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2044 if (TYPE_NAME (type) != 0
2045 /* The C frontend creates for anonymous variable length
2046 records/unions TYPE_NAME with DECL_NAME NULL. */
2047 && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
2048 || DECL_NAME (TYPE_NAME (type))))
2049 dbxout_type_name (type);
2050 else
2051 {
2052 stabstr_S ("$$");
2053 stabstr_D (anonymous_type_number++);
2054 }
2055
2056 stabstr_C (':');
2057 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2058 break;
2059 }
2060
2061 /* Identify record or union, and print its size. */
2062 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2063 stabstr_D (int_size_in_bytes (type));
2064
2065 if (binfo)
2066 {
2067 int i;
2068 tree child;
2069 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
2070
2071 if (use_gnu_debug_info_extensions)
2072 {
2073 if (BINFO_N_BASE_BINFOS (binfo))
2074 {
2075 stabstr_C ('!');
2076 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2077 stabstr_C (',');
2078 }
2079 }
2080 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2081 {
2082 tree access = (accesses ? VEC_index (tree, accesses, i)
2083 : access_public_node);
2084
2085 if (use_gnu_debug_info_extensions)
2086 {
2087 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2088 stabstr_C (access == access_public_node ? '2' :
2089 access == access_protected_node
2090 ? '1' :'0');
2091 if (BINFO_VIRTUAL_P (child)
2092 && (strcmp (lang_hooks.name, "GNU C++") == 0
2093 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2094 /* For a virtual base, print the (negative)
2095 offset within the vtable where we must look
2096 to find the necessary adjustment. */
2097 stabstr_D
2098 (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2099 * BITS_PER_UNIT);
2100 else
2101 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2102 * BITS_PER_UNIT);
2103 stabstr_C (',');
2104 dbxout_type (BINFO_TYPE (child), 0);
2105 stabstr_C (';');
2106 }
2107 else
2108 {
2109 /* Print out the base class information with
2110 fields which have the same names at the types
2111 they hold. */
2112 dbxout_type_name (BINFO_TYPE (child));
2113 stabstr_C (':');
2114 dbxout_type (BINFO_TYPE (child), full);
2115 stabstr_C (',');
2116 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2117 * BITS_PER_UNIT);
2118 stabstr_C (',');
2119 stabstr_D
2120 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2121 * BITS_PER_UNIT);
2122 stabstr_C (';');
2123 }
2124 }
2125 }
2126 }
2127
2128 /* Write out the field declarations. */
2129 dbxout_type_fields (type);
2130 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2131 {
2132 dbxout_type_methods (type);
2133 }
2134
2135 stabstr_C (';');
2136
2137 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2138 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2139 && TYPE_VFIELD (type))
2140 {
2141
2142 /* We need to write out info about what field this class
2143 uses as its "main" vtable pointer field, because if this
2144 field is inherited from a base class, GDB cannot necessarily
2145 figure out which field it's using in time. */
2146 stabstr_S ("~%");
2147 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2148 stabstr_C (';');
2149 }
2150 break;
2151
2152 case ENUMERAL_TYPE:
2153 /* We must use the same test here as we use in the DBX_NO_XREFS case
2154 above. We simplify it a bit since an enum will never have a variable
2155 size. */
2156 if ((TYPE_NAME (type) != 0
2157 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2158 && DECL_IGNORED_P (TYPE_NAME (type)))
2159 && !full)
2160 || !COMPLETE_TYPE_P (type))
2161 {
2162 stabstr_S ("xe");
2163 dbxout_type_name (type);
2164 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2165 stabstr_C (':');
2166 return;
2167 }
2168 if (use_gnu_debug_info_extensions
2169 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2170 {
2171 stabstr_S ("@s");
2172 stabstr_D (TYPE_PRECISION (type));
2173 stabstr_C (';');
2174 }
2175
2176 stabstr_C ('e');
2177 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2178 {
2179 tree value = TREE_VALUE (tem);
2180
2181 stabstr_I (TREE_PURPOSE (tem));
2182 stabstr_C (':');
2183
2184 if (TREE_CODE (value) == CONST_DECL)
2185 value = DECL_INITIAL (value);
2186
2187 if (TREE_INT_CST_HIGH (value) == 0)
2188 stabstr_D (TREE_INT_CST_LOW (value));
2189 else if (TREE_INT_CST_HIGH (value) == -1
2190 && (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < 0)
2191 stabstr_D (TREE_INT_CST_LOW (value));
2192 else
2193 stabstr_O (value);
2194
2195 stabstr_C (',');
2196 if (TREE_CHAIN (tem) != 0)
2197 CONTIN;
2198 }
2199
2200 stabstr_C (';');
2201 break;
2202
2203 case POINTER_TYPE:
2204 stabstr_C ('*');
2205 dbxout_type (TREE_TYPE (type), 0);
2206 break;
2207
2208 case METHOD_TYPE:
2209 if (use_gnu_debug_info_extensions)
2210 {
2211 stabstr_C ('#');
2212
2213 /* Write the argument types out longhand. */
2214 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2215 stabstr_C (',');
2216 dbxout_type (TREE_TYPE (type), 0);
2217 dbxout_args (TYPE_ARG_TYPES (type));
2218 stabstr_C (';');
2219 }
2220 else
2221 /* Treat it as a function type. */
2222 dbxout_type (TREE_TYPE (type), 0);
2223 break;
2224
2225 case OFFSET_TYPE:
2226 if (use_gnu_debug_info_extensions)
2227 {
2228 stabstr_C ('@');
2229 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2230 stabstr_C (',');
2231 dbxout_type (TREE_TYPE (type), 0);
2232 }
2233 else
2234 /* Should print as an int, because it is really just an offset. */
2235 dbxout_type (integer_type_node, 0);
2236 break;
2237
2238 case REFERENCE_TYPE:
2239 if (use_gnu_debug_info_extensions)
2240 {
2241 stabstr_C ('&');
2242 }
2243 else
2244 stabstr_C ('*');
2245 dbxout_type (TREE_TYPE (type), 0);
2246 break;
2247
2248 case FUNCTION_TYPE:
2249 stabstr_C ('f');
2250 dbxout_type (TREE_TYPE (type), 0);
2251 break;
2252
2253 default:
2254 gcc_unreachable ();
2255 }
2256}
2257
2258/* Return nonzero if the given type represents an integer whose bounds
2259 should be printed in octal format. */
2260
2261static bool
2262print_int_cst_bounds_in_octal_p (tree type)
2263{
2264 /* If we can use GDB extensions and the size is wider than a long
2265 (the size used by GDB to read them) or we may have trouble writing
2266 the bounds the usual way, write them in octal. Note the test is for
2267 the *target's* size of "long", not that of the host. The host test
2268 is just to make sure we can write it out in case the host wide int
2269 is narrower than the target "long".
2270
2271 For unsigned types, we use octal if they are the same size or larger.
2272 This is because we print the bounds as signed decimal, and hence they
2273 can't span same size unsigned types. */
2274
2275 if (use_gnu_debug_info_extensions
2276 && TYPE_MIN_VALUE (type) != 0
2277 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
2278 && TYPE_MAX_VALUE (type) != 0
2279 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
2280 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2281 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2282 && TYPE_UNSIGNED (type))
2283 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2284 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2285 && TYPE_UNSIGNED (type))))
2286 return TRUE;
2287 else
2288 return FALSE;
2289}
2290
2291/* Output the name of type TYPE, with no punctuation.
2292 Such names can be set up either by typedef declarations
2293 or by struct, enum and union tags. */
2294
2295static void
2296dbxout_type_name (tree type)
2297{
2298 tree t = TYPE_NAME (type);
2299
2300 gcc_assert (t);
2301 switch (TREE_CODE (t))
2302 {
2303 case IDENTIFIER_NODE:
2304 break;
2305 case TYPE_DECL:
2306 t = DECL_NAME (t);
2307 break;
2308 default:
2309 gcc_unreachable ();
2310 }
2311
2312 stabstr_I (t);
2313}
2314
2315/* Output leading leading struct or class names needed for qualifying
2316 type whose scope is limited to a struct or class. */
2317
2318static void
2319dbxout_class_name_qualifiers (tree decl)
2320{
2321 tree context = decl_type_context (decl);
2322
2323 if (context != NULL_TREE
2324 && TREE_CODE(context) == RECORD_TYPE
2325 && TYPE_NAME (context) != 0
2326 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2327 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2328 {
2329 tree name = TYPE_NAME (context);
2330
2331 if (TREE_CODE (name) == TYPE_DECL)
2332 {
2333 dbxout_class_name_qualifiers (name);
2334 name = DECL_NAME (name);
2335 }
2336 stabstr_I (name);
2337 stabstr_S ("::");
2338 }
2339}
2340\f
2341/* This is a specialized subset of expand_expr for use by dbxout_symbol in
2342 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2343 haven't been expanded, or if the expression is getting so complex we won't
2344 be able to represent it in stabs anyway. Returns NULL on failure. */
2345
2346static rtx
2347dbxout_expand_expr (tree expr)
2348{
2349 switch (TREE_CODE (expr))
2350 {
2351 case VAR_DECL:
2352 /* We can't handle emulated tls variables, because the address is an
2353 offset to the return value of __emutls_get_address, and there is no
2354 way to express that in stabs. Also, there are name mangling issues
2355 here. We end up with references to undefined symbols if we don't
2356 disable debug info for these variables. */
2357 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2358 return NULL;
2359 /* FALLTHRU */
2360
2361 case PARM_DECL:
2362 if (DECL_HAS_VALUE_EXPR_P (expr))
2363 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2364 /* FALLTHRU */
2365
2366 case CONST_DECL:
2367 case RESULT_DECL:
2368 return DECL_RTL_IF_SET (expr);
2369
2370 case INTEGER_CST:
2371 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2372
2373 case COMPONENT_REF:
2374 case ARRAY_REF:
2375 case ARRAY_RANGE_REF:
2376 case BIT_FIELD_REF:
2377 {
2378 enum machine_mode mode;
2379 HOST_WIDE_INT bitsize, bitpos;
2380 tree offset, tem;
2381 int volatilep = 0, unsignedp = 0;
2382 rtx x;
2383
2384 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2385 &mode, &unsignedp, &volatilep, true);
2386
2387 x = dbxout_expand_expr (tem);
2388 if (x == NULL || !MEM_P (x))
2389 return NULL;
2390 if (offset != NULL)
2391 {
2392 if (!host_integerp (offset, 0))
2393 return NULL;
2394 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
2395 }
2396 if (bitpos != 0)
2397 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2398
2399 return x;
2400 }
2401
2402 default:
2403 return NULL;
2404 }
2405}
2406
2407/* Helper function for output_used_types. Queue one entry from the
2408 used types hash to be output. */
2409
2410static int
2411output_used_types_helper (void **slot, void *data)
2412{
2413 tree type = (tree) *slot;
2414 VEC(tree, heap) **types_p = (VEC(tree, heap) **) data;
2415
2416 if ((TREE_CODE (type) == RECORD_TYPE
2417 || TREE_CODE (type) == UNION_TYPE
2418 || TREE_CODE (type) == QUAL_UNION_TYPE
2419 || TREE_CODE (type) == ENUMERAL_TYPE)
2420 && TYPE_STUB_DECL (type)
2421 && DECL_P (TYPE_STUB_DECL (type))
2422 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2423 VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
2424 else if (TYPE_NAME (type)
2425 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2426 VEC_quick_push (tree, *types_p, TYPE_NAME (type));
2427
2428 return 1;
2429}
2430
2431/* This is a qsort callback which sorts types and declarations into a
2432 predictable order (types, then declarations, sorted by UID
2433 within). */
2434
2435static int
2436output_types_sort (const void *pa, const void *pb)
2437{
2438 const tree lhs = *((const tree *)pa);
2439 const tree rhs = *((const tree *)pb);
2440
2441 if (TYPE_P (lhs))
2442 {
2443 if (TYPE_P (rhs))
2444 return TYPE_UID (lhs) - TYPE_UID (rhs);
2445 else
2446 return 1;
2447 }
2448 else
2449 {
2450 if (TYPE_P (rhs))
2451 return -1;
2452 else
2453 return DECL_UID (lhs) - DECL_UID (rhs);
2454 }
2455}
2456
2457
2458/* Force all types used by this function to be output in debug
2459 information. */
2460
2461static void
2462output_used_types (void)
2463{
2464 if (cfun && cfun->used_types_hash)
2465 {
2466 VEC(tree, heap) *types;
2467 int i;
2468 tree type;
2469
2470 types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
2471 htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
2472
2473 /* Sort by UID to prevent dependence on hash table ordering. */
2474 qsort (VEC_address (tree, types), VEC_length (tree, types),
2475 sizeof (tree), output_types_sort);
2476
2477 for (i = 0; VEC_iterate (tree, types, i, type); i++)
2478 debug_queue_symbol (type);
2479
2480 VEC_free (tree, heap, types);
2481 }
2482}
2483
2484/* Output a .stabs for the symbol defined by DECL,
2485 which must be a ..._DECL node in the normal namespace.
2486 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2487 LOCAL is nonzero if the scope is less than the entire file.
2488 Return 1 if a stabs might have been emitted. */
2489
2490int
2491dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2492{
2493 tree type = TREE_TYPE (decl);
2494 tree context = NULL_TREE;
2495 int result = 0;
2496 rtx decl_rtl;
2497
2498 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2499 ++debug_nesting;
2500
2501 /* Ignore nameless syms, but don't ignore type tags. */
2502
2503 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2504 || DECL_IGNORED_P (decl))
2505 DBXOUT_DECR_NESTING_AND_RETURN (0);
2506
2507 /* If we are to generate only the symbols actually used then such
2508 symbol nodes are flagged with TREE_USED. Ignore any that
2509 aren't flagged as TREE_USED. */
2510
2511 if (flag_debug_only_used_symbols
2512 && (!TREE_USED (decl)
2513 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2514 DBXOUT_DECR_NESTING_AND_RETURN (0);
2515
2516 /* If dbxout_init has not yet run, queue this symbol for later. */
2517 if (!typevec)
2518 {
2519 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2520 DBXOUT_DECR_NESTING_AND_RETURN (0);
2521 }
2522
2523 if (flag_debug_only_used_symbols)
2524 {
2525 tree t;
2526
2527 /* We now have a used symbol. We need to generate the info for
2528 the symbol's type in addition to the symbol itself. These
2529 type symbols are queued to be generated after were done with
2530 the symbol itself (otherwise they would fight over the
2531 stabstr obstack).
2532
2533 Note, because the TREE_TYPE(type) might be something like a
2534 pointer to a named type we need to look for the first name
2535 we see following the TREE_TYPE chain. */
2536
2537 t = type;
2538 while (POINTER_TYPE_P (t))
2539 t = TREE_TYPE (t);
2540
2541 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2542 need special treatment. The TYPE_STUB_DECL field in these
2543 types generally represents the tag name type we want to
2544 output. In addition there could be a typedef type with
2545 a different name. In that case we also want to output
2546 that. */
2547
2548 if (TREE_CODE (t) == RECORD_TYPE
2549 || TREE_CODE (t) == UNION_TYPE
2550 || TREE_CODE (t) == QUAL_UNION_TYPE
2551 || TREE_CODE (t) == ENUMERAL_TYPE)
2552 {
2553 if (TYPE_STUB_DECL (t)
2554 && TYPE_STUB_DECL (t) != decl
2555 && DECL_P (TYPE_STUB_DECL (t))
2556 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2557 {
2558 debug_queue_symbol (TYPE_STUB_DECL (t));
2559 if (TYPE_NAME (t)
2560 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2561 && TYPE_NAME (t) != decl
2562 && DECL_P (TYPE_NAME (t)))
2563 debug_queue_symbol (TYPE_NAME (t));
2564 }
2565 }
2566 else if (TYPE_NAME (t)
2567 && TYPE_NAME (t) != decl
2568 && DECL_P (TYPE_NAME (t)))
2569 debug_queue_symbol (TYPE_NAME (t));
2570 }
2571
2572 emit_pending_bincls_if_required ();
2573
2574 switch (TREE_CODE (decl))
2575 {
2576 case CONST_DECL:
2577 /* Enum values are defined by defining the enum type. */
2578 break;
2579
2580 case FUNCTION_DECL:
2581 decl_rtl = DECL_RTL_IF_SET (decl);
2582 if (!decl_rtl)
2583 DBXOUT_DECR_NESTING_AND_RETURN (0);
2584 if (DECL_EXTERNAL (decl))
2585 break;
2586 /* Don't mention a nested function under its parent. */
2587 context = decl_function_context (decl);
2588 if (context == current_function_decl)
2589 break;
2590 /* Don't mention an inline instance of a nested function. */
2591 if (context && DECL_FROM_INLINE (decl))
2592 break;
2593 if (!MEM_P (decl_rtl)
2594 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2595 break;
2596
2597 if (flag_debug_only_used_symbols)
2598 output_used_types ();
2599
2600 dbxout_begin_complex_stabs ();
2601 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2602 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2603 result = 1;
2604
2605 if (TREE_TYPE (type))
2606 dbxout_type (TREE_TYPE (type), 0);
2607 else
2608 dbxout_type (void_type_node, 0);
2609
2610 /* For a nested function, when that function is compiled,
2611 mention the containing function name
2612 as well as (since dbx wants it) our own assembler-name. */
2613 if (context != 0)
2614 {
2615 stabstr_C (',');
2616 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2617 stabstr_C (',');
2618 stabstr_I (DECL_NAME (context));
2619 }
2620
2621 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2622 break;
2623
2624 case TYPE_DECL:
2625 /* Don't output the same typedef twice.
2626 And don't output what language-specific stuff doesn't want output. */
2627 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2628 DBXOUT_DECR_NESTING_AND_RETURN (0);
2629
2630 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2631#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2632 {
2633 int fundamental_type_number =
2634 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2635
2636 if (fundamental_type_number != 0)
2637 {
2638 TREE_ASM_WRITTEN (decl) = 1;
2639 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2640 DBXOUT_DECR_NESTING_AND_RETURN (0);
2641 }
2642 }
2643#endif
2644 FORCE_TEXT;
2645 result = 1;
2646 {
2647 int tag_needed = 1;
2648 int did_output = 0;
2649
2650 if (DECL_NAME (decl))
2651 {
2652 /* Nonzero means we must output a tag as well as a typedef. */
2653 tag_needed = 0;
2654
2655 /* Handle the case of a C++ structure or union
2656 where the TYPE_NAME is a TYPE_DECL
2657 which gives both a typedef name and a tag. */
2658 /* dbx requires the tag first and the typedef second. */
2659 if ((TREE_CODE (type) == RECORD_TYPE
2660 || TREE_CODE (type) == UNION_TYPE
2661 || TREE_CODE (type) == QUAL_UNION_TYPE)
2662 && TYPE_NAME (type) == decl
2663 && !use_gnu_debug_info_extensions
2664 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2665 /* Distinguish the implicit typedefs of C++
2666 from explicit ones that might be found in C. */
2667 && DECL_ARTIFICIAL (decl)
2668 /* Do not generate a tag for incomplete records. */
2669 && COMPLETE_TYPE_P (type)
2670 /* Do not generate a tag for records of variable size,
2671 since this type can not be properly described in the
2672 DBX format, and it confuses some tools such as objdump. */
2673 && host_integerp (TYPE_SIZE (type), 1))
2674 {
2675 tree name = TYPE_NAME (type);
2676 if (TREE_CODE (name) == TYPE_DECL)
2677 name = DECL_NAME (name);
2678
2679 dbxout_begin_complex_stabs ();
2680 stabstr_I (name);
2681 stabstr_S (":T");
2682 dbxout_type (type, 1);
2683 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2684 0, 0, 0);
2685 }
2686
2687 dbxout_begin_complex_stabs ();
2688
2689 /* Output leading class/struct qualifiers. */
2690 if (use_gnu_debug_info_extensions)
2691 dbxout_class_name_qualifiers (decl);
2692
2693 /* Output typedef name. */
2694 stabstr_I (DECL_NAME (decl));
2695 stabstr_C (':');
2696
2697 /* Short cut way to output a tag also. */
2698 if ((TREE_CODE (type) == RECORD_TYPE
2699 || TREE_CODE (type) == UNION_TYPE
2700 || TREE_CODE (type) == QUAL_UNION_TYPE)
2701 && TYPE_NAME (type) == decl
2702 /* Distinguish the implicit typedefs of C++
2703 from explicit ones that might be found in C. */
2704 && DECL_ARTIFICIAL (decl))
2705 {
2706 if (use_gnu_debug_info_extensions)
2707 {
2708 stabstr_C ('T');
2709 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2710 }
2711 }
2712
2713 stabstr_C ('t');
2714 dbxout_type (type, 1);
2715 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2716 0, 0, 0);
2717 did_output = 1;
2718 }
2719
2720 /* Don't output a tag if this is an incomplete type. This prevents
2721 the sun4 Sun OS 4.x dbx from crashing. */
2722
2723 if (tag_needed && TYPE_NAME (type) != 0
2724 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2725 || (DECL_NAME (TYPE_NAME (type)) != 0))
2726 && COMPLETE_TYPE_P (type)
2727 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2728 {
2729 /* For a TYPE_DECL with no name, but the type has a name,
2730 output a tag.
2731 This is what represents `struct foo' with no typedef. */
2732 /* In C++, the name of a type is the corresponding typedef.
2733 In C, it is an IDENTIFIER_NODE. */
2734 tree name = TYPE_NAME (type);
2735 if (TREE_CODE (name) == TYPE_DECL)
2736 name = DECL_NAME (name);
2737
2738 dbxout_begin_complex_stabs ();
2739 stabstr_I (name);
2740 stabstr_S (":T");
2741 dbxout_type (type, 1);
2742 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2743 did_output = 1;
2744 }
2745
2746 /* If an enum type has no name, it cannot be referred to, but
2747 we must output it anyway, to record the enumeration
2748 constants. */
2749
2750 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2751 {
2752 dbxout_begin_complex_stabs ();
2753 /* Some debuggers fail when given NULL names, so give this a
2754 harmless name of " " (Why not "(anon)"?). */
2755 stabstr_S (" :T");
2756 dbxout_type (type, 1);
2757 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2758 }
2759
2760 /* Prevent duplicate output of a typedef. */
2761 TREE_ASM_WRITTEN (decl) = 1;
2762 break;
2763 }
2764
2765 case PARM_DECL:
2766 if (DECL_HAS_VALUE_EXPR_P (decl))
2767 decl = DECL_VALUE_EXPR (decl);
2768
2769 /* PARM_DECLs go in their own separate chain and are output by
2770 dbxout_reg_parms and dbxout_parms, except for those that are
2771 disguised VAR_DECLs like Out parameters in Ada. */
2772 gcc_assert (TREE_CODE (decl) == VAR_DECL);
2773
2774 /* ... fall through ... */
2775
2776 case RESULT_DECL:
2777 case VAR_DECL:
2778 /* Don't mention a variable that is external.
2779 Let the file that defines it describe it. */
2780 if (DECL_EXTERNAL (decl))
2781 break;
2782
2783 /* If the variable is really a constant
2784 and not written in memory, inform the debugger.
2785
2786 ??? Why do we skip emitting the type and location in this case? */
2787 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2788 && DECL_INITIAL (decl) != 0
2789 && host_integerp (DECL_INITIAL (decl), 0)
2790 && ! TREE_ASM_WRITTEN (decl)
2791 && (DECL_CONTEXT (decl) == NULL_TREE
2792 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2793 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2794 && TREE_PUBLIC (decl) == 0)
2795 {
2796 /* The sun4 assembler does not grok this. */
2797
2798 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2799 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2800 {
2801 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2802
2803 dbxout_begin_complex_stabs ();
2804 dbxout_symbol_name (decl, NULL, 'c');
2805 stabstr_S ("=i");
2806 stabstr_D (ival);
2807 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2808 DBXOUT_DECR_NESTING;
2809 return 1;
2810 }
2811 else
2812 break;
2813 }
2814 /* else it is something we handle like a normal variable. */
2815
2816 decl_rtl = dbxout_expand_expr (decl);
2817 if (!decl_rtl)
2818 DBXOUT_DECR_NESTING_AND_RETURN (0);
2819
2820 decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX);
2821#ifdef LEAF_REG_REMAP
2822 if (current_function_uses_only_leaf_regs)
2823 leaf_renumber_regs_insn (decl_rtl);
2824#endif
2825
2826 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2827 break;
2828
2829 default:
2830 break;
2831 }
2832 DBXOUT_DECR_NESTING;
2833 return result;
2834}
2835\f
2836/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2837 Add SUFFIX to its name, if SUFFIX is not 0.
2838 Describe the variable as residing in HOME
2839 (usually HOME is DECL_RTL (DECL), but not always).
2840 Returns 1 if the stab was really emitted. */
2841
2842static int
2843dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2844{
2845 int letter = 0;
2846 STAB_CODE_TYPE code;
2847 rtx addr = 0;
2848 int number = 0;
2849 int regno = -1;
2850
2851 /* Don't mention a variable at all
2852 if it was completely optimized into nothingness.
2853
2854 If the decl was from an inline function, then its rtl
2855 is not identically the rtl that was used in this
2856 particular compilation. */
2857 if (GET_CODE (home) == SUBREG)
2858 {
2859 rtx value = home;
2860
2861 while (GET_CODE (value) == SUBREG)
2862 value = SUBREG_REG (value);
2863 if (REG_P (value))
2864 {
2865 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2866 return 0;
2867 }
2868 home = alter_subreg (&home);
2869 }
2870 if (REG_P (home))
2871 {
2872 regno = REGNO (home);
2873 if (regno >= FIRST_PSEUDO_REGISTER)
2874 return 0;
2875 }
2876
2877 /* The kind-of-variable letter depends on where
2878 the variable is and on the scope of its name:
2879 G and N_GSYM for static storage and global scope,
2880 S for static storage and file scope,
2881 V for static storage and local scope,
2882 for those two, use N_LCSYM if data is in bss segment,
2883 N_STSYM if in data segment, N_FUN otherwise.
2884 (We used N_FUN originally, then changed to N_STSYM
2885 to please GDB. However, it seems that confused ld.
2886 Now GDB has been fixed to like N_FUN, says Kingdon.)
2887 no letter at all, and N_LSYM, for auto variable,
2888 r and N_RSYM for register variable. */
2889
2890 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2891 {
2892 if (TREE_PUBLIC (decl))
2893 {
2894 int offs;
2895 letter = 'G';
2896 code = N_GSYM;
2897 if (NULL != dbxout_common_check (decl, &offs))
2898 {
2899 letter = 'V';
2900 addr = 0;
2901 number = offs;
2902 }
2903 }
2904 else
2905 {
2906 addr = XEXP (home, 0);
2907
2908 letter = decl_function_context (decl) ? 'V' : 'S';
2909
2910 /* Some ports can transform a symbol ref into a label ref,
2911 because the symbol ref is too far away and has to be
2912 dumped into a constant pool. Alternatively, the symbol
2913 in the constant pool might be referenced by a different
2914 symbol. */
2915 if (GET_CODE (addr) == SYMBOL_REF
2916 && CONSTANT_POOL_ADDRESS_P (addr))
2917 {
2918 bool marked;
2919 rtx tmp = get_pool_constant_mark (addr, &marked);
2920
2921 if (GET_CODE (tmp) == SYMBOL_REF)
2922 {
2923 addr = tmp;
2924 if (CONSTANT_POOL_ADDRESS_P (addr))
2925 get_pool_constant_mark (addr, &marked);
2926 else
2927 marked = true;
2928 }
2929 else if (GET_CODE (tmp) == LABEL_REF)
2930 {
2931 addr = tmp;
2932 marked = true;
2933 }
2934
2935 /* If all references to the constant pool were optimized
2936 out, we just ignore the symbol. */
2937 if (!marked)
2938 return 0;
2939 }
2940
2941 /* This should be the same condition as in assemble_variable, but
2942 we don't have access to dont_output_data here. So, instead,
2943 we rely on the fact that error_mark_node initializers always
2944 end up in bss for C++ and never end up in bss for C. */
2945 if (DECL_INITIAL (decl) == 0
2946 || (!strcmp (lang_hooks.name, "GNU C++")
2947 && DECL_INITIAL (decl) == error_mark_node))
2948 {
2949 int offs;
2950 code = N_LCSYM;
2951 if (NULL != dbxout_common_check (decl, &offs))
2952 {
2953 addr = 0;
2954 number = offs;
2955 letter = 'V';
2956 code = N_GSYM;
2957 }
2958 }
2959 else if (DECL_IN_TEXT_SECTION (decl))
2960 /* This is not quite right, but it's the closest
2961 of all the codes that Unix defines. */
2962 code = DBX_STATIC_CONST_VAR_CODE;
2963 else
2964 {
2965 /* Ultrix `as' seems to need this. */
2966#ifdef DBX_STATIC_STAB_DATA_SECTION
2967 switch_to_section (data_section);
2968#endif
2969 code = N_STSYM;
2970 }
2971 }
2972 }
2973 else if (regno >= 0)
2974 {
2975 letter = 'r';
2976 code = N_RSYM;
2977 number = DBX_REGISTER_NUMBER (regno);
2978 }
2979 else if (MEM_P (home)
2980 && (MEM_P (XEXP (home, 0))
2981 || (REG_P (XEXP (home, 0))
2982 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2983 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2984#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2985 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2986#endif
2987 )))
2988 /* If the value is indirect by memory or by a register
2989 that isn't the frame pointer
2990 then it means the object is variable-sized and address through
2991 that register or stack slot. DBX has no way to represent this
2992 so all we can do is output the variable as a pointer.
2993 If it's not a parameter, ignore it. */
2994 {
2995 if (REG_P (XEXP (home, 0)))
2996 {
2997 letter = 'r';
2998 code = N_RSYM;
2999 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
3000 return 0;
3001 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3002 }
3003 else
3004 {
3005 code = N_LSYM;
3006 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3007 We want the value of that CONST_INT. */
3008 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3009 }
3010
3011 /* Effectively do build_pointer_type, but don't cache this type,
3012 since it might be temporary whereas the type it points to
3013 might have been saved for inlining. */
3014 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3015 type = make_node (POINTER_TYPE);
3016 TREE_TYPE (type) = TREE_TYPE (decl);
3017 }
3018 else if (MEM_P (home)
3019 && REG_P (XEXP (home, 0)))
3020 {
3021 code = N_LSYM;
3022 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3023 }
3024 else if (MEM_P (home)
3025 && GET_CODE (XEXP (home, 0)) == PLUS
3026 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
3027 {
3028 code = N_LSYM;
3029 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3030 We want the value of that CONST_INT. */
3031 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3032 }
3033 else if (MEM_P (home)
3034 && GET_CODE (XEXP (home, 0)) == CONST)
3035 {
3036 /* Handle an obscure case which can arise when optimizing and
3037 when there are few available registers. (This is *always*
3038 the case for i386/i486 targets). The RTL looks like
3039 (MEM (CONST ...)) even though this variable is a local `auto'
3040 or a local `register' variable. In effect, what has happened
3041 is that the reload pass has seen that all assignments and
3042 references for one such a local variable can be replaced by
3043 equivalent assignments and references to some static storage
3044 variable, thereby avoiding the need for a register. In such
3045 cases we're forced to lie to debuggers and tell them that
3046 this variable was itself `static'. */
3047 int offs;
3048 code = N_LCSYM;
3049 letter = 'V';
3050 if (NULL == dbxout_common_check (decl, &offs))
3051 addr = XEXP (XEXP (home, 0), 0);
3052 else
3053 {
3054 addr = 0;
3055 number = offs;
3056 code = N_GSYM;
3057 }
3058 }
3059 else if (GET_CODE (home) == CONCAT)
3060 {
3061 tree subtype;
3062
3063 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3064 for example), then there is no easy way to figure out
3065 what SUBTYPE should be. So, we give up. */
3066 if (TREE_CODE (type) != COMPLEX_TYPE)
3067 return 0;
3068
3069 subtype = TREE_TYPE (type);
3070
3071 /* If the variable's storage is in two parts,
3072 output each as a separate stab with a modified name. */
3073 if (WORDS_BIG_ENDIAN)
3074 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3075 else
3076 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3077
3078 if (WORDS_BIG_ENDIAN)
3079 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3080 else
3081 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3082 return 1;
3083 }
3084 else
3085 /* Address might be a MEM, when DECL is a variable-sized object.
3086 Or it might be const0_rtx, meaning previous passes
3087 want us to ignore this variable. */
3088 return 0;
3089
3090 /* Ok, start a symtab entry and output the variable name. */
3091 emit_pending_bincls_if_required ();
3092 FORCE_TEXT;
3093
3094#ifdef DBX_STATIC_BLOCK_START
3095 DBX_STATIC_BLOCK_START (asm_out_file, code);
3096#endif
3097
3098 dbxout_begin_complex_stabs_noforcetext ();
3099 dbxout_symbol_name (decl, suffix, letter);
3100 dbxout_type (type, 0);
3101 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3102
3103#ifdef DBX_STATIC_BLOCK_END
3104 DBX_STATIC_BLOCK_END (asm_out_file, code);
3105#endif
3106 return 1;
3107}
3108\f
3109/* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3110 Then output LETTER to indicate the kind of location the symbol has. */
3111
3112static void
3113dbxout_symbol_name (tree decl, const char *suffix, int letter)
3114{
3115 tree name;
3116
3117 if (DECL_CONTEXT (decl)
3118 && (TYPE_P (DECL_CONTEXT (decl))
3119 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3120 /* One slight hitch: if this is a VAR_DECL which is a class member
3121 or a namespace member, we must put out the mangled name instead of the
3122 DECL_NAME. Note also that static member (variable) names DO NOT begin
3123 with underscores in .stabs directives. */
3124 name = DECL_ASSEMBLER_NAME (decl);
3125 else
3126 /* ...but if we're function-local, we don't want to include the junk
3127 added by ASM_FORMAT_PRIVATE_NAME. */
3128 name = DECL_NAME (decl);
3129
3130 if (name)
3131 stabstr_I (name);
3132 else
3133 stabstr_S ("(anon)");
3134
3135 if (suffix)
3136 stabstr_S (suffix);
3137 stabstr_C (':');
3138 if (letter)
3139 stabstr_C (letter);
3140}
3141
3142
3143/* Output the common block name for DECL in a stabs.
3144
3145 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3146 around each group of symbols in the same .comm area. The N_GSYM stabs
3147 that are emitted only contain the offset in the common area. This routine
3148 emits the N_BCOMM and N_ECOMM stabs. */
3149
3150static void
3151dbxout_common_name (tree decl, const char *name, STAB_CODE_TYPE op)
3152{
3153 dbxout_begin_complex_stabs ();
3154 stabstr_S (name);
3155 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3156}
3157
3158/* Check decl to determine whether it is a VAR_DECL destined for storage in a
3159 common area. If it is, the return value will be a non-null string giving
3160 the name of the common storage block it will go into. If non-null, the
3161 value is the offset into the common block for that symbol's storage. */
3162
3163static const char *
3164dbxout_common_check (tree decl, int *value)
3165{
3166 rtx home;
3167 rtx sym_addr;
3168 const char *name = NULL;
3169
3170 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
3171 it does not have a value (the offset into the common area), or if it
3172 is thread local (as opposed to global) then it isn't common, and shouldn't
3173 be handled as such.
3174
3175 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3176 for thread-local symbols. Can be handled via same mechanism as used
3177 in dwarf2out.c. */
3178 if (TREE_CODE (decl) != VAR_DECL
3179 || !TREE_PUBLIC(decl)
3180 || !TREE_STATIC(decl)
3181 || !DECL_HAS_VALUE_EXPR_P(decl)
3182 || DECL_THREAD_LOCAL_P (decl)
3183 || !is_fortran ())
3184 return NULL;
3185
3186 home = DECL_RTL (decl);
3187 if (home == NULL_RTX || GET_CODE (home) != MEM)
3188 return NULL;
3189
3190 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3191 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3192 return NULL;
3193
3194 sym_addr = XEXP (sym_addr, 0);
3195 if (GET_CODE (sym_addr) == CONST)
3196 sym_addr = XEXP (sym_addr, 0);
3197 if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3198 && DECL_INITIAL (decl) == 0)
3199 {
3200
3201 /* We have a sym that will go into a common area, meaning that it
3202 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3203
3204 Determine name of common area this symbol will be an offset into,
3205 and offset into that area. Also retrieve the decl for the area
3206 that the symbol is offset into. */
3207 tree cdecl = NULL;
3208
3209 switch (GET_CODE (sym_addr))
3210 {
3211 case PLUS:
3212 if (GET_CODE (XEXP (sym_addr, 0)) == CONST_INT)
3213 {
3214 name =
3215 targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
3216 *value = INTVAL (XEXP (sym_addr, 0));
3217 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3218 }
3219 else
3220 {
3221 name =
3222 targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0));
3223 *value = INTVAL (XEXP (sym_addr, 1));
3224 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3225 }
3226 break;
3227
3228 case SYMBOL_REF:
3229 name = targetm.strip_name_encoding(XSTR (sym_addr, 0));
3230 *value = 0;
3231 cdecl = SYMBOL_REF_DECL (sym_addr);
3232 break;
3233
3234 default:
3235 error ("common symbol debug info is not structured as "
3236 "symbol+offset");
3237 }
3238
3239 /* Check area common symbol is offset into. If this is not public, then
3240 it is not a symbol in a common block. It must be a .lcomm symbol, not
3241 a .comm symbol. */
3242 if (cdecl == NULL || !TREE_PUBLIC(cdecl))
3243 name = NULL;
3244 }
3245 else
3246 name = NULL;
3247
3248 return name;
3249}
3250
3251/* Output definitions of all the decls in a chain. Return nonzero if
3252 anything was output */
3253
3254int
3255dbxout_syms (tree syms)
3256{
3257 int result = 0;
3258 const char *comm_prev = NULL;
3259 tree syms_prev = NULL;
3260
3261 while (syms)
3262 {
3263 int temp, copen, cclos;
3264 const char *comm_new;
3265
3266 /* Check for common symbol, and then progression into a new/different
3267 block of common symbols. Emit closing/opening common bracket if
3268 necessary. */
3269 comm_new = dbxout_common_check (syms, &temp);
3270 copen = comm_new != NULL
3271 && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3272 cclos = comm_prev != NULL
3273 && (comm_new == NULL || strcmp (comm_new, comm_prev));
3274 if (cclos)
3275 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3276 if (copen)
3277 {
3278 dbxout_common_name (syms, comm_new, N_BCOMM);
3279 syms_prev = syms;
3280 }
3281 comm_prev = comm_new;
3282
3283 result += dbxout_symbol (syms, 1);
3284 syms = TREE_CHAIN (syms);
3285 }
3286
3287 if (comm_prev != NULL)
3288 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3289
3290 return result;
3291}
3292\f
3293/* The following two functions output definitions of function parameters.
3294 Each parameter gets a definition locating it in the parameter list.
3295 Each parameter that is a register variable gets a second definition
3296 locating it in the register.
3297
3298 Printing or argument lists in gdb uses the definitions that
3299 locate in the parameter list. But reference to the variable in
3300 expressions uses preferentially the definition as a register. */
3301
3302/* Output definitions, referring to storage in the parmlist,
3303 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3304
3305void
3306dbxout_parms (tree parms)
3307{
3308 ++debug_nesting;
3309 emit_pending_bincls_if_required ();
3310
3311 for (; parms; parms = TREE_CHAIN (parms))
3312 if (DECL_NAME (parms)
3313 && TREE_TYPE (parms) != error_mark_node
3314 && DECL_RTL_SET_P (parms)
3315 && DECL_INCOMING_RTL (parms))
3316 {
3317 tree eff_type;
3318 char letter;
3319 STAB_CODE_TYPE code;
3320 int number;
3321
3322 /* Perform any necessary register eliminations on the parameter's rtl,
3323 so that the debugging output will be accurate. */
3324 DECL_INCOMING_RTL (parms)
3325 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
3326 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
3327#ifdef LEAF_REG_REMAP
3328 if (current_function_uses_only_leaf_regs)
3329 {
3330 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3331 leaf_renumber_regs_insn (DECL_RTL (parms));
3332 }
3333#endif
3334
3335 if (PARM_PASSED_IN_MEMORY (parms))
3336 {
3337 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3338
3339 /* ??? Here we assume that the parm address is indexed
3340 off the frame pointer or arg pointer.
3341 If that is not true, we produce meaningless results,
3342 but do not crash. */
3343 if (GET_CODE (inrtl) == PLUS
3344 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
3345 number = INTVAL (XEXP (inrtl, 1));
3346 else
3347 number = 0;
3348
3349 code = N_PSYM;
3350 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3351 letter = 'p';
3352
3353 /* It is quite tempting to use TREE_TYPE (parms) instead
3354 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3355 reports the actual type of the parameter, rather than
3356 the promoted type. This certainly makes GDB's life
3357 easier, at least for some ports. The change is a bad
3358 idea however, since GDB expects to be able access the
3359 type without performing any conversions. So for
3360 example, if we were passing a float to an unprototyped
3361 function, gcc will store a double on the stack, but if
3362 we emit a stab saying the type is a float, then gdb
3363 will only read in a single value, and this will produce
3364 an erroneous value. */
3365 eff_type = DECL_ARG_TYPE (parms);
3366 }
3367 else if (REG_P (DECL_RTL (parms)))
3368 {
3369 rtx best_rtl;
3370
3371 /* Parm passed in registers and lives in registers or nowhere. */
3372 code = DBX_REGPARM_STABS_CODE;
3373 letter = DBX_REGPARM_STABS_LETTER;
3374
3375 /* For parms passed in registers, it is better to use the
3376 declared type of the variable, not the type it arrived in. */
3377 eff_type = TREE_TYPE (parms);
3378
3379 /* If parm lives in a register, use that register; pretend
3380 the parm was passed there. It would be more consistent
3381 to describe the register where the parm was passed, but
3382 in practice that register usually holds something else.
3383 If the parm lives nowhere, use the register where it
3384 was passed. */
3385 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3386 best_rtl = DECL_RTL (parms);
3387 else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3388 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3389 else
3390 best_rtl = DECL_INCOMING_RTL (parms);
3391
3392 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3393 }
3394 else if (MEM_P (DECL_RTL (parms))
3395 && REG_P (XEXP (DECL_RTL (parms), 0))
3396 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3397 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3398#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3399 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3400#endif
3401 )
3402 {
3403 /* Parm was passed via invisible reference.
3404 That is, its address was passed in a register.
3405 Output it as if it lived in that register.
3406 The debugger will know from the type
3407 that it was actually passed by invisible reference. */
3408
3409 code = DBX_REGPARM_STABS_CODE;
3410
3411 /* GDB likes this marked with a special letter. */
3412 letter = (use_gnu_debug_info_extensions
3413 ? 'a' : DBX_REGPARM_STABS_LETTER);
3414 eff_type = TREE_TYPE (parms);
3415
3416 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3417 If it is an unallocated pseudo-reg, then use the register where
3418 it was passed instead.
3419 ??? Why is DBX_REGISTER_NUMBER not used here? */
3420
3421 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3422 number = REGNO (XEXP (DECL_RTL (parms), 0));
3423 else
3424 number = REGNO (DECL_INCOMING_RTL (parms));
3425 }
3426 else if (MEM_P (DECL_RTL (parms))
3427 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3428 {
3429 /* Parm was passed via invisible reference, with the reference
3430 living on the stack. DECL_RTL looks like
3431 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3432 could look like (MEM (MEM (REG))). */
3433
3434 code = N_PSYM;
3435 letter = 'v';
3436 eff_type = TREE_TYPE (parms);
3437
3438 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3439 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3440 else
3441 number = 0;
3442
3443 number = DEBUGGER_ARG_OFFSET (number,
3444 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3445 }
3446 else if (MEM_P (DECL_RTL (parms))
3447 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3448 /* ??? A constant address for a parm can happen
3449 when the reg it lives in is equiv to a constant in memory.
3450 Should make this not happen, after 2.4. */
3451 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3452 {
3453 /* Parm was passed in registers but lives on the stack. */
3454
3455 code = N_PSYM;
3456 letter = 'p';
3457 eff_type = TREE_TYPE (parms);
3458
3459 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3460 in which case we want the value of that CONST_INT,
3461 or (MEM (REG ...)),
3462 in which case we use a value of zero. */
3463 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3464 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3465 else
3466 number = 0;
3467
3468 /* Make a big endian correction if the mode of the type of the
3469 parameter is not the same as the mode of the rtl. */
3470 if (BYTES_BIG_ENDIAN
3471 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3472 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3473 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3474 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3475 }
3476 else
3477 /* ??? We don't know how to represent this argument. */
3478 continue;
3479
3480 dbxout_begin_complex_stabs ();
3481
3482 if (DECL_NAME (parms))
3483 {
3484 stabstr_I (DECL_NAME (parms));
3485 stabstr_C (':');
3486 }
3487 else
3488 stabstr_S ("(anon):");
3489 stabstr_C (letter);
3490 dbxout_type (eff_type, 0);
3491 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3492 }
3493 DBXOUT_DECR_NESTING;
3494}
3495
3496/* Output definitions for the places where parms live during the function,
3497 when different from where they were passed, when the parms were passed
3498 in memory.
3499
3500 It is not useful to do this for parms passed in registers
3501 that live during the function in different registers, because it is
3502 impossible to look in the passed register for the passed value,
3503 so we use the within-the-function register to begin with.
3504
3505 PARMS is a chain of PARM_DECL nodes. */
3506
3507void
3508dbxout_reg_parms (tree parms)
3509{
3510 ++debug_nesting;
3511
3512 for (; parms; parms = TREE_CHAIN (parms))
3513 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3514 {
3515 /* Report parms that live in registers during the function
3516 but were passed in memory. */
3517 if (REG_P (DECL_RTL (parms))
3518 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3519 dbxout_symbol_location (parms, TREE_TYPE (parms),
3520 0, DECL_RTL (parms));
3521 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3522 dbxout_symbol_location (parms, TREE_TYPE (parms),
3523 0, DECL_RTL (parms));
3524 /* Report parms that live in memory but not where they were passed. */
3525 else if (MEM_P (DECL_RTL (parms))
3526 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3527 dbxout_symbol_location (parms, TREE_TYPE (parms),
3528 0, DECL_RTL (parms));
3529 }
3530 DBXOUT_DECR_NESTING;
3531}
3532\f
3533/* Given a chain of ..._TYPE nodes (as come in a parameter list),
3534 output definitions of those names, in raw form */
3535
3536static void
3537dbxout_args (tree args)
3538{
3539 while (args)
3540 {
3541 stabstr_C (',');
3542 dbxout_type (TREE_VALUE (args), 0);
3543 args = TREE_CHAIN (args);
3544 }
3545}
3546\f
3547#if defined (DBX_DEBUGGING_INFO)
3548
3549/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3550 BEGIN_LABEL is the name of the beginning of the function, which may
3551 be required. */
3552static void
3553dbx_output_lbrac (const char *label,
3554 const char *begin_label ATTRIBUTE_UNUSED)
3555{
3556 dbxout_begin_stabn (N_LBRAC);
3557 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3558 dbxout_stab_value_label_diff (label, begin_label);
3559 else
3560 dbxout_stab_value_label (label);
3561}
3562
3563/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3564 BEGIN_LABEL is the name of the beginning of the function, which may
3565 be required. */
3566static void
3567dbx_output_rbrac (const char *label,
3568 const char *begin_label ATTRIBUTE_UNUSED)
3569{
3570 dbxout_begin_stabn (N_RBRAC);
3571 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3572 dbxout_stab_value_label_diff (label, begin_label);
3573 else
3574 dbxout_stab_value_label (label);
3575}
3576
3577/* Output everything about a symbol block (a BLOCK node
3578 that represents a scope level),
3579 including recursive output of contained blocks.
3580
3581 BLOCK is the BLOCK node.
3582 DEPTH is its depth within containing symbol blocks.
3583 ARGS is usually zero; but for the outermost block of the
3584 body of a function, it is a chain of PARM_DECLs for the function parameters.
3585 We output definitions of all the register parms
3586 as if they were local variables of that block.
3587
3588 If -g1 was used, we count blocks just the same, but output nothing
3589 except for the outermost block.
3590
3591 Actually, BLOCK may be several blocks chained together.
3592 We handle them all in sequence. */
3593
3594static void
3595dbxout_block (tree block, int depth, tree args)
3596{
3597 char begin_label[20];
3598 /* Reference current function start using LFBB. */
3599 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3600
3601 while (block)
3602 {
3603 /* Ignore blocks never expanded or otherwise marked as real. */
3604 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3605 {
3606 int did_output;
3607 int blocknum = BLOCK_NUMBER (block);
3608
3609 /* In dbx format, the syms of a block come before the N_LBRAC.
3610 If nothing is output, we don't need the N_LBRAC, either. */
3611 did_output = 0;
3612 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3613 did_output = dbxout_syms (BLOCK_VARS (block));
3614 if (args)
3615 dbxout_reg_parms (args);
3616
3617 /* Now output an N_LBRAC symbol to represent the beginning of
3618 the block. Use the block's tree-walk order to generate
3619 the assembler symbols LBBn and LBEn
3620 that final will define around the code in this block. */
3621 if (did_output)
3622 {
3623 char buf[20];
3624 const char *scope_start;
3625
3626 if (depth == 0)
3627 /* The outermost block doesn't get LBB labels; use
3628 the LFBB local symbol emitted by dbxout_begin_prologue. */
3629 scope_start = begin_label;
3630 else
3631 {
3632 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3633 scope_start = buf;
3634 }
3635
3636 dbx_output_lbrac (scope_start, begin_label);
3637 }
3638
3639 /* Output the subblocks. */
3640 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3641
3642 /* Refer to the marker for the end of the block. */
3643 if (did_output)
3644 {
3645 char buf[100];
3646 if (depth == 0)
3647 /* The outermost block doesn't get LBE labels;
3648 use the "scope" label which will be emitted
3649 by dbxout_function_end. */
3650 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3651 else
3652 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3653
3654 dbx_output_rbrac (buf, begin_label);
3655 }
3656 }
3657 block = BLOCK_CHAIN (block);
3658 }
3659}
3660
3661/* Output the information about a function and its arguments and result.
3662 Usually this follows the function's code,
3663 but on some systems, it comes before. */
3664
3665static void
3666dbxout_begin_function (tree decl)
3667{
3668 int saved_tree_used1;
3669
3670 if (DECL_IGNORED_P (decl))
3671 return;
3672
3673 saved_tree_used1 = TREE_USED (decl);
3674 TREE_USED (decl) = 1;
3675 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3676 {
3677 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3678 TREE_USED (DECL_RESULT (decl)) = 1;
3679 dbxout_symbol (decl, 0);
3680 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3681 }
3682 else
3683 dbxout_symbol (decl, 0);
3684 TREE_USED (decl) = saved_tree_used1;
3685
3686 dbxout_parms (DECL_ARGUMENTS (decl));
3687 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3688 dbxout_symbol (DECL_RESULT (decl), 1);
3689}
3690#endif /* DBX_DEBUGGING_INFO */
3691
3692#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3693
3694#include "gt-dbxout.h"