![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dbxout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to dbxout.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Output dbx-format symbol table information from GNU compiler.
2: Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* Output dbx-format symbol table data.
22: This consists of many symbol table entries, each of them
23: a .stabs assembler pseudo-op with four operands:
24: a "name" which is really a description of one symbol and its type,
25: a "code", which is a symbol defined in stab.h whose name starts with N_,
26: an unused operand always 0,
27: and a "value" which is an address or an offset.
28: The name is enclosed in doublequote characters.
29:
30: Each function, variable, typedef, and structure tag
31: has a symbol table entry to define it.
32: The beginning and end of each level of name scoping within
33: a function are also marked by special symbol table entries.
34:
35: The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36: and a data type number. The data type number may be followed by
37: "=" and a type definition; normally this will happen the first time
38: the type number is mentioned. The type definition may refer to
39: other types by number, and those type numbers may be followed
40: by "=" and nested definitions.
41:
42: This can make the "name" quite long.
43: When a name is more than 80 characters, we split the .stabs pseudo-op
44: into two .stabs pseudo-ops, both sharing the same "code" and "value".
45: The first one is marked as continued with a double-backslash at the
46: end of its "name".
47:
48: The kind-of-symbol letter distinguished function names from global
49: variables from file-scope variables from parameters from auto
50: variables in memory from typedef names from register variables.
51: See `dbxout_symbol'.
52:
53: The "code" is mostly redundant with the kind-of-symbol letter
54: that goes in the "name", but not entirely: for symbols located
55: in static storage, the "code" says which segment the address is in,
56: which controls how it is relocated.
57:
58: The "value" for a symbol in static storage
59: is the core address of the symbol (actually, the assembler
60: label for the symbol). For a symbol located in a stack slot
61: it is the stack offset; for one in a register, the register number.
62: For a typedef symbol, it is zero.
63:
64: If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65: output while in the text section.
66:
67: For more on data type definitions, see `dbxout_type'. */
68:
69: /* Include these first, because they may define MIN and MAX. */
70: #include <stdio.h>
71: #include <errno.h>
72:
73: #include "config.h"
74: #include "tree.h"
75: #include "rtl.h"
76: #include "flags.h"
77: #include "regs.h"
78: #include "insn-config.h"
79: #include "reload.h"
80: #include "defaults.h"
81: #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
82:
83: #ifndef errno
84: extern int errno;
85: #endif
86:
87: #ifdef XCOFF_DEBUGGING_INFO
88: #include "xcoffout.h"
89: #endif
90:
91: #ifndef ASM_STABS_OP
92: #define ASM_STABS_OP ".stabs"
93: #endif
94:
95: #ifndef ASM_STABN_OP
96: #define ASM_STABN_OP ".stabn"
97: #endif
98:
99: #ifndef DBX_TYPE_DECL_STABS_CODE
100: #define DBX_TYPE_DECL_STABS_CODE N_LSYM
101: #endif
102:
103: #ifndef DBX_STATIC_CONST_VAR_CODE
104: #define DBX_STATIC_CONST_VAR_CODE N_FUN
105: #endif
106:
107: #ifndef DBX_REGPARM_STABS_CODE
108: #define DBX_REGPARM_STABS_CODE N_RSYM
109: #endif
110:
111: #ifndef DBX_REGPARM_STABS_LETTER
112: #define DBX_REGPARM_STABS_LETTER 'P'
113: #endif
114:
115: #ifndef DBX_MEMPARM_STABS_LETTER
116: #define DBX_MEMPARM_STABS_LETTER 'p'
117: #endif
118:
119: #ifndef FILE_NAME_JOINER
120: #define FILE_NAME_JOINER "/"
121: #endif
122:
123: /* Nonzero means if the type has methods, only output debugging
124: information if methods are actually written to the asm file. */
125:
126: static int flag_minimal_debug = 1;
127:
128: /* Nonzero if we have actually used any of the GDB extensions
129: to the debugging format. The idea is that we use them for the
130: first time only if there's a strong reason, but once we have done that,
131: we use them whenever convenient. */
132:
133: static int have_used_extensions = 0;
134:
135: char *getpwd ();
136:
137: /* Typical USG systems don't have stab.h, and they also have
138: no use for DBX-format debugging info. */
139:
140: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
141:
142: #ifdef DEBUG_SYMS_TEXT
143: #define FORCE_TEXT text_section ();
144: #else
145: #define FORCE_TEXT
146: #endif
147:
148: #if defined (USG) || defined (NO_STAB_H)
149: #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
150: #else
151: #include <stab.h> /* On BSD, use the system's stab.h. */
152:
153: /* This is a GNU extension we need to reference in this file. */
154: #ifndef N_CATCH
155: #define N_CATCH 0x54
156: #endif
157: #endif /* not USG */
158:
159: #ifdef __GNU_STAB__
160: #define STAB_CODE_TYPE enum __stab_debug_code
161: #else
162: #define STAB_CODE_TYPE int
163: #endif
164:
165: /* 1 if PARM is passed to this function in memory. */
166:
167: #define PARM_PASSED_IN_MEMORY(PARM) \
168: (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
169:
170: /* A C expression for the integer offset value of an automatic variable
171: (N_LSYM) having address X (an RTX). */
172: #ifndef DEBUGGER_AUTO_OFFSET
173: #define DEBUGGER_AUTO_OFFSET(X) \
174: (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
175: #endif
176:
177: /* A C expression for the integer offset value of an argument (N_PSYM)
178: having address X (an RTX). The nominal offset is OFFSET. */
179: #ifndef DEBUGGER_ARG_OFFSET
180: #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
181: #endif
182:
183: /* Stream for writing to assembler file. */
184:
185: static FILE *asmfile;
186:
187: /* Last source file name mentioned in a NOTE insn. */
188:
189: static char *lastfile;
190:
191: /* Current working directory. */
192:
193: static char *cwd;
194:
195: enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
196:
197: /* Vector recording the status of describing C data types.
198: When we first notice a data type (a tree node),
199: we assign it a number using next_type_number.
200: That is its index in this vector.
201: The vector element says whether we have yet output
202: the definition of the type. TYPE_XREF says we have
203: output it as a cross-reference only. */
204:
205: enum typestatus *typevec;
206:
207: /* Number of elements of space allocated in `typevec'. */
208:
209: static int typevec_len;
210:
211: /* In dbx output, each type gets a unique number.
212: This is the number for the next type output.
213: The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
214:
215: static int next_type_number;
216:
217: /* In dbx output, we must assign symbol-blocks id numbers
218: in the order in which their beginnings are encountered.
219: We output debugging info that refers to the beginning and
220: end of the ranges of code in each block
221: with assembler labels LBBn and LBEn, where n is the block number.
222: The labels are generated in final, which assigns numbers to the
223: blocks in the same way. */
224:
225: static int next_block_number;
226:
227: /* These variables are for dbxout_symbol to communicate to
228: dbxout_finish_symbol.
229: current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
230: current_sym_value and current_sym_addr are two ways to address the
231: value to store in the symtab entry.
232: current_sym_addr if nonzero represents the value as an rtx.
233: If that is zero, current_sym_value is used. This is used
234: when the value is an offset (such as for auto variables,
235: register variables and parms). */
236:
237: static STAB_CODE_TYPE current_sym_code;
238: static int current_sym_value;
239: static rtx current_sym_addr;
240:
241: /* Number of chars of symbol-description generated so far for the
242: current symbol. Used by CHARS and CONTIN. */
243:
244: static int current_sym_nchars;
245:
246: /* Report having output N chars of the current symbol-description. */
247:
248: #define CHARS(N) (current_sym_nchars += (N))
249:
250: /* Break the current symbol-description, generating a continuation,
251: if it has become long. */
252:
253: #ifndef DBX_CONTIN_LENGTH
254: #define DBX_CONTIN_LENGTH 80
255: #endif
256:
257: #if DBX_CONTIN_LENGTH > 0
258: #define CONTIN \
259: do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
260: #else
261: #define CONTIN
262: #endif
263:
264: void dbxout_types ();
265: void dbxout_args ();
266: void dbxout_symbol ();
267: static void dbxout_type_name ();
268: static void dbxout_type ();
269: static void dbxout_typedefs ();
270: static void dbxout_symbol_name ();
271: static void dbxout_symbol_location ();
272: static void dbxout_prepare_symbol ();
273: static void dbxout_finish_symbol ();
274: static void dbxout_continue ();
275: static void print_int_cst_octal ();
276: static void print_octal ();
277:
278: #if 0 /* Not clear we will actually need this. */
279:
280: /* Return the absolutized filename for the given relative
281: filename. Note that if that filename is already absolute, it may
282: still be returned in a modified form because this routine also
283: eliminates redundant slashes and single dots and eliminates double
284: dots to get a shortest possible filename from the given input
285: filename. The absolutization of relative filenames is made by
286: assuming that the given filename is to be taken as relative to
287: the first argument (cwd) or to the current directory if cwd is
288: NULL. */
289:
290: static char *
291: abspath (rel_filename)
292: char *rel_filename;
293: {
294: /* Setup the current working directory as needed. */
295: char *abs_buffer
296: = (char *) alloca (strlen (cwd) + strlen (rel_filename) + 1);
297: char *endp = abs_buffer;
298: char *outp, *inp;
299: char *value;
300:
301: /* Copy the filename (possibly preceded by the current working
302: directory name) into the absolutization buffer. */
303:
304: {
305: char *src_p;
306:
307: if (rel_filename[0] != '/')
308: {
309: src_p = cwd;
310: while (*endp++ = *src_p++)
311: continue;
312: *(endp-1) = '/'; /* overwrite null */
313: }
314: src_p = rel_filename;
315: while (*endp++ = *src_p++)
316: continue;
317: if (endp[-1] == '/')
318: *endp = '\0';
319:
320: /* Now make a copy of abs_buffer into abs_buffer, shortening the
321: filename (by taking out slashes and dots) as we go. */
322:
323: outp = inp = abs_buffer;
324: *outp++ = *inp++; /* copy first slash */
325: for (;;)
326: {
327: if (!inp[0])
328: break;
329: else if (inp[0] == '/' && outp[-1] == '/')
330: {
331: inp++;
332: continue;
333: }
334: else if (inp[0] == '.' && outp[-1] == '/')
335: {
336: if (!inp[1])
337: break;
338: else if (inp[1] == '/')
339: {
340: inp += 2;
341: continue;
342: }
343: else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
344: {
345: inp += (inp[2] == '/') ? 3 : 2;
346: outp -= 2;
347: while (outp >= abs_buffer && *outp != '/')
348: outp--;
349: if (outp < abs_buffer)
350: {
351: /* Catch cases like /.. where we try to backup to a
352: point above the absolute root of the logical file
353: system. */
354:
355: fprintf (stderr, "%s: invalid file name: %s\n",
356: pname, rel_filename);
357: exit (1);
358: }
359: *++outp = '\0';
360: continue;
361: }
362: }
363: *outp++ = *inp++;
364: }
365:
366: /* On exit, make sure that there is a trailing null, and make sure that
367: the last character of the returned string is *not* a slash. */
368:
369: *outp = '\0';
370: if (outp[-1] == '/')
371: *--outp = '\0';
372:
373: /* Make a copy (in the heap) of the stuff left in the absolutization
374: buffer and return a pointer to the copy. */
375:
376: value = (char *) oballoc (strlen (abs_buffer) + 1);
377: strcpy (value, abs_buffer);
378: return value;
379: }
380: #endif /* 0 */
381:
382: /* At the beginning of compilation, start writing the symbol table.
383: Initialize `typevec' and output the standard data types of C. */
384:
385: void
386: dbxout_init (asm_file, input_file_name, syms)
387: FILE *asm_file;
388: char *input_file_name;
389: tree syms;
390: {
391: char ltext_label_name[100];
392:
393: asmfile = asm_file;
394:
395: typevec_len = 100;
396: typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
397: bzero (typevec, typevec_len * sizeof typevec[0]);
398:
399: /* Convert Ltext into the appropriate format for local labels in case
400: the system doesn't insert underscores in front of user generated
401: labels. */
402: ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
403:
404: /* Put the current working directory in an N_SO symbol. */
405: #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
406: but GDB always does. */
407: if (use_gnu_debug_info_extensions)
408: #endif
409: {
410: if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
411: {
412: char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
413: sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
414: cwd = wdslash;
415: }
416: if (cwd)
417: {
418: #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
419: DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
420: #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
421: fprintf (asmfile, "%s ", ASM_STABS_OP);
422: output_quoted_string (asmfile, cwd);
423: fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
424: #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
425: }
426: }
427:
428: #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
429: /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
430: would give us an N_SOL, and we want an N_SO. */
431: DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
432: #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
433: /* We include outputting `Ltext:' here,
434: because that gives you a way to override it. */
435: /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
436: fprintf (asmfile, "%s ", ASM_STABS_OP);
437: output_quoted_string (asmfile, input_file_name);
438: fprintf (asmfile, ",%d,0,0,%s\n",
439: N_SO, <ext_label_name[1]);
440: text_section ();
441: ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
442: #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
443:
444: /* Possibly output something to inform GDB that this compilation was by
445: GCC. It's easier for GDB to parse it when after the N_SO's. This
446: is used in Solaris 2. */
447: #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
448: ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
449: #endif
450:
451: lastfile = input_file_name;
452:
453: next_type_number = 1;
454: next_block_number = 2;
455:
456: /* Make sure that types `int' and `char' have numbers 1 and 2.
457: Definitions of other integer types will refer to those numbers.
458: (Actually it should no longer matter what their numbers are.
459: Also, if any types with tags have been defined, dbxout_symbol
460: will output them first, so the numbers won't be 1 and 2. That
461: happens in C++. So it's a good thing it should no longer matter). */
462:
463: #ifdef DBX_OUTPUT_STANDARD_TYPES
464: DBX_OUTPUT_STANDARD_TYPES (syms);
465: #else
466: dbxout_symbol (TYPE_NAME (integer_type_node), 0);
467: dbxout_symbol (TYPE_NAME (char_type_node), 0);
468: #endif
469:
470: /* Get all permanent types that have typedef names,
471: and output them all, except for those already output. */
472:
473: dbxout_typedefs (syms);
474: }
475:
476: /* Output any typedef names for types described by TYPE_DECLs in SYMS,
477: in the reverse order from that which is found in SYMS. */
478:
479: static void
480: dbxout_typedefs (syms)
481: tree syms;
482: {
483: if (syms)
484: {
485: dbxout_typedefs (TREE_CHAIN (syms));
486: if (TREE_CODE (syms) == TYPE_DECL)
487: {
488: tree type = TREE_TYPE (syms);
489: if (TYPE_NAME (type)
490: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
491: && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
492: dbxout_symbol (TYPE_NAME (type), 0);
493: }
494: }
495: }
496:
497: /* Output debugging info to FILE to switch to sourcefile FILENAME. */
498:
499: void
500: dbxout_source_file (file, filename)
501: FILE *file;
502: char *filename;
503: {
504: char ltext_label_name[100];
505:
506: if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
507: {
508: #ifdef DBX_OUTPUT_SOURCE_FILENAME
509: DBX_OUTPUT_SOURCE_FILENAME (file, filename);
510: #else
511: ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
512: fprintf (file, "%s ", ASM_STABS_OP);
513: output_quoted_string (file, filename);
514: fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
515: #endif
516: lastfile = filename;
517: }
518: }
519:
520: /* Output a line number symbol entry into output stream FILE,
521: for source file FILENAME and line number LINENO. */
522:
523: void
524: dbxout_source_line (file, filename, lineno)
525: FILE *file;
526: char *filename;
527: int lineno;
528: {
529: dbxout_source_file (file, filename);
530:
531: #ifdef ASM_OUTPUT_SOURCE_LINE
532: ASM_OUTPUT_SOURCE_LINE (file, lineno);
533: #else
534: fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
535: #endif
536: }
537:
538: /* At the end of compilation, finish writing the symbol table.
539: Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
540: to do nothing. */
541:
542: void
543: dbxout_finish (file, filename)
544: FILE *file;
545: char *filename;
546: {
547: #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
548: DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
549: #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
550: }
551:
552: /* Continue a symbol-description that gets too big.
553: End one symbol table entry with a double-backslash
554: and start a new one, eventually producing something like
555: .stabs "start......\\",code,0,value
556: .stabs "...rest",code,0,value */
557:
558: static void
559: dbxout_continue ()
560: {
561: #ifdef DBX_CONTIN_CHAR
562: fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
563: #else
564: fprintf (asmfile, "\\\\");
565: #endif
566: dbxout_finish_symbol (NULL_TREE);
567: fprintf (asmfile, "%s \"", ASM_STABS_OP);
568: current_sym_nchars = 0;
569: }
570:
571: /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
572: This must be a separate function because anonymous unions require
573: recursive calls. */
574:
575: static void
576: dbxout_type_fields (type)
577: tree type;
578: {
579: tree tem;
580: /* Output the name, type, position (in bits), size (in bits) of each
581: field. */
582: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
583: {
584: /* For nameless subunions and subrecords, treat their fields as ours. */
585: if (DECL_NAME (tem) == NULL_TREE
586: && (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
587: || TREE_CODE (TREE_TYPE (tem)) == QUAL_UNION_TYPE
588: || TREE_CODE (TREE_TYPE (tem)) == RECORD_TYPE))
589: dbxout_type_fields (TREE_TYPE (tem));
590: /* Omit here local type decls until we know how to support them. */
591: else if (TREE_CODE (tem) == TYPE_DECL)
592: continue;
593: /* Omit fields whose position or size are variable. */
594: else if (TREE_CODE (tem) == FIELD_DECL
595: && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
596: || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
597: continue;
598: /* Omit here the nameless fields that are used to skip bits. */
599: else if (DECL_NAME (tem) != 0 && TREE_CODE (tem) != CONST_DECL)
600: {
601: /* Continue the line if necessary,
602: but not before the first field. */
603: if (tem != TYPE_FIELDS (type))
604: CONTIN;
605:
606: if (use_gnu_debug_info_extensions
607: && flag_minimal_debug
608: && TREE_CODE (tem) == FIELD_DECL
609: && DECL_VIRTUAL_P (tem)
610: && DECL_ASSEMBLER_NAME (tem))
611: {
612: have_used_extensions = 1;
613: CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem)))));
614: fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
615: dbxout_type (DECL_FCONTEXT (tem), 0, 0);
616: fprintf (asmfile, ":");
617: dbxout_type (TREE_TYPE (tem), 0, 0);
618: fprintf (asmfile, ",%d;",
619: TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
620: continue;
621: }
622:
623: fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
624: CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
625:
626: if (use_gnu_debug_info_extensions
627: && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
628: || TREE_CODE (tem) != FIELD_DECL))
629: {
630: have_used_extensions = 1;
631: putc ('/', asmfile);
632: putc ((TREE_PRIVATE (tem) ? '0'
633: : TREE_PROTECTED (tem) ? '1' : '2'),
634: asmfile);
635: CHARS (2);
636: }
637:
638: dbxout_type ((TREE_CODE (tem) == FIELD_DECL
639: && DECL_BIT_FIELD_TYPE (tem))
640: ? DECL_BIT_FIELD_TYPE (tem)
641: : TREE_TYPE (tem), 0, 0);
642:
643: if (TREE_CODE (tem) == VAR_DECL)
644: {
645: if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
646: {
647: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
648: have_used_extensions = 1;
649: fprintf (asmfile, ":%s;", name);
650: CHARS (strlen (name));
651: }
652: else
653: {
654: /* If TEM is non-static, GDB won't understand it. */
655: fprintf (asmfile, ",0,0;");
656: }
657: }
658: else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
659: {
660: fprintf (asmfile, ",%d,%d;",
661: TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
662: TREE_INT_CST_LOW (DECL_SIZE (tem)));
663: }
664: CHARS (23);
665: }
666: }
667: }
668:
669: /* Subroutine of `dbxout_type_methods'. Output debug info about the
670: method described DECL. DEBUG_NAME is an encoding of the method's
671: type signature. ??? We may be able to do without DEBUG_NAME altogether
672: now. */
673:
674: static void
675: dbxout_type_method_1 (decl, debug_name)
676: tree decl;
677: char *debug_name;
678: {
679: tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
680: char c1 = 'A', c2;
681:
682: if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
683: c2 = '?';
684: else /* it's a METHOD_TYPE. */
685: {
686: /* A for normal functions.
687: B for `const' member functions.
688: C for `volatile' member functions.
689: D for `const volatile' member functions. */
690: if (TYPE_READONLY (TREE_TYPE (firstarg)))
691: c1 += 1;
692: if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
693: c1 += 2;
694:
695: if (DECL_VINDEX (decl))
696: c2 = '*';
697: else
698: c2 = '.';
699: }
700:
701: fprintf (asmfile, ":%s;%c%c%c", debug_name,
702: TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
703: CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
704: - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
705: if (DECL_VINDEX (decl))
706: {
707: fprintf (asmfile, "%d;",
708: TREE_INT_CST_LOW (DECL_VINDEX (decl)));
709: dbxout_type (DECL_CONTEXT (decl), 0, 0);
710: fprintf (asmfile, ";");
711: CHARS (8);
712: }
713: }
714:
715: /* Subroutine of `dbxout_type'. Output debug info about the methods defined
716: in TYPE. */
717:
718: static void
719: dbxout_type_methods (type)
720: register tree type;
721: {
722: /* C++: put out the method names and their parameter lists */
723: tree methods = TYPE_METHODS (type);
724: tree type_encoding;
725: register tree fndecl;
726: register tree last;
727: char formatted_type_identifier_length[16];
728: register int type_identifier_length;
729:
730: if (methods == NULL_TREE)
731: return;
732:
733: type_encoding = DECL_NAME (TYPE_NAME (type));
734:
735: /* C++: Template classes break some assumptions made by this code about
736: the class names, constructor names, and encodings for assembler
737: label names. For now, disable output of dbx info for them. */
738: {
739: char *ptr = IDENTIFIER_POINTER (type_encoding);
740: /* This should use index. (mrs) */
741: while (*ptr && *ptr != '<') ptr++;
742: if (*ptr != 0)
743: {
744: static int warned;
745: if (!warned)
746: {
747: warned = 1;
748: #ifdef HAVE_TEMPLATES
749: if (warn_template_debugging)
750: warning ("dbx info for template class methods not yet supported");
751: #endif
752: }
753: return;
754: }
755: }
756:
757: type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
758:
759: sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
760:
761: if (TREE_CODE (methods) == FUNCTION_DECL)
762: fndecl = methods;
763: else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
764: fndecl = TREE_VEC_ELT (methods, 0);
765: else
766: fndecl = TREE_VEC_ELT (methods, 1);
767:
768: while (fndecl)
769: {
770: tree name = DECL_NAME (fndecl);
771: int need_prefix = 1;
772:
773: /* Group together all the methods for the same operation.
774: These differ in the types of the arguments. */
775: for (last = NULL_TREE;
776: fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
777: fndecl = TREE_CHAIN (fndecl))
778: /* Output the name of the field (after overloading), as
779: well as the name of the field before overloading, along
780: with its parameter list */
781: {
782: /* This is the "mangled" name of the method.
783: It encodes the argument types. */
784: char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
785: int destructor = 0;
786:
787: CONTIN;
788:
789: last = fndecl;
790:
791: if (DECL_IGNORED_P (fndecl))
792: continue;
793:
794: if (flag_minimal_debug)
795: {
796: /* Detect ordinary methods because their mangled names
797: start with the operation name. */
798: if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
799: IDENTIFIER_LENGTH (name)))
800: {
801: debug_name += IDENTIFIER_LENGTH (name);
802: if (debug_name[0] == '_' && debug_name[1] == '_')
803: {
804: char *method_name = debug_name + 2;
805: char *length_ptr = formatted_type_identifier_length;
806: /* Get past const and volatile qualifiers. */
807: while (*method_name == 'C' || *method_name == 'V')
808: method_name++;
809: /* Skip digits for length of type_encoding. */
810: while (*method_name == *length_ptr && *length_ptr)
811: length_ptr++, method_name++;
812: if (! strncmp (method_name,
813: IDENTIFIER_POINTER (type_encoding),
814: type_identifier_length))
815: method_name += type_identifier_length;
816: debug_name = method_name;
817: }
818: }
819: /* Detect constructors by their style of name mangling. */
820: else if (debug_name[0] == '_' && debug_name[1] == '_')
821: {
822: char *ctor_name = debug_name + 2;
823: char *length_ptr = formatted_type_identifier_length;
824: while (*ctor_name == 'C' || *ctor_name == 'V')
825: ctor_name++;
826: /* Skip digits for length of type_encoding. */
827: while (*ctor_name == *length_ptr && *length_ptr)
828: length_ptr++, ctor_name++;
829: if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
830: type_identifier_length))
831: debug_name = ctor_name + type_identifier_length;
832: }
833: /* The other alternative is a destructor. */
834: else
835: destructor = 1;
836:
837: /* Output the operation name just once, for the first method
838: that we output. */
839: if (need_prefix)
840: {
841: fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
842: CHARS (IDENTIFIER_LENGTH (name) + 2);
843: need_prefix = 0;
844: }
845: }
846:
847: dbxout_type (TREE_TYPE (fndecl), 0, destructor);
848:
849: dbxout_type_method_1 (fndecl, debug_name);
850: }
851: if (!need_prefix)
852: {
853: putc (';', asmfile);
854: CHARS (1);
855: }
856: }
857: }
858:
859: /* Emit a "range" type specification, which has the form:
860: "r<index type>;<lower bound>;<upper bound>;".
861: TYPE is an INTEGER_TYPE. */
862:
863: static void
864: dbxout_range_type (type)
865: tree type;
866: {
867: fprintf (asmfile, "r");
868: if (TREE_TYPE (type) && TREE_CODE (TREE_TYPE(type)) != INTEGER_TYPE)
869: dbxout_type (TREE_TYPE (type), 0, 0);
870: else
871: {
872: /* This used to say `r1' and we used to take care
873: to make sure that `int' was type number 1. */
874: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node));
875: }
876: if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
877: fprintf (asmfile, ";%d",
878: TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
879: else
880: fprintf (asmfile, ";0");
881: if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
882: fprintf (asmfile, ";%d;",
883: TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
884: else
885: fprintf (asmfile, ";-1;");
886: }
887:
888: /* Output a reference to a type. If the type has not yet been
889: described in the dbx output, output its definition now.
890: For a type already defined, just refer to its definition
891: using the type number.
892:
893: If FULL is nonzero, and the type has been described only with
894: a forward-reference, output the definition now.
895: If FULL is zero in this case, just refer to the forward-reference
896: using the number previously allocated.
897:
898: If SHOW_ARG_TYPES is nonzero, we output a description of the argument
899: types for a METHOD_TYPE. */
900:
901: static void
902: dbxout_type (type, full, show_arg_types)
903: tree type;
904: int full;
905: int show_arg_types;
906: {
907: register tree tem;
908: static int anonymous_type_number = 0;
909:
910: /* If there was an input error and we don't really have a type,
911: avoid crashing and write something that is at least valid
912: by assuming `int'. */
913: if (type == error_mark_node)
914: type = integer_type_node;
915: else
916: {
917: type = TYPE_MAIN_VARIANT (type);
918: if (TYPE_NAME (type)
919: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
920: && DECL_IGNORED_P (TYPE_NAME (type)))
921: full = 0;
922: }
923:
924: if (TYPE_SYMTAB_ADDRESS (type) == 0)
925: {
926: /* Type has no dbx number assigned. Assign next available number. */
927: TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
928:
929: /* Make sure type vector is long enough to record about this type. */
930:
931: if (next_type_number == typevec_len)
932: {
933: typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
934: bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]);
935: typevec_len *= 2;
936: }
937: }
938:
939: /* Output the number of this type, to refer to it. */
940: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
941: CHARS (3);
942:
943: #ifdef DBX_TYPE_DEFINED
944: if (DBX_TYPE_DEFINED (type))
945: return;
946: #endif
947:
948: /* If this type's definition has been output or is now being output,
949: that is all. */
950:
951: switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
952: {
953: case TYPE_UNSEEN:
954: break;
955: case TYPE_XREF:
956: /* If we have already had a cross reference,
957: and either that's all we want or that's the best we could do,
958: don't repeat the cross reference.
959: Sun dbx crashes if we do. */
960: if (! full || TYPE_SIZE (type) == 0
961: /* No way in DBX fmt to describe a variable size. */
962: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
963: return;
964: break;
965: case TYPE_DEFINED:
966: return;
967: }
968:
969: #ifdef DBX_NO_XREFS
970: /* For systems where dbx output does not allow the `=xsNAME:' syntax,
971: leave the type-number completely undefined rather than output
972: a cross-reference. */
973: if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
974: || TREE_CODE (type) == QUAL_UNION_TYPE
975: || TREE_CODE (type) == ENUMERAL_TYPE)
976:
977: if ((TYPE_NAME (type) != 0 && !full)
978: || TYPE_SIZE (type) == 0)
979: {
980: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
981: return;
982: }
983: #endif
984:
985: /* Output a definition now. */
986:
987: fprintf (asmfile, "=");
988: CHARS (1);
989:
990: /* Mark it as defined, so that if it is self-referent
991: we will not get into an infinite recursion of definitions. */
992:
993: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
994:
995: switch (TREE_CODE (type))
996: {
997: case VOID_TYPE:
998: case LANG_TYPE:
999: /* For a void type, just define it as itself; ie, "5=5".
1000: This makes us consider it defined
1001: without saying what it is. The debugger will make it
1002: a void type when the reference is seen, and nothing will
1003: ever override that default. */
1004: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
1005: CHARS (3);
1006: break;
1007:
1008: case INTEGER_TYPE:
1009: if (type == char_type_node && ! TREE_UNSIGNED (type))
1010: /* Output the type `char' as a subrange of itself!
1011: I don't understand this definition, just copied it
1012: from the output of pcc.
1013: This used to use `r2' explicitly and we used to
1014: take care to make sure that `char' was type number 2. */
1015: fprintf (asmfile, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type));
1016: else if (use_gnu_debug_info_extensions
1017: && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1018: || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
1019: {
1020: /* This used to say `r1' and we used to take care
1021: to make sure that `int' was type number 1. */
1022: fprintf (asmfile, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node));
1023: print_int_cst_octal (TYPE_MIN_VALUE (type));
1024: fprintf (asmfile, ";");
1025: print_int_cst_octal (TYPE_MAX_VALUE (type));
1026: fprintf (asmfile, ";");
1027: }
1028: else /* Output other integer types as subranges of `int'. */
1029: dbxout_range_type (type);
1030: CHARS (25);
1031: break;
1032:
1033: case REAL_TYPE:
1034: /* This used to say `r1' and we used to take care
1035: to make sure that `int' was type number 1. */
1036: fprintf (asmfile, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node),
1037: int_size_in_bytes (type));
1038: CHARS (16);
1039: break;
1040:
1041: case CHAR_TYPE:
1042: if (use_gnu_debug_info_extensions)
1043: fprintf (asmfile, "@s%d;-20;",
1044: BITS_PER_UNIT * int_size_in_bytes (type));
1045: else
1046: /* Output the type `char' as a subrange of itself.
1047: That is what pcc seems to do. */
1048: fprintf (asmfile, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node),
1049: TREE_UNSIGNED (type) ? 255 : 127);
1050: CHARS (9);
1051: break;
1052:
1053: case BOOLEAN_TYPE:
1054: if (use_gnu_debug_info_extensions)
1055: fprintf (asmfile, "@s%d;-16;",
1056: BITS_PER_UNIT * int_size_in_bytes (type));
1057: else /* Define as enumeral type (False, True) */
1058: fprintf (asmfile, "eFalse:0,True:1,;");
1059: CHARS (17);
1060: break;
1061:
1062: case FILE_TYPE:
1063: putc ('d', asmfile);
1064: CHARS (1);
1065: dbxout_type (TREE_TYPE (type), 0, 0);
1066: break;
1067:
1068: case COMPLEX_TYPE:
1069: /* Differs from the REAL_TYPE by its new data type number */
1070:
1071: if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1072: {
1073: fprintf (asmfile, "r%d;%d;0;",
1074: TYPE_SYMTAB_ADDRESS (type),
1075: int_size_in_bytes (TREE_TYPE (type)));
1076: CHARS (15); /* The number is probably incorrect here. */
1077: }
1078: else
1079: {
1080: /* Output a complex integer type as a structure,
1081: pending some other way to do it. */
1082: fprintf (asmfile, "s%d", int_size_in_bytes (type));
1083:
1084: fprintf (asmfile, "real:");
1085: CHARS (10);
1086: dbxout_type (TREE_TYPE (type), 0, 0);
1087: fprintf (asmfile, ",%d,%d;",
1088: 0, TYPE_PRECISION (TREE_TYPE (type)));
1089: CHARS (8);
1090: fprintf (asmfile, "imag:");
1091: CHARS (5);
1092: dbxout_type (TREE_TYPE (type), 0, 0);
1093: fprintf (asmfile, ",%d,%d;;",
1094: TYPE_PRECISION (TREE_TYPE (type)),
1095: TYPE_PRECISION (TREE_TYPE (type)));
1096: CHARS (9);
1097: }
1098: break;
1099:
1100: case SET_TYPE:
1101: putc ('S', asmfile);
1102: CHARS (1);
1103: dbxout_type (TYPE_DOMAIN (type), 0, 0);
1104: break;
1105:
1106: case ARRAY_TYPE:
1107: /* Output "a" followed by a range type definition
1108: for the index type of the array
1109: followed by a reference to the target-type.
1110: ar1;0;N;M for a C array of type M and size N+1. */
1111: tem = TYPE_DOMAIN (type);
1112: if (tem == NULL)
1113: fprintf (asmfile, "ar%d;0;-1;",
1114: TYPE_SYMTAB_ADDRESS (integer_type_node));
1115: else
1116: {
1117: fprintf (asmfile, "a");
1118: dbxout_range_type (tem);
1119: }
1120: CHARS (17);
1121: dbxout_type (TREE_TYPE (type), 0, 0);
1122: break;
1123:
1124: case RECORD_TYPE:
1125: case UNION_TYPE:
1126: case QUAL_UNION_TYPE:
1127: {
1128: int i, n_baseclasses = 0;
1129:
1130: if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1131: n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1132:
1133: /* Output a structure type. */
1134: if ((TYPE_NAME (type) != 0
1135: /* Long ago, Tiemann said this creates output that "confuses GDB".
1136: In April 93, [email protected] said there is no such problem.
1137: The type decls made automatically by struct specifiers
1138: are marked with DECL_IGNORED_P in C++. */
1139: #if 0 /* This creates output for anonymous classes which confuses GDB. */
1140: && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1141: && DECL_IGNORED_P (TYPE_NAME (type)))
1142: #endif
1143: && !full)
1144: || TYPE_SIZE (type) == 0
1145: /* No way in DBX fmt to describe a variable size. */
1146: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1147: {
1148: /* If the type is just a cross reference, output one
1149: and mark the type as partially described.
1150: If it later becomes defined, we will output
1151: its real definition.
1152: If the type has a name, don't nest its definition within
1153: another type's definition; instead, output an xref
1154: and let the definition come when the name is defined. */
1155: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1156: CHARS (3);
1157: #if 0 /* This assertion is legitimately false in C++. */
1158: /* We shouldn't be outputting a reference to a type before its
1159: definition unless the type has a tag name.
1160: A typedef name without a tag name should be impossible. */
1161: if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1162: abort ();
1163: #endif
1164: if (TYPE_NAME (type) != 0)
1165: dbxout_type_name (type);
1166: else
1167: fprintf (asmfile, "$$%d", anonymous_type_number++);
1168: fprintf (asmfile, ":");
1169: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1170: break;
1171: }
1172:
1173: /* Identify record or union, and print its size. */
1174: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1175: int_size_in_bytes (type));
1176:
1177: if (use_gnu_debug_info_extensions)
1178: {
1179: if (n_baseclasses)
1180: {
1181: have_used_extensions = 1;
1182: fprintf (asmfile, "!%d,", n_baseclasses);
1183: CHARS (8);
1184: }
1185: }
1186: for (i = 0; i < n_baseclasses; i++)
1187: {
1188: tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1189: if (use_gnu_debug_info_extensions)
1190: {
1191: have_used_extensions = 1;
1192: putc (TREE_VIA_VIRTUAL (child) ? '1'
1193: : '0',
1194: asmfile);
1195: putc (TREE_VIA_PUBLIC (child) ? '2'
1196: : '0',
1197: asmfile);
1198: fprintf (asmfile, "%d,",
1199: TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1200: CHARS (15);
1201: dbxout_type (BINFO_TYPE (child), 0, 0);
1202: putc (';', asmfile);
1203: }
1204: else
1205: {
1206: /* Print out the base class information with fields
1207: which have the same names at the types they hold. */
1208: dbxout_type_name (BINFO_TYPE (child));
1209: putc (':', asmfile);
1210: dbxout_type (BINFO_TYPE (child), full, 0);
1211: fprintf (asmfile, ",%d,%d;",
1212: TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1213: TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1214: CHARS (20);
1215: }
1216: }
1217: }
1218:
1219: CHARS (11);
1220:
1221: /* Write out the field declarations. */
1222: dbxout_type_fields (type);
1223: if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1224: {
1225: have_used_extensions = 1;
1226: dbxout_type_methods (type);
1227: }
1228: putc (';', asmfile);
1229:
1230: if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1231: /* Avoid the ~ if we don't really need it--it confuses dbx. */
1232: && TYPE_VFIELD (type))
1233: {
1234: have_used_extensions = 1;
1235:
1236: /* Tell GDB+ that it may keep reading. */
1237: putc ('~', asmfile);
1238:
1239: /* We need to write out info about what field this class
1240: uses as its "main" vtable pointer field, because if this
1241: field is inherited from a base class, GDB cannot necessarily
1242: figure out which field it's using in time. */
1243: if (TYPE_VFIELD (type))
1244: {
1245: putc ('%', asmfile);
1246: dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1247: }
1248: putc (';', asmfile);
1249: CHARS (3);
1250: }
1251: break;
1252:
1253: case ENUMERAL_TYPE:
1254: if ((TYPE_NAME (type) != 0 && !full
1255: && (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1256: && ! DECL_IGNORED_P (TYPE_NAME (type))))
1257: || TYPE_SIZE (type) == 0)
1258: {
1259: fprintf (asmfile, "xe");
1260: CHARS (3);
1261: dbxout_type_name (type);
1262: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1263: fprintf (asmfile, ":");
1264: return;
1265: }
1266: #ifdef DBX_OUTPUT_ENUM
1267: DBX_OUTPUT_ENUM (asmfile, type);
1268: #else
1269: putc ('e', asmfile);
1270: CHARS (1);
1271: for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1272: {
1273: fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1274: if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1275: fprintf (asmfile, "%lu",
1276: (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1277: else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1278: && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1279: fprintf (asmfile, "%ld",
1280: (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1281: else
1282: print_int_cst_octal (TREE_VALUE (tem));
1283: fprintf (asmfile, ",");
1284: CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1285: if (TREE_CHAIN (tem) != 0)
1286: CONTIN;
1287: }
1288: putc (';', asmfile);
1289: CHARS (1);
1290: #endif
1291: break;
1292:
1293: case POINTER_TYPE:
1294: putc ('*', asmfile);
1295: CHARS (1);
1296: dbxout_type (TREE_TYPE (type), 0, 0);
1297: break;
1298:
1299: case METHOD_TYPE:
1300: if (use_gnu_debug_info_extensions)
1301: {
1302: have_used_extensions = 1;
1303: putc ('#', asmfile);
1304: CHARS (1);
1305: if (flag_minimal_debug && !show_arg_types)
1306: {
1307: /* Normally, just output the return type.
1308: The argument types are encoded in the method name. */
1309: putc ('#', asmfile);
1310: dbxout_type (TREE_TYPE (type), 0, 0);
1311: putc (';', asmfile);
1312: CHARS (1);
1313: }
1314: else
1315: {
1316: /* When outputting destructors, we need to write
1317: the argument types out longhand. */
1318: dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1319: putc (',', asmfile);
1320: CHARS (1);
1321: dbxout_type (TREE_TYPE (type), 0, 0);
1322: dbxout_args (TYPE_ARG_TYPES (type));
1323: putc (';', asmfile);
1324: CHARS (1);
1325: }
1326: }
1327: else
1328: {
1329: /* Treat it as a function type. */
1330: dbxout_type (TREE_TYPE (type), 0, 0);
1331: }
1332: break;
1333:
1334: case OFFSET_TYPE:
1335: if (use_gnu_debug_info_extensions)
1336: {
1337: have_used_extensions = 1;
1338: putc ('@', asmfile);
1339: CHARS (1);
1340: dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1341: putc (',', asmfile);
1342: CHARS (1);
1343: dbxout_type (TREE_TYPE (type), 0, 0);
1344: }
1345: else
1346: {
1347: /* Should print as an int, because it is really
1348: just an offset. */
1349: dbxout_type (integer_type_node, 0, 0);
1350: }
1351: break;
1352:
1353: case REFERENCE_TYPE:
1354: if (use_gnu_debug_info_extensions)
1355: have_used_extensions = 1;
1356: putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1357: CHARS (1);
1358: dbxout_type (TREE_TYPE (type), 0, 0);
1359: break;
1360:
1361: case FUNCTION_TYPE:
1362: putc ('f', asmfile);
1363: CHARS (1);
1364: dbxout_type (TREE_TYPE (type), 0, 0);
1365: break;
1366:
1367: default:
1368: abort ();
1369: }
1370: }
1371:
1372: /* Print the value of integer constant C, in octal,
1373: handling double precision. */
1374:
1375: static void
1376: print_int_cst_octal (c)
1377: tree c;
1378: {
1379: unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1380: unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1381: int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1382: int width = TYPE_PRECISION (TREE_TYPE (c));
1383:
1384: /* GDB wants constants with no extra leading "1" bits, so
1385: we need to remove any sign-extension that might be
1386: present. */
1387: if (width == HOST_BITS_PER_WIDE_INT * 2)
1388: ;
1389: else if (width > HOST_BITS_PER_WIDE_INT)
1390: high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1391: else if (width == HOST_BITS_PER_WIDE_INT)
1392: high = 0;
1393: else
1394: high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1395:
1396: fprintf (asmfile, "0");
1397:
1398: if (excess == 3)
1399: {
1400: print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1401: print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1402: }
1403: else
1404: {
1405: unsigned HOST_WIDE_INT beg = high >> excess;
1406: unsigned HOST_WIDE_INT middle
1407: = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1408: | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1409: unsigned HOST_WIDE_INT end
1410: = low & (((unsigned HOST_WIDE_INT) 1
1411: << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1412: - 1);
1413:
1414: fprintf (asmfile, "%o%01o", beg, middle);
1415: print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1416: }
1417: }
1418:
1419: static void
1420: print_octal (value, digits)
1421: unsigned HOST_WIDE_INT value;
1422: int digits;
1423: {
1424: int i;
1425:
1426: for (i = digits - 1; i >= 0; i--)
1427: fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1428: }
1429:
1430: /* Output the name of type TYPE, with no punctuation.
1431: Such names can be set up either by typedef declarations
1432: or by struct, enum and union tags. */
1433:
1434: static void
1435: dbxout_type_name (type)
1436: register tree type;
1437: {
1438: tree t;
1439: if (TYPE_NAME (type) == 0)
1440: abort ();
1441: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1442: {
1443: t = TYPE_NAME (type);
1444: }
1445: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1446: {
1447: t = DECL_NAME (TYPE_NAME (type));
1448: }
1449: else
1450: abort ();
1451:
1452: fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1453: CHARS (IDENTIFIER_LENGTH (t));
1454: }
1455:
1456: /* Output a .stabs for the symbol defined by DECL,
1457: which must be a ..._DECL node in the normal namespace.
1458: It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1459: LOCAL is nonzero if the scope is less than the entire file. */
1460:
1461: void
1462: dbxout_symbol (decl, local)
1463: tree decl;
1464: int local;
1465: {
1466: int letter = 0;
1467: tree type = TREE_TYPE (decl);
1468: tree context = NULL_TREE;
1469: int regno = -1;
1470:
1471: /* Cast avoids warning in old compilers. */
1472: current_sym_code = (STAB_CODE_TYPE) 0;
1473: current_sym_value = 0;
1474: current_sym_addr = 0;
1475:
1476: /* Ignore nameless syms, but don't ignore type tags. */
1477:
1478: if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1479: || DECL_IGNORED_P (decl))
1480: return;
1481:
1482: dbxout_prepare_symbol (decl);
1483:
1484: /* The output will always start with the symbol name,
1485: so always count that in the length-output-so-far. */
1486:
1487: if (DECL_NAME (decl) != 0)
1488: current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1489:
1490: switch (TREE_CODE (decl))
1491: {
1492: case CONST_DECL:
1493: /* Enum values are defined by defining the enum type. */
1494: break;
1495:
1496: case FUNCTION_DECL:
1497: if (DECL_RTL (decl) == 0)
1498: return;
1499: if (DECL_EXTERNAL (decl))
1500: break;
1501: /* Don't mention a nested function under its parent. */
1502: context = decl_function_context (decl);
1503: if (context == current_function_decl)
1504: break;
1505: if (GET_CODE (DECL_RTL (decl)) != MEM
1506: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1507: break;
1508: FORCE_TEXT;
1509:
1510: fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1511: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1512: TREE_PUBLIC (decl) ? 'F' : 'f');
1513:
1514: current_sym_code = N_FUN;
1515: current_sym_addr = XEXP (DECL_RTL (decl), 0);
1516:
1517: if (TREE_TYPE (type))
1518: dbxout_type (TREE_TYPE (type), 0, 0);
1519: else
1520: dbxout_type (void_type_node, 0, 0);
1521:
1522: /* For a nested function, when that function is compiled,
1523: mention the containing function name
1524: as well as (since dbx wants it) our own assembler-name. */
1525: if (context != 0)
1526: fprintf (asmfile, ",%s,%s",
1527: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1528: IDENTIFIER_POINTER (DECL_NAME (context)));
1529:
1530: dbxout_finish_symbol (decl);
1531: break;
1532:
1533: case TYPE_DECL:
1534: #if 0
1535: /* This seems all wrong. Outputting most kinds of types gives no name
1536: at all. A true definition gives no name; a cross-ref for a
1537: structure can give the tag name, but not a type name.
1538: It seems that no typedef name is defined by outputting a type. */
1539:
1540: /* If this typedef name was defined by outputting the type,
1541: don't duplicate it. */
1542: if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
1543: && TYPE_NAME (TREE_TYPE (decl)) == decl)
1544: return;
1545: #endif
1546: /* Don't output the same typedef twice.
1547: And don't output what language-specific stuff doesn't want output. */
1548: if (TREE_ASM_WRITTEN (decl) || DECL_IGNORED_P (decl))
1549: return;
1550:
1551: FORCE_TEXT;
1552:
1553: {
1554: int tag_needed = 1;
1555: int did_output = 0;
1556:
1557: if (DECL_NAME (decl))
1558: {
1559: /* Nonzero means we must output a tag as well as a typedef. */
1560: tag_needed = 0;
1561:
1562: /* Handle the case of a C++ structure or union
1563: where the TYPE_NAME is a TYPE_DECL
1564: which gives both a typedef name and a tag. */
1565: /* dbx requires the tag first and the typedef second. */
1566: if ((TREE_CODE (type) == RECORD_TYPE
1567: || TREE_CODE (type) == UNION_TYPE
1568: || TREE_CODE (type) == QUAL_UNION_TYPE)
1569: && TYPE_NAME (type) == decl
1570: && !(use_gnu_debug_info_extensions && have_used_extensions)
1571: && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1572: /* Distinguish the implicit typedefs of C++
1573: from explicit ones that might be found in C. */
1574: && (!strcmp (lang_identify (), "cplusplus")
1575: /* The following line maybe unnecessary;
1576: in 2.6, try removing it. */
1577: || DECL_SOURCE_LINE (decl) == 0))
1578: {
1579: tree name = TYPE_NAME (type);
1580: if (TREE_CODE (name) == TYPE_DECL)
1581: name = DECL_NAME (name);
1582:
1583: current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1584: current_sym_value = 0;
1585: current_sym_addr = 0;
1586: current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1587:
1588: fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1589: IDENTIFIER_POINTER (name));
1590: dbxout_type (type, 1, 0);
1591: dbxout_finish_symbol (NULL_TREE);
1592: }
1593:
1594: /* Output typedef name. */
1595: fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1596: IDENTIFIER_POINTER (DECL_NAME (decl)));
1597:
1598: /* Short cut way to output a tag also. */
1599: if ((TREE_CODE (type) == RECORD_TYPE
1600: || TREE_CODE (type) == UNION_TYPE
1601: || TREE_CODE (type) == QUAL_UNION_TYPE)
1602: && TYPE_NAME (type) == decl)
1603: {
1604: if (use_gnu_debug_info_extensions && have_used_extensions)
1605: {
1606: putc ('T', asmfile);
1607: TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1608: }
1609: #if 0 /* Now we generate the tag for this case up above. */
1610: else
1611: tag_needed = 1;
1612: #endif
1613: }
1614:
1615: putc ('t', asmfile);
1616: current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1617:
1618: dbxout_type (type, 1, 0);
1619: dbxout_finish_symbol (decl);
1620: did_output = 1;
1621: }
1622:
1623: /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1624: zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1625:
1626: if (tag_needed && TYPE_NAME (type) != 0 && TYPE_SIZE (type) != 0
1627: && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1628: {
1629: /* For a TYPE_DECL with no name, but the type has a name,
1630: output a tag.
1631: This is what represents `struct foo' with no typedef. */
1632: /* In C++, the name of a type is the corresponding typedef.
1633: In C, it is an IDENTIFIER_NODE. */
1634: tree name = TYPE_NAME (type);
1635: if (TREE_CODE (name) == TYPE_DECL)
1636: name = DECL_NAME (name);
1637:
1638: current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1639: current_sym_value = 0;
1640: current_sym_addr = 0;
1641: current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1642:
1643: fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1644: IDENTIFIER_POINTER (name));
1645: dbxout_type (type, 1, 0);
1646: dbxout_finish_symbol (NULL_TREE);
1647: did_output = 1;
1648: }
1649:
1650: /* If an enum type has no name, it cannot be referred to,
1651: but we must output it anyway, since the enumeration constants
1652: can be referred to. */
1653: if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1654: {
1655: current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1656: current_sym_value = 0;
1657: current_sym_addr = 0;
1658: current_sym_nchars = 2;
1659:
1660: /* Some debuggers fail when given NULL names, so give this a
1661: harmless name of ` '. */
1662: fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1663: dbxout_type (type, 1, 0);
1664: dbxout_finish_symbol (NULL_TREE);
1665: }
1666:
1667: /* Prevent duplicate output of a typedef. */
1668: TREE_ASM_WRITTEN (decl) = 1;
1669: break;
1670: }
1671:
1672: case PARM_DECL:
1673: /* Parm decls go in their own separate chains
1674: and are output by dbxout_reg_parms and dbxout_parms. */
1675: abort ();
1676:
1677: case RESULT_DECL:
1678: /* Named return value, treat like a VAR_DECL. */
1679: case VAR_DECL:
1680: if (DECL_RTL (decl) == 0)
1681: return;
1682: /* Don't mention a variable that is external.
1683: Let the file that defines it describe it. */
1684: if (DECL_EXTERNAL (decl))
1685: break;
1686:
1687: /* If the variable is really a constant
1688: and not written in memory, inform the debugger. */
1689: if (TREE_STATIC (decl) && TREE_READONLY (decl)
1690: && DECL_INITIAL (decl) != 0
1691: && ! TREE_ASM_WRITTEN (decl)
1692: && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1693: || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1694: {
1695: if (TREE_PUBLIC (decl) == 0)
1696: {
1697: /* The sun4 assembler does not grok this. */
1698: char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1699: if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1700: || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1701: {
1702: HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1703: #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1704: DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1705: #else
1706: fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1707: ASM_STABS_OP, name, ival, N_LSYM);
1708: #endif
1709: return;
1710: }
1711: else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1712: {
1713: /* don't know how to do this yet. */
1714: }
1715: break;
1716: }
1717: /* else it is something we handle like a normal variable. */
1718: }
1719:
1720: DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1721: #ifdef LEAF_REG_REMAP
1722: if (leaf_function)
1723: leaf_renumber_regs_insn (DECL_RTL (decl));
1724: #endif
1725:
1726: dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1727: }
1728: }
1729:
1730: /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1731: Add SUFFIX to its name, if SUFFIX is not 0.
1732: Describe the variable as residing in HOME
1733: (usually HOME is DECL_RTL (DECL), but not always). */
1734:
1735: static void
1736: dbxout_symbol_location (decl, type, suffix, home)
1737: tree decl, type;
1738: char *suffix;
1739: rtx home;
1740: {
1741: int letter = 0;
1742: int regno = -1;
1743:
1744: /* Don't mention a variable at all
1745: if it was completely optimized into nothingness.
1746:
1747: If the decl was from an inline function, then it's rtl
1748: is not identically the rtl that was used in this
1749: particular compilation. */
1750: if (GET_CODE (home) == REG)
1751: {
1752: regno = REGNO (home);
1753: if (regno >= FIRST_PSEUDO_REGISTER)
1754: return;
1755: }
1756: else if (GET_CODE (home) == SUBREG)
1757: {
1758: rtx value = home;
1759: int offset = 0;
1760: while (GET_CODE (value) == SUBREG)
1761: {
1762: offset += SUBREG_WORD (value);
1763: value = SUBREG_REG (value);
1764: }
1765: if (GET_CODE (value) == REG)
1766: {
1767: regno = REGNO (value);
1768: if (regno >= FIRST_PSEUDO_REGISTER)
1769: return;
1770: regno += offset;
1771: }
1772: alter_subreg (home);
1773: }
1774:
1775: /* The kind-of-variable letter depends on where
1776: the variable is and on the scope of its name:
1777: G and N_GSYM for static storage and global scope,
1778: S for static storage and file scope,
1779: V for static storage and local scope,
1780: for those two, use N_LCSYM if data is in bss segment,
1781: N_STSYM if in data segment, N_FUN otherwise.
1782: (We used N_FUN originally, then changed to N_STSYM
1783: to please GDB. However, it seems that confused ld.
1784: Now GDB has been fixed to like N_FUN, says Kingdon.)
1785: no letter at all, and N_LSYM, for auto variable,
1786: r and N_RSYM for register variable. */
1787:
1788: if (GET_CODE (home) == MEM
1789: && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1790: {
1791: if (TREE_PUBLIC (decl))
1792: {
1793: letter = 'G';
1794: current_sym_code = N_GSYM;
1795: }
1796: else
1797: {
1798: current_sym_addr = XEXP (home, 0);
1799:
1800: letter = decl_function_context (decl) ? 'V' : 'S';
1801:
1802: if (!DECL_INITIAL (decl))
1803: current_sym_code = N_LCSYM;
1804: else if (DECL_IN_TEXT_SECTION (decl))
1805: /* This is not quite right, but it's the closest
1806: of all the codes that Unix defines. */
1807: current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1808: else
1809: {
1810: /* Ultrix `as' seems to need this. */
1811: #ifdef DBX_STATIC_STAB_DATA_SECTION
1812: data_section ();
1813: #endif
1814: current_sym_code = N_STSYM;
1815: }
1816: }
1817: }
1818: else if (regno >= 0)
1819: {
1820: letter = 'r';
1821: current_sym_code = N_RSYM;
1822: current_sym_value = DBX_REGISTER_NUMBER (regno);
1823: }
1824: else if (GET_CODE (home) == MEM
1825: && (GET_CODE (XEXP (home, 0)) == MEM
1826: || (GET_CODE (XEXP (home, 0)) == REG
1827: && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM)))
1828: /* If the value is indirect by memory or by a register
1829: that isn't the frame pointer
1830: then it means the object is variable-sized and address through
1831: that register or stack slot. DBX has no way to represent this
1832: so all we can do is output the variable as a pointer.
1833: If it's not a parameter, ignore it.
1834: (VAR_DECLs like this can be made by integrate.c.) */
1835: {
1836: if (GET_CODE (XEXP (home, 0)) == REG)
1837: {
1838: letter = 'r';
1839: current_sym_code = N_RSYM;
1840: current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
1841: }
1842: else
1843: {
1844: current_sym_code = N_LSYM;
1845: /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1846: We want the value of that CONST_INT. */
1847: current_sym_value
1848: = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
1849: }
1850:
1851: /* Effectively do build_pointer_type, but don't cache this type,
1852: since it might be temporary whereas the type it points to
1853: might have been saved for inlining. */
1854: /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1855: type = make_node (POINTER_TYPE);
1856: TREE_TYPE (type) = TREE_TYPE (decl);
1857: }
1858: else if (GET_CODE (home) == MEM
1859: && GET_CODE (XEXP (home, 0)) == REG)
1860: {
1861: current_sym_code = N_LSYM;
1862: current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1863: }
1864: else if (GET_CODE (home) == MEM
1865: && GET_CODE (XEXP (home, 0)) == PLUS
1866: && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
1867: {
1868: current_sym_code = N_LSYM;
1869: /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1870: We want the value of that CONST_INT. */
1871: current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1872: }
1873: else if (GET_CODE (home) == MEM
1874: && GET_CODE (XEXP (home, 0)) == CONST)
1875: {
1876: /* Handle an obscure case which can arise when optimizing and
1877: when there are few available registers. (This is *always*
1878: the case for i386/i486 targets). The RTL looks like
1879: (MEM (CONST ...)) even though this variable is a local `auto'
1880: or a local `register' variable. In effect, what has happened
1881: is that the reload pass has seen that all assignments and
1882: references for one such a local variable can be replaced by
1883: equivalent assignments and references to some static storage
1884: variable, thereby avoiding the need for a register. In such
1885: cases we're forced to lie to debuggers and tell them that
1886: this variable was itself `static'. */
1887: current_sym_code = N_LCSYM;
1888: letter = 'V';
1889: current_sym_addr = XEXP (XEXP (home, 0), 0);
1890: }
1891: else if (GET_CODE (home) == CONCAT)
1892: {
1893: tree subtype = TREE_TYPE (type);
1894:
1895: /* If the variable's storage is in two parts,
1896: output each as a separate stab with a modified name. */
1897: if (WORDS_BIG_ENDIAN)
1898: dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
1899: else
1900: dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
1901:
1902: /* Cast avoids warning in old compilers. */
1903: current_sym_code = (STAB_CODE_TYPE) 0;
1904: current_sym_value = 0;
1905: current_sym_addr = 0;
1906: dbxout_prepare_symbol (decl);
1907:
1908: if (WORDS_BIG_ENDIAN)
1909: dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
1910: else
1911: dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
1912: return;
1913: }
1914: else
1915: /* Address might be a MEM, when DECL is a variable-sized object.
1916: Or it might be const0_rtx, meaning previous passes
1917: want us to ignore this variable. */
1918: return;
1919:
1920: /* Ok, start a symtab entry and output the variable name. */
1921: FORCE_TEXT;
1922:
1923: #ifdef DBX_STATIC_BLOCK_START
1924: DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
1925: #endif
1926:
1927: dbxout_symbol_name (decl, suffix, letter);
1928: dbxout_type (type, 0, 0);
1929: dbxout_finish_symbol (decl);
1930:
1931: #ifdef DBX_STATIC_BLOCK_END
1932: DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
1933: #endif
1934: }
1935:
1936: /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
1937: Then output LETTER to indicate the kind of location the symbol has. */
1938:
1939: static void
1940: dbxout_symbol_name (decl, suffix, letter)
1941: tree decl;
1942: char *suffix;
1943: int letter;
1944: {
1945: /* One slight hitch: if this is a VAR_DECL which is a static
1946: class member, we must put out the mangled name instead of the
1947: DECL_NAME. */
1948:
1949: char *name;
1950: /* Note also that static member (variable) names DO NOT begin
1951: with underscores in .stabs directives. */
1952: if (DECL_LANG_SPECIFIC (decl))
1953: name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1954: else
1955: name = IDENTIFIER_POINTER (DECL_NAME (decl));
1956: if (name == 0)
1957: name = "(anon)";
1958: fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
1959: (suffix ? suffix : ""));
1960:
1961: if (letter) putc (letter, asmfile);
1962: }
1963:
1964: static void
1965: dbxout_prepare_symbol (decl)
1966: tree decl;
1967: {
1968: #ifdef WINNING_GDB
1969: char *filename = DECL_SOURCE_FILE (decl);
1970:
1971: dbxout_source_file (asmfile, filename);
1972: #endif
1973: }
1974:
1975: static void
1976: dbxout_finish_symbol (sym)
1977: tree sym;
1978: {
1979: #ifdef DBX_FINISH_SYMBOL
1980: DBX_FINISH_SYMBOL (sym);
1981: #else
1982: int line = 0;
1983: if (use_gnu_debug_info_extensions && sym != 0)
1984: line = DECL_SOURCE_LINE (sym);
1985:
1986: fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
1987: if (current_sym_addr)
1988: output_addr_const (asmfile, current_sym_addr);
1989: else
1990: fprintf (asmfile, "%d", current_sym_value);
1991: putc ('\n', asmfile);
1992: #endif
1993: }
1994:
1995: /* Output definitions of all the decls in a chain. */
1996:
1997: void
1998: dbxout_syms (syms)
1999: tree syms;
2000: {
2001: while (syms)
2002: {
2003: dbxout_symbol (syms, 1);
2004: syms = TREE_CHAIN (syms);
2005: }
2006: }
2007:
2008: /* The following two functions output definitions of function parameters.
2009: Each parameter gets a definition locating it in the parameter list.
2010: Each parameter that is a register variable gets a second definition
2011: locating it in the register.
2012:
2013: Printing or argument lists in gdb uses the definitions that
2014: locate in the parameter list. But reference to the variable in
2015: expressions uses preferentially the definition as a register. */
2016:
2017: /* Output definitions, referring to storage in the parmlist,
2018: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2019:
2020: void
2021: dbxout_parms (parms)
2022: tree parms;
2023: {
2024: for (; parms; parms = TREE_CHAIN (parms))
2025: if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2026: {
2027: dbxout_prepare_symbol (parms);
2028:
2029: /* Perform any necessary register eliminations on the parameter's rtl,
2030: so that the debugging output will be accurate. */
2031: DECL_INCOMING_RTL (parms)
2032: = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2033: DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2034: #ifdef LEAF_REG_REMAP
2035: if (leaf_function)
2036: {
2037: leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2038: leaf_renumber_regs_insn (DECL_RTL (parms));
2039: }
2040: #endif
2041:
2042: if (PARM_PASSED_IN_MEMORY (parms))
2043: {
2044: rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2045:
2046: /* ??? Here we assume that the parm address is indexed
2047: off the frame pointer or arg pointer.
2048: If that is not true, we produce meaningless results,
2049: but do not crash. */
2050: if (GET_CODE (addr) == PLUS
2051: && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2052: current_sym_value = INTVAL (XEXP (addr, 1));
2053: else
2054: current_sym_value = 0;
2055:
2056: current_sym_code = N_PSYM;
2057: current_sym_addr = 0;
2058:
2059: FORCE_TEXT;
2060: if (DECL_NAME (parms))
2061: {
2062: current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2063:
2064: fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2065: IDENTIFIER_POINTER (DECL_NAME (parms)),
2066: DBX_MEMPARM_STABS_LETTER);
2067: }
2068: else
2069: {
2070: current_sym_nchars = 8;
2071: fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2072: DBX_MEMPARM_STABS_LETTER);
2073: }
2074:
2075: if (GET_CODE (DECL_RTL (parms)) == REG
2076: && REGNO (DECL_RTL (parms)) >= 0
2077: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2078: dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2079: else
2080: {
2081: int original_value = current_sym_value;
2082:
2083: /* This is the case where the parm is passed as an int or double
2084: and it is converted to a char, short or float and stored back
2085: in the parmlist. In this case, describe the parm
2086: with the variable's declared type, and adjust the address
2087: if the least significant bytes (which we are using) are not
2088: the first ones. */
2089: #if BYTES_BIG_ENDIAN
2090: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2091: current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2092: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2093: #endif
2094:
2095: if (GET_CODE (DECL_RTL (parms)) == MEM
2096: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2097: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2098: && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
2099: dbxout_type (TREE_TYPE (parms), 0, 0);
2100: else
2101: {
2102: current_sym_value = original_value;
2103: dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2104: }
2105: }
2106: current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2107: dbxout_finish_symbol (parms);
2108: }
2109: else if (GET_CODE (DECL_RTL (parms)) == REG)
2110: {
2111: rtx best_rtl;
2112: char regparm_letter;
2113: tree parm_type;
2114: /* Parm passed in registers and lives in registers or nowhere. */
2115:
2116: current_sym_code = DBX_REGPARM_STABS_CODE;
2117: regparm_letter = DBX_REGPARM_STABS_LETTER;
2118: current_sym_addr = 0;
2119:
2120: /* If parm lives in a register, use that register;
2121: pretend the parm was passed there. It would be more consistent
2122: to describe the register where the parm was passed,
2123: but in practice that register usually holds something else.
2124:
2125: If we use DECL_RTL, then we must use the declared type of
2126: the variable, not the type that it arrived in. */
2127: if (REGNO (DECL_RTL (parms)) >= 0
2128: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2129: {
2130: best_rtl = DECL_RTL (parms);
2131: parm_type = TREE_TYPE (parms);
2132: }
2133: /* If the parm lives nowhere,
2134: use the register where it was passed. */
2135: else
2136: {
2137: best_rtl = DECL_INCOMING_RTL (parms);
2138: parm_type = DECL_ARG_TYPE (parms);
2139: }
2140: current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2141:
2142: FORCE_TEXT;
2143: if (DECL_NAME (parms))
2144: {
2145: current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2146: fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2147: IDENTIFIER_POINTER (DECL_NAME (parms)),
2148: regparm_letter);
2149: }
2150: else
2151: {
2152: current_sym_nchars = 8;
2153: fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2154: regparm_letter);
2155: }
2156:
2157: dbxout_type (parm_type, 0, 0);
2158: dbxout_finish_symbol (parms);
2159: }
2160: else if (GET_CODE (DECL_RTL (parms)) == MEM
2161: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2162: && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2163: && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2164: #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2165: && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2166: #endif
2167: )
2168: {
2169: /* Parm was passed via invisible reference.
2170: That is, its address was passed in a register.
2171: Output it as if it lived in that register.
2172: The debugger will know from the type
2173: that it was actually passed by invisible reference. */
2174:
2175: char regparm_letter;
2176: /* Parm passed in registers and lives in registers or nowhere. */
2177:
2178: current_sym_code = DBX_REGPARM_STABS_CODE;
2179: regparm_letter = DBX_REGPARM_STABS_LETTER;
2180:
2181: /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2182: current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2183: current_sym_addr = 0;
2184:
2185: FORCE_TEXT;
2186: if (DECL_NAME (parms))
2187: {
2188: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2189:
2190: fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2191: IDENTIFIER_POINTER (DECL_NAME (parms)),
2192: DBX_REGPARM_STABS_LETTER);
2193: }
2194: else
2195: {
2196: current_sym_nchars = 8;
2197: fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2198: DBX_REGPARM_STABS_LETTER);
2199: }
2200:
2201: dbxout_type (TREE_TYPE (parms), 0, 0);
2202: dbxout_finish_symbol (parms);
2203: }
2204: else if (GET_CODE (DECL_RTL (parms)) == MEM
2205: && XEXP (DECL_RTL (parms), 0) != const0_rtx
2206: /* ??? A constant address for a parm can happen
2207: when the reg it lives in is equiv to a constant in memory.
2208: Should make this not happen, after 2.4. */
2209: && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2210: {
2211: /* Parm was passed in registers but lives on the stack. */
2212:
2213: current_sym_code = N_PSYM;
2214: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2215: in which case we want the value of that CONST_INT,
2216: or (MEM (REG ...)) or (MEM (MEM ...)),
2217: in which case we use a value of zero. */
2218: if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2219: || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2220: current_sym_value = 0;
2221: else
2222: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2223: current_sym_addr = 0;
2224:
2225: FORCE_TEXT;
2226: if (DECL_NAME (parms))
2227: {
2228: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2229:
2230: fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2231: IDENTIFIER_POINTER (DECL_NAME (parms)),
2232: DBX_MEMPARM_STABS_LETTER);
2233: }
2234: else
2235: {
2236: current_sym_nchars = 8;
2237: fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2238: DBX_MEMPARM_STABS_LETTER);
2239: }
2240:
2241: current_sym_value
2242: = DEBUGGER_ARG_OFFSET (current_sym_value,
2243: XEXP (DECL_RTL (parms), 0));
2244: dbxout_type (TREE_TYPE (parms), 0, 0);
2245: dbxout_finish_symbol (parms);
2246: }
2247: }
2248: }
2249:
2250: /* Output definitions for the places where parms live during the function,
2251: when different from where they were passed, when the parms were passed
2252: in memory.
2253:
2254: It is not useful to do this for parms passed in registers
2255: that live during the function in different registers, because it is
2256: impossible to look in the passed register for the passed value,
2257: so we use the within-the-function register to begin with.
2258:
2259: PARMS is a chain of PARM_DECL nodes. */
2260:
2261: void
2262: dbxout_reg_parms (parms)
2263: tree parms;
2264: {
2265: for (; parms; parms = TREE_CHAIN (parms))
2266: if (DECL_NAME (parms))
2267: {
2268: dbxout_prepare_symbol (parms);
2269:
2270: /* Report parms that live in registers during the function
2271: but were passed in memory. */
2272: if (GET_CODE (DECL_RTL (parms)) == REG
2273: && REGNO (DECL_RTL (parms)) >= 0
2274: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
2275: && PARM_PASSED_IN_MEMORY (parms))
2276: dbxout_symbol_location (parms, TREE_TYPE (parms),
2277: 0, DECL_RTL (parms));
2278: else if (GET_CODE (DECL_RTL (parms)) == CONCAT
2279: && PARM_PASSED_IN_MEMORY (parms))
2280: dbxout_symbol_location (parms, TREE_TYPE (parms),
2281: 0, DECL_RTL (parms));
2282: /* Report parms that live in memory but not where they were passed. */
2283: else if (GET_CODE (DECL_RTL (parms)) == MEM
2284: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2285: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2286: && PARM_PASSED_IN_MEMORY (parms)
2287: && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2288: {
2289: #if 0 /* ??? It is not clear yet what should replace this. */
2290: int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
2291: /* A parm declared char is really passed as an int,
2292: so it occupies the least significant bytes.
2293: On a big-endian machine those are not the low-numbered ones. */
2294: #if BYTES_BIG_ENDIAN
2295: if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2296: offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2297: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2298: #endif
2299: if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
2300: #endif
2301: dbxout_symbol_location (parms, TREE_TYPE (parms),
2302: 0, DECL_RTL (parms));
2303: }
2304: #if 0
2305: else if (GET_CODE (DECL_RTL (parms)) == MEM
2306: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2307: {
2308: /* Parm was passed via invisible reference.
2309: That is, its address was passed in a register.
2310: Output it as if it lived in that register.
2311: The debugger will know from the type
2312: that it was actually passed by invisible reference. */
2313:
2314: current_sym_code = N_RSYM;
2315:
2316: /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2317: current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2318: current_sym_addr = 0;
2319:
2320: FORCE_TEXT;
2321: if (DECL_NAME (parms))
2322: {
2323: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2324:
2325: fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2326: IDENTIFIER_POINTER (DECL_NAME (parms)));
2327: }
2328: else
2329: {
2330: current_sym_nchars = 8;
2331: fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2332: }
2333:
2334: dbxout_type (TREE_TYPE (parms), 0, 0);
2335: dbxout_finish_symbol (parms);
2336: }
2337: #endif
2338: }
2339: }
2340:
2341: /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2342: output definitions of those names, in raw form */
2343:
2344: void
2345: dbxout_args (args)
2346: tree args;
2347: {
2348: while (args)
2349: {
2350: putc (',', asmfile);
2351: dbxout_type (TREE_VALUE (args), 0, 0);
2352: CHARS (1);
2353: args = TREE_CHAIN (args);
2354: }
2355: }
2356:
2357: /* Given a chain of ..._TYPE nodes,
2358: find those which have typedef names and output those names.
2359: This is to ensure those types get output. */
2360:
2361: void
2362: dbxout_types (types)
2363: register tree types;
2364: {
2365: while (types)
2366: {
2367: if (TYPE_NAME (types)
2368: && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2369: && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2370: dbxout_symbol (TYPE_NAME (types), 1);
2371: types = TREE_CHAIN (types);
2372: }
2373: }
2374:
2375: /* Output everything about a symbol block (a BLOCK node
2376: that represents a scope level),
2377: including recursive output of contained blocks.
2378:
2379: BLOCK is the BLOCK node.
2380: DEPTH is its depth within containing symbol blocks.
2381: ARGS is usually zero; but for the outermost block of the
2382: body of a function, it is a chain of PARM_DECLs for the function parameters.
2383: We output definitions of all the register parms
2384: as if they were local variables of that block.
2385:
2386: If -g1 was used, we count blocks just the same, but output nothing
2387: except for the outermost block.
2388:
2389: Actually, BLOCK may be several blocks chained together.
2390: We handle them all in sequence. */
2391:
2392: static void
2393: dbxout_block (block, depth, args)
2394: register tree block;
2395: int depth;
2396: tree args;
2397: {
2398: int blocknum;
2399:
2400: while (block)
2401: {
2402: /* Ignore blocks never expanded or otherwise marked as real. */
2403: if (TREE_USED (block))
2404: {
2405: #ifndef DBX_LBRAC_FIRST
2406: /* In dbx format, the syms of a block come before the N_LBRAC. */
2407: if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2408: dbxout_syms (BLOCK_VARS (block));
2409: if (args)
2410: dbxout_reg_parms (args);
2411: #endif
2412:
2413: /* Now output an N_LBRAC symbol to represent the beginning of
2414: the block. Use the block's tree-walk order to generate
2415: the assembler symbols LBBn and LBEn
2416: that final will define around the code in this block. */
2417: if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2418: {
2419: char buf[20];
2420: blocknum = next_block_number++;
2421: ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2422:
2423: if (BLOCK_HANDLER_BLOCK (block))
2424: {
2425: /* A catch block. Must precede N_LBRAC. */
2426: tree decl = BLOCK_VARS (block);
2427: while (decl)
2428: {
2429: #ifdef DBX_OUTPUT_CATCH
2430: DBX_OUTPUT_CATCH (asmfile, decl, buf);
2431: #else
2432: fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2433: IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2434: assemble_name (asmfile, buf);
2435: fprintf (asmfile, "\n");
2436: #endif
2437: decl = TREE_CHAIN (decl);
2438: }
2439: }
2440:
2441: #ifdef DBX_OUTPUT_LBRAC
2442: DBX_OUTPUT_LBRAC (asmfile, buf);
2443: #else
2444: fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2445: assemble_name (asmfile, buf);
2446: #if DBX_BLOCKS_FUNCTION_RELATIVE
2447: fputc ('-', asmfile);
2448: assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2449: #endif
2450: fprintf (asmfile, "\n");
2451: #endif
2452: }
2453: else if (depth > 0)
2454: /* Count blocks the same way regardless of debug_info_level. */
2455: next_block_number++;
2456:
2457: #ifdef DBX_LBRAC_FIRST
2458: /* On some weird machines, the syms of a block
2459: come after the N_LBRAC. */
2460: if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2461: dbxout_syms (BLOCK_VARS (block));
2462: if (args)
2463: dbxout_reg_parms (args);
2464: #endif
2465:
2466: /* Output the subblocks. */
2467: dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2468:
2469: /* Refer to the marker for the end of the block. */
2470: if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2471: {
2472: char buf[20];
2473: ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2474: #ifdef DBX_OUTPUT_RBRAC
2475: DBX_OUTPUT_RBRAC (asmfile, buf);
2476: #else
2477: fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2478: assemble_name (asmfile, buf);
2479: #if DBX_BLOCKS_FUNCTION_RELATIVE
2480: fputc ('-', asmfile);
2481: assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2482: #endif
2483: fprintf (asmfile, "\n");
2484: #endif
2485: }
2486: }
2487: block = BLOCK_CHAIN (block);
2488: }
2489: }
2490:
2491: /* Output the information about a function and its arguments and result.
2492: Usually this follows the function's code,
2493: but on some systems, it comes before. */
2494:
2495: static void
2496: dbxout_really_begin_function (decl)
2497: tree decl;
2498: {
2499: dbxout_symbol (decl, 0);
2500: dbxout_parms (DECL_ARGUMENTS (decl));
2501: if (DECL_NAME (DECL_RESULT (decl)) != 0)
2502: dbxout_symbol (DECL_RESULT (decl), 1);
2503: }
2504:
2505: /* Called at beginning of output of function definition. */
2506:
2507: void
2508: dbxout_begin_function (decl)
2509: tree decl;
2510: {
2511: #ifdef DBX_FUNCTION_FIRST
2512: dbxout_really_begin_function (decl);
2513: #endif
2514: }
2515:
2516: /* Output dbx data for a function definition.
2517: This includes a definition of the function name itself (a symbol),
2518: definitions of the parameters (locating them in the parameter list)
2519: and then output the block that makes up the function's body
2520: (including all the auto variables of the function). */
2521:
2522: void
2523: dbxout_function (decl)
2524: tree decl;
2525: {
2526: #ifndef DBX_FUNCTION_FIRST
2527: dbxout_really_begin_function (decl);
2528: #endif
2529: dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2530: #ifdef DBX_OUTPUT_FUNCTION_END
2531: DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2532: #endif
2533: }
2534: #endif /* DBX_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.