![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to dbxout.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Output dbx-format symbol table information from GNU compiler.
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* Output dbx-format symbol table data.
23: This consists of many symbol table entries, each of them
24: a .stabs assembler pseudo-op with four operands:
25: a "name" which is really a description of one symbol and its type,
26: a "code", which is a symbol defined in stab.h whose name starts with N_,
27: an unused operand always 0,
28: and a "value" which is an address or an offset.
29: The name is enclosed in doublequote characters.
30:
31: Each function, variable, typedef, and structure tag
32: has a symbol table entry to define it.
33: The beginning and end of each level of name scoping within
34: a function are also marked by special symbol table entries.
35:
36: The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
37: and a data type number. The data type number may be followed by
38: "=" and a type definition; normally this will happen the first time
39: the type number is mentioned. The type definition may refer to
40: other types by number, and those type numbers may be followed
41: by "=" and nested definitions.
42:
43: This can make the "name" quite long.
44: When a name is more than 80 characters, we split the .stabs pseudo-op
45: into two .stabs pseudo-ops, both sharing the same "code" and "value".
46: The first one is marked as continued with a double-backslash at the
47: end of its "name".
48:
49: The kind-of-symbol letter distinguished function names from global
50: variables from file-scope variables from parameters from auto
51: variables in memory from typedef names from register variables.
52: See `dbxout_symbol'.
53:
54: The "code" is mostly redundant with the kind-of-symbol letter
55: that goes in the "name", but not entirely: for symbols located
56: in static storage, the "code" says which segment the address is in,
57: which controls how it is relocated.
58:
59: The "value" for a symbol in static storage
60: is the core address of the symbol (actually, the assembler
61: label for the symbol). For a symbol located in a stack slot
62: it is the stack offset; for one in a register, the register number.
63: For a typedef symbol, it is zero.
64:
65: For more on data type definitions, see `dbxout_type'. */
66:
67: #include "config.h"
68: #include "tree.h"
69: #include "rtl.h"
70: #include <stdio.h>
71:
72: /* Typical USG systems don't have stab.h, and they also have
73: no use for DBX-format debugging info. */
74:
75: #ifndef NO_DBX_FORMAT
76:
77: #include <stab.h>
78:
79: /* Stream for writing to assembler file. */
80:
81: static FILE *asmfile;
82:
83: enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
84:
85: /* Vector recording the status of describing C data types.
86: When we first notice a data type (a tree node),
87: we assign it a number using next_type_number.
88: That is its index in this vector.
89: The vector element says whether we have yet output
90: the definition of the type. TYPE_XREF says we have
91: output it as a cross-reference only. */
92:
93: enum typestatus *typevec;
94:
95: /* Number of elements of space allocated in `typevec'. */
96:
97: static int typevec_len;
98:
99: /* In dbx output, each type gets a unique number.
100: This is the number for the next type output.
101: The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
102:
103: static int next_type_number;
104:
105: /* In dbx output, we must assign symbol-blocks id numbers
106: in the order in which their beginnings are encountered.
107: We output debugging info that refers to the beginning and
108: end of the ranges of code in each block
109: with assembler labels LBBn and LBEn, where n is the block number.
110: The labels are generated in final, which assigns numbers to the
111: blocks in the same way. */
112:
113: static int next_block_number;
114:
115: /* These variables are for dbxout_symbol to communicate to
116: dbxout_finish_symbol.
117: current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
118: current_sym_value and current_sym_addr are two ways to address the
119: value to store in the symtab entry.
120: current_sym_addr if nonzero represents the value as an rtx.
121: If that is zero, current_sym_value is used. This is used
122: when the value is an offset (such as for auto variables,
123: register variables and parms). */
124:
125: static int current_sym_code;
126: static int current_sym_value;
127: static rtx current_sym_addr;
128:
129: /* Number of chars of symbol-description generated so far for the
130: current symbol. Used by CHARS and CONTIN. */
131:
132: static int current_sym_nchars;
133:
134: /* Report having output N chars of the current symbol-description. */
135:
136: #define CHARS(N) (current_sym_nchars += (N))
137:
138: /* Break the current symbol-description, generating a continuation,
139: if it has become long. */
140:
141: #ifndef DBX_CONTIN_LENGTH
142: #define DBX_CONTIN_LENGTH 80
143: #endif
144:
145: #if DBX_CONTIN_LENGTH > 0
146: #define CONTIN \
147: do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
148: #else
149: #define CONTIN
150: #endif
151:
152: void dbxout_types ();
153: void dbxout_tags ();
154: static void dbxout_type_name ();
155: static void dbxout_type ();
156: static void dbxout_type_def ();
157: static void dbxout_finish_symbol ();
158: static void dbxout_continue ();
159:
160: /* At the beginning of compilation, start writing the symbol table.
161: Initialize `typevec' and output the standard data types of C. */
162:
163: void
164: dbxout_init (asm_file, input_file_name)
165: FILE *asm_file;
166: char *input_file_name;
167: {
168: asmfile = asm_file;
169:
170: typevec_len = 100;
171: typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
172: bzero (typevec, typevec_len * sizeof typevec[0]);
173:
174: fprintf (asmfile,
175: "Ltext:\t.stabs \"%s\",%d,0,0,Ltext\n",
176: input_file_name, N_SO);
177:
178: next_type_number = 1;
179: next_block_number = 2;
180:
181: /* Make sure that types `int' and `char' have numbers 1 and 2.
182: Definitions of other integer types will refer to those numbers. */
183:
184: dbxout_type_def (integer_type_node);
185: dbxout_type_def (char_type_node);
186:
187: /* Get all permanent types not yet gotten, and output them. */
188:
189: dbxout_types (get_permanent_types ());
190: }
191:
192: /* Continue a symbol-description that gets too big.
193: End one symbol table entry with a double-backslash
194: and start a new one, eventually producing something like
195: .stabs "start......\\",code,0,value
196: .stabs "...rest",code,0,value */
197:
198: static void
199: dbxout_continue ()
200: {
201: #ifdef DBX_CONTIN_CHAR
202: fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
203: #else
204: fprintf (asmfile, "\\\\");
205: #endif
206: dbxout_finish_symbol ();
207: fprintf (asmfile, ".stabs \"");
208: current_sym_nchars = 0;
209: }
210:
211: /* Output a reference to a type. If the type has not yet been
212: described in the dbx output, output its definition now.
213: For a type already defined, just refer to its definition
214: using the type number.
215:
216: If FULL is nonzero, and the type has been described only with
217: a forward-reference, output the definition now.
218: If FULL is zero in this case, just refer to the forward-reference
219: using the number previously allocated. */
220:
221: static void
222: dbxout_type (type, full)
223: tree type;
224: int full;
225: {
226: register tree tem;
227:
228: /* If there was an input error and we don't really have a type,
229: avoid crashing and write something that is at least valid
230: by assuming `int'. */
231: if (type == error_mark_node)
232: type = integer_type_node;
233: else if (TYPE_SIZE (type) == 0)
234: type = TYPE_MAIN_VARIANT (type);
235:
236: if (TYPE_SYMTAB_ADDRESS (type) == 0)
237: {
238: /* Type has no dbx number assigned. Assign next available number. */
239: TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
240:
241: /* Make sure type vector is long enough to record about this type. */
242:
243: if (next_type_number == typevec_len)
244: {
245: typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
246: bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]);
247: typevec_len *= 2;
248: }
249: }
250:
251: /* Output the number of this type, to refer to it. */
252: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
253: CHARS (3);
254:
255: /* If this type's definition has been output or is now being output,
256: that is all. */
257:
258: switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
259: {
260: case TYPE_UNSEEN:
261: break;
262: case TYPE_XREF:
263: if (! full)
264: return;
265: break;
266: case TYPE_DEFINED:
267: return;
268: }
269:
270: #ifdef DBX_NO_XREFS
271: /* For systems where dbx output does not allow the `=xsNAME:' syntax,
272: leave the type-number completely undefined rather than output
273: a cross-reference. */
274: if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
275: || TREE_CODE (type) == ENUMERAL_TYPE)
276:
277: if ((TYPE_NAME (type) != 0 && !full)
278: || TYPE_SIZE (type) == 0)
279: {
280: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
281: return;
282: }
283: #endif
284:
285: /* Output a definition now. */
286:
287: fprintf (asmfile, "=");
288: CHARS (1);
289:
290: /* Mark it as defined, so that if it is self-referent
291: we will not get into an infinite recursion of definitions. */
292:
293: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
294:
295: switch (TREE_CODE (type))
296: {
297: case VOID_TYPE:
298: /* For a void type, just define it as itself; ie, "5=5".
299: This makes us consider it defined
300: without saying what it is. The debugger will make it
301: a void type when the reference is seen, and nothing will
302: ever override that default. */
303: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
304: CHARS (3);
305: break;
306:
307: case INTEGER_TYPE:
308: if (type == char_type_node && ! TREE_UNSIGNED (type))
309: /* Output the type `char' as a subrange of itself!
310: I don't understand this definition, just copied it
311: from the output of pcc. */
312: fprintf (asmfile, "r2;0;127;");
313: else
314: /* Output other integer types as subranges of `int'. */
315: fprintf (asmfile, "r1;%d;%d;",
316: TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)),
317: TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
318: CHARS (25);
319: break;
320:
321: case REAL_TYPE:
322: /* This must be magic. */
323: fprintf (asmfile, "r1;%d;0;",
324: TREE_INT_CST_LOW (size_in_bytes (type)));
325: CHARS (16);
326: break;
327:
328: case ARRAY_TYPE:
329: /* Output "a" followed by a range type definition
330: for the index type of the array
331: followed by a reference to the target-type.
332: ar1;0;N;M for an array of type M and size N. */
333: fprintf (asmfile, "ar1;0;%d;",
334: (TYPE_DOMAIN (type)
335: ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
336: : -1));
337: CHARS (17);
338: dbxout_type (TREE_TYPE (type), 0);
339: break;
340:
341: case RECORD_TYPE:
342: case UNION_TYPE:
343: /* Output a structure type. */
344: if ((TYPE_NAME (type) != 0 && !full)
345: || TYPE_SIZE (type) == 0)
346: {
347: /* If the type is just a cross reference, output one
348: and mark the type as partially described.
349: If it later becomes defined, we will output
350: its real definition.
351: If the type has a name, don't nest its name within
352: another type's definition; instead, output an xref
353: and let the definition come when the name is defined. */
354: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
355: CHARS (3);
356: dbxout_type_name (type);
357: fprintf (asmfile, ":");
358: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
359: break;
360: }
361: tem = size_in_bytes (type);
362: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
363: TREE_INT_CST_LOW (tem));
364: CHARS (11);
365: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
366: /* Output the name, type, position (in bits), size (in bits)
367: of each field. */
368: /* Omit here the nameless fields that are used to skip bits. */
369: if (DECL_NAME (tem) != 0)
370: {
371: fprintf (asmfile, "<%d:%d>", current_sym_nchars, DBX_CONTIN_LENGTH);
372: /* Continue the line if necessary,
373: but not before the first field. */
374: if (tem != TYPE_FIELDS (type))
375: CONTIN;
376: fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
377: CHARS (1 + strlen (IDENTIFIER_POINTER (DECL_NAME (tem))));
378: dbxout_type (TREE_TYPE (tem), 0);
379: fprintf (asmfile, ",%d,%d;", DECL_OFFSET (tem),
380: TREE_INT_CST_LOW (DECL_SIZE (tem)) * DECL_SIZE_UNIT (tem));
381: CHARS (23);
382: }
383: putc (';', asmfile);
384: CHARS (1);
385: break;
386:
387: case ENUMERAL_TYPE:
388: if ((TYPE_NAME (type) != 0 && !full)
389: || TYPE_SIZE (type) == 0)
390: {
391: fprintf (asmfile, "xe");
392: CHARS (3);
393: dbxout_type_name (type);
394: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
395: fprintf (asmfile, ":");
396: return;
397: }
398: putc ('e', asmfile);
399: CHARS (1);
400: for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
401: {
402: fprintf (asmfile, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem)),
403: TREE_INT_CST_LOW (TREE_VALUE (tem)));
404: CHARS (11 + strlen (IDENTIFIER_POINTER (TREE_PURPOSE (tem))));
405: if (TREE_CHAIN (tem) != 0)
406: CONTIN;
407: }
408: putc (';', asmfile);
409: CHARS (1);
410: break;
411:
412: case POINTER_TYPE:
413: putc ('*', asmfile);
414: CHARS (1);
415: dbxout_type (TREE_TYPE (type), 0);
416: break;
417:
418: case FUNCTION_TYPE:
419: putc ('f', asmfile);
420: CHARS (1);
421: dbxout_type (TREE_TYPE (type), 0);
422: break;
423: }
424: }
425:
426: /* Output the name of type TYPE, with no punctuation.
427: Such names can be set up either by typedef declarations
428: or by struct, enum and union tags. */
429:
430: static void
431: dbxout_type_name (type)
432: register tree type;
433: {
434: register char *name;
435: if (TYPE_NAME (type) == 0)
436: abort ();
437: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
438: name = IDENTIFIER_POINTER (TYPE_NAME (type));
439: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
440: name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
441: else
442: abort ();
443:
444: fprintf (asmfile, "%s", name);
445: CHARS (strlen (name));
446: }
447:
448: /* Output a .stabs for the symbol defined by DECL,
449: which must be a ..._DECL node in the normal namespace.
450: It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
451: LOCAL is nonzero if the scope is less than the entire file. */
452:
453: void
454: dbxout_symbol (decl, local)
455: tree decl;
456: int local;
457: {
458: int letter = 0;
459: tree type = TREE_TYPE (decl);
460:
461: /* If global, first output all types and all
462: struct, enum and union tags that have been created
463: and not yet output. */
464:
465: if (local == 0)
466: {
467: dbxout_tags (gettags ());
468: dbxout_types (get_permanent_types ());
469: }
470:
471: current_sym_code = 0;
472: current_sym_value = 0;
473: current_sym_addr = 0;
474:
475: /* The output will always start with the symbol name,
476: so count that always in the length-output-so-far. */
477:
478: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (decl)));
479:
480: switch (TREE_CODE (decl))
481: {
482: case CONST_DECL:
483: /* Enum values are defined by defining the enum type. */
484: break;
485:
486: case FUNCTION_DECL:
487: if (DECL_RTL (decl) == 0)
488: return;
489: if (TREE_EXTERNAL (decl))
490: break;
491: if (GET_CODE (DECL_RTL (decl)) != MEM
492: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
493: break;
494: fprintf (asmfile, ".stabs \"%s:%c",
495: IDENTIFIER_POINTER (DECL_NAME (decl)),
496: TREE_PUBLIC (decl) ? 'F' : 'f');
497:
498: current_sym_code = N_FUN;
499: current_sym_addr = XEXP (DECL_RTL (decl), 0);
500:
501: if (TREE_TYPE (TREE_TYPE (decl)))
502: dbxout_type (TREE_TYPE (TREE_TYPE (decl)), 0);
503: else
504: dbxout_type (void_type_node, 0);
505: dbxout_finish_symbol ();
506: break;
507:
508: case TYPE_DECL:
509: /* If this typedef name was defined by outputting the type,
510: don't duplicate it. */
511: if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
512: && TYPE_NAME (TREE_TYPE (decl)) == decl)
513: return;
514:
515: /* Output typedef name. */
516: fprintf (asmfile, ".stabs \"%s:t",
517: IDENTIFIER_POINTER (DECL_NAME (decl)));
518:
519: current_sym_code = N_LSYM;
520:
521: dbxout_type (TREE_TYPE (decl), 1);
522: dbxout_finish_symbol ();
523: break;
524:
525: case PARM_DECL:
526: /* Parm decls go in their own separate chains
527: and are output by dbxout_reg_parms and dbxout_parms. */
528: abort ();
529:
530: case VAR_DECL:
531: if (DECL_RTL (decl) == 0)
532: return;
533: /* Don't mention a variable that is external.
534: Let the file that defines it describe it. */
535: if (TREE_EXTERNAL (decl))
536: break;
537:
538: /* Don't mention a variable at all
539: if it was completely optimized into nothingness. */
540: if (GET_CODE (DECL_RTL (decl)) == REG
541: && (REGNO (DECL_RTL (decl)) < 0
542: || REGNO (DECL_RTL (decl)) >= FIRST_PSEUDO_REGISTER))
543: break;
544:
545: /* Ok, start a symtab entry and output the variable name. */
546: fprintf (asmfile, ".stabs \"%s:",
547: IDENTIFIER_POINTER (DECL_NAME (decl)));
548:
549: /* The kind-of-variable letter depends on where
550: the variable is and on the scope of its name:
551: G and N_GSYM for static storage and global scope,
552: S for static storage and file scope,
553: v for static storage and local scope,
554: for those two, use N_LCSYM if data is in bss segment,
555: N_STSYM if it is in data segment, or N_FUN if in text segment.
556: no letter at all, and N_LSYM, for auto variable,
557: r and N_RSYM for register variable. */
558:
559: if (GET_CODE (DECL_RTL (decl)) == MEM
560: && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
561: {
562: if (TREE_PUBLIC (decl))
563: {
564: letter = 'G';
565: current_sym_code = N_GSYM;
566: }
567: else
568: {
569: current_sym_addr = XEXP (DECL_RTL (decl), 0);
570:
571: letter = TREE_PERMANENT (decl) ? 'S' : 'v';
572:
573: if (!DECL_INITIAL (decl))
574: current_sym_code = N_LCSYM;
575: else if (TREE_READONLY (decl) && ! TREE_VOLATILE (decl))
576: /* This is not quite right, but it's the closest
577: of all the codes that Unix defines. */
578: current_sym_code = N_FUN;
579: else
580: current_sym_code = N_STSYM;
581: }
582: }
583: else if (GET_CODE (DECL_RTL (decl)) == REG)
584: {
585: letter = 'r';
586: current_sym_code = N_RSYM;
587: current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (decl)));
588: }
589: else if (GET_CODE (DECL_RTL (decl)) == MEM
590: && (GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
591: || (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG
592: && REGNO (XEXP (DECL_RTL (decl), 0)) != FRAME_POINTER_REGNUM)))
593: /* If the value is indirect by memory or by a register
594: that isn't the frame pointer
595: then it means the object is variable-sized and address through
596: that register or stack slot. DBX has no way to represent this
597: so all we can do is output the variable as a pointer. */
598: {
599: if (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
600: {
601: letter = 'r';
602: current_sym_code = N_RSYM;
603: current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl), 0)));
604: }
605: else
606: {
607: current_sym_code = N_LSYM;
608: /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
609: We want the value of that CONST_INT. */
610: current_sym_value = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (decl), 0), 0), 1));
611: }
612:
613: type = build_pointer_type (TREE_TYPE (decl));
614: }
615: else if (GET_CODE (DECL_RTL (decl)) == MEM
616: && XEXP (DECL_RTL (decl), 0) != const0_rtx)
617: /* const0_rtx is used as the address for a variable that
618: is a dummy due to an erroneous declaration.
619: Ignore such vars. */
620: {
621: current_sym_code = N_LSYM;
622: if (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
623: current_sym_value = 0;
624: else
625: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
626: We want the value of that CONST_INT. */
627: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (decl), 0), 1));
628: }
629: if (letter) putc (letter, asmfile);
630: dbxout_type (type, 0);
631: dbxout_finish_symbol ();
632: break;
633: }
634: }
635:
636: static void
637: dbxout_finish_symbol ()
638: {
639: fprintf (asmfile, "\",%d,0,0,", current_sym_code);
640: if (current_sym_addr)
641: output_addr_const (asmfile, current_sym_addr);
642: else
643: fprintf (asmfile, "%d", current_sym_value);
644: putc ('\n', asmfile);
645: }
646:
647: /* Output definitions of all the decls in a chain. */
648:
649: static void
650: dbxout_syms (syms)
651: tree syms;
652: {
653: while (syms)
654: {
655: dbxout_symbol (syms, 1);
656: syms = TREE_CHAIN (syms);
657: }
658: }
659:
660: /* The following two functions output definitions of function parameters.
661: Each parameter gets a definition locating it in the parameter list.
662: Each parameter that is a register variable gets a second definition
663: locating it in the register.
664:
665: Printing or argument lists in gdb uses the definitions that
666: locate in the parameter list. But reference to the variable in
667: expressions uses preferentially the definition as a register. */
668:
669: /* Output definitions, referring to storage in the parmlist,
670: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
671:
672: static void
673: dbxout_parms (parms)
674: tree parms;
675: {
676: for (; parms; parms = TREE_CHAIN (parms))
677: {
678: if (DECL_OFFSET (parms) >= 0)
679: {
680: current_sym_code = N_PSYM;
681: current_sym_value = DECL_OFFSET (parms) / BITS_PER_UNIT;
682: current_sym_addr = 0;
683: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
684:
685: fprintf (asmfile, ".stabs \"%s:p",
686: IDENTIFIER_POINTER (DECL_NAME (parms)));
687:
688: if (GET_CODE (DECL_RTL (parms)) == REG
689: && REGNO (DECL_RTL (parms)) >= 0
690: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
691: dbxout_type (DECL_ARG_TYPE (parms), 0);
692: else
693: {
694: /* This is the case where the parm is passed as an int or double
695: and it is converted to a char, short or float and stored back
696: in the parmlist. In this case, describe the parm
697: with the variable's declared type, and adjust the address
698: if the least significant bytes (which we are using) are not
699: the first ones. */
700: #ifdef BYTES_BIG_ENDIAN
701: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
702: current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
703: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
704: #endif
705:
706: if (GET_CODE (DECL_RTL (parms)) == MEM
707: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
708: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
709: && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
710: dbxout_type (TREE_TYPE (parms), 0);
711: else
712: {
713: current_sym_value = DECL_OFFSET (parms) / BITS_PER_UNIT;
714: dbxout_type (DECL_ARG_TYPE (parms), 0);
715: }
716: }
717: dbxout_finish_symbol ();
718: }
719: /* Parm was passed in registers.
720: If it is in a register, output a "regparm" symbol
721: for the register it lives in. */
722: else if (GET_CODE (DECL_RTL (parms)) == REG)
723: {
724: current_sym_code = N_RSYM;
725: current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)));
726: current_sym_addr = 0;
727: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
728:
729: fprintf (asmfile, ".stabs \"%s:P",
730: IDENTIFIER_POINTER (DECL_NAME (parms)));
731:
732: dbxout_type (DECL_ARG_TYPE (parms), 0);
733: dbxout_finish_symbol ();
734: }
735: else if (GET_CODE (DECL_RTL (parms)) == MEM
736: && XEXP (DECL_RTL (parms), 0) != const0_rtx)
737: {
738: current_sym_code = N_LSYM;
739: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))).
740: We want the value of that CONST_INT. */
741: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
742: current_sym_addr = 0;
743: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
744:
745: fprintf (asmfile, ".stabs \"%s:p",
746: IDENTIFIER_POINTER (DECL_NAME (parms)));
747:
748: /* This is the case where the parm is passed as an int or double
749: and it is converted to a char, short or float and stored back
750: in the parmlist. In this case, describe the parm
751: with the variable's declared type, and adjust the address
752: if the least significant bytes (which we are using) are not
753: the first ones. */
754: #ifdef BYTES_BIG_ENDIAN
755: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
756: current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
757: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
758: #endif
759:
760: dbxout_type (TREE_TYPE (parms), 0);
761: dbxout_finish_symbol ();
762: }
763:
764: }
765: }
766:
767: /* Output definitions, referring to registers,
768: of all the parms in PARMS which are stored in registers during the function.
769: PARMS is a chain of PARM_DECL nodes. */
770:
771: static void
772: dbxout_reg_parms (parms)
773: tree parms;
774: {
775: while (parms)
776: {
777: /* Report parms that live in registers during the function. */
778: if (GET_CODE (DECL_RTL (parms)) == REG
779: && REGNO (DECL_RTL (parms)) >= 0
780: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
781: && DECL_OFFSET (parms) >= 0)
782: {
783: current_sym_code = N_RSYM;
784: current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)));
785: current_sym_addr = 0;
786: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
787: fprintf (asmfile, ".stabs \"%s:r",
788: IDENTIFIER_POINTER (DECL_NAME (parms)));
789: dbxout_type (TREE_TYPE (parms), 0);
790: dbxout_finish_symbol ();
791: }
792: /* Report parms that live in memory but outside the parmlist. */
793: else if (GET_CODE (DECL_RTL (parms)) == MEM
794: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
795: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT)
796: {
797: int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
798: /* A parm declared char is really passed as an int,
799: so it occupies the least significant bytes.
800: On a big-endian machine those are not the low-numbered ones. */
801: #ifdef BYTES_BIG_ENDIAN
802: if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
803: offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
804: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
805: #endif
806: if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset)
807: {
808: current_sym_code = N_LSYM;
809: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
810: current_sym_addr = 0;
811: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
812: fprintf (asmfile, ".stabs \"%s:",
813: IDENTIFIER_POINTER (DECL_NAME (parms)));
814: dbxout_type (TREE_TYPE (parms), 0);
815: dbxout_finish_symbol ();
816: }
817: }
818: parms = TREE_CHAIN (parms);
819: }
820: }
821:
822: /* Given a chain of ..._TYPE nodes, all of which have names,
823: output definitions of those names, as typedefs. */
824:
825: void
826: dbxout_types (types)
827: register tree types;
828: {
829: while (types)
830: {
831: if (TYPE_NAME (types)
832: && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL)
833: dbxout_type_def (types);
834: types = TREE_CHAIN (types);
835: }
836: }
837:
838: /* Output a definition of a typedef name.
839: It works much like any other kind of symbol definition.
840: Output nothing if TYPE's definition has been output already. */
841:
842: static void
843: dbxout_type_def (type)
844: tree type;
845: {
846: /* This fn is called an extra time for int and char types. Do nothing. */
847: /* This `if' used to reject any type already output,
848: but that caused some type NAMES not to be defined,
849: whose TYPES were defined already. */
850: if (TYPE_SYMTAB_ADDRESS (type) != 0
851: && typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
852: && (type == integer_type_node || type == char_type_node))
853: return;
854:
855: current_sym_code = N_LSYM;
856: current_sym_value = 0;
857: current_sym_addr = 0;
858: current_sym_nchars = 0;
859: current_sym_nchars
860: = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
861:
862: fprintf (asmfile, ".stabs \"%s:t",
863: IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
864: dbxout_type (type, 1);
865: dbxout_finish_symbol ();
866: }
867:
868: /* Output the tags (struct, union and enum definitions with names) for a block,
869: given a list of them (a chain of TREE_LIST nodes) in TAGS.
870: We must check to include those that have been mentioned already with
871: only a cross-reference. */
872:
873: void
874: dbxout_tags (tags)
875: tree tags;
876: {
877: register tree link;
878: for (link = tags; link; link = TREE_CHAIN (link))
879: {
880: register tree type = TYPE_MAIN_VARIANT (TREE_VALUE (link));
881: if (TREE_PURPOSE (link) != 0
882: && ! TREE_ASM_WRITTEN (link)
883: && TYPE_SIZE (type) != 0)
884: {
885: TREE_ASM_WRITTEN (link) = 1;
886: current_sym_code = N_LSYM;
887: current_sym_value = 0;
888: current_sym_addr = 0;
889: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (TREE_PURPOSE (link)));
890:
891: fprintf (asmfile, ".stabs \"%s:T",
892: IDENTIFIER_POINTER (TREE_PURPOSE (link)));
893: dbxout_type (type, 1);
894: dbxout_finish_symbol ();
895: }
896: }
897: }
898:
899: /* Output everything about a symbol block (that is to say, a LET_STMT node
900: that represents a scope level),
901: including recursive output of contained blocks.
902:
903: STMT is the LET_STMT node.
904: DEPTH is its depth within containing symbol blocks.
905: ARGS is usually zero; but for the outermost block of the
906: body of a function, it is a chain of PARM_DECLs for the function parameters.
907: We output definitions of all the register parms
908: as if they were local variables of that block.
909:
910: Actually, STMT may be several statements chained together.
911: We handle them all in sequence. */
912:
913: static void
914: dbxout_block (stmt, depth, args)
915: register tree stmt;
916: int depth;
917: tree args;
918: {
919: int blocknum;
920:
921: while (stmt)
922: {
923: switch (TREE_CODE (stmt))
924: {
925: case COMPOUND_STMT:
926: case LOOP_STMT:
927: dbxout_block (STMT_BODY (stmt), depth, 0);
928: break;
929:
930: case IF_STMT:
931: dbxout_block (STMT_THEN (stmt), depth, 0);
932: dbxout_block (STMT_ELSE (stmt), depth, 0);
933: break;
934:
935: case LET_STMT:
936: /* In dbx format, the syms of a block come before the N_LBRAC. */
937: dbxout_tags (STMT_TYPE_TAGS (stmt));
938: dbxout_syms (STMT_VARS (stmt));
939: if (args)
940: dbxout_reg_parms (args);
941:
942: /* Now output an N_LBRAC symbol to represent the beginning of
943: the block. Use the block's tree-walk order to generate
944: the assembler symbols LBBn and LBEn
945: that final will define around the code in this block. */
946: if (depth > 0)
947: {
948: blocknum = next_block_number++;
949: fprintf (asmfile, ".stabn %d,0,0,LBB%d\n", N_LBRAC, blocknum);
950: }
951:
952: /* Output the interior of the block. */
953: dbxout_block (STMT_BODY (stmt), depth + 1, 0);
954:
955: /* Refer to the marker for the end of the block. */
956: if (depth > 0)
957: fprintf (asmfile, ".stabn %d,0,0,LBE%d\n", N_RBRAC, blocknum);
958: }
959: stmt = TREE_CHAIN (stmt);
960: }
961: }
962:
963: /* Output dbx data for a function definition.
964: This includes a definition of the function name itself (a symbol),
965: definitions of the parameters (locating them in the parameter list)
966: and then output the block that makes up the function's body
967: (including all the auto variables of the function). */
968:
969: void
970: dbxout_function (decl)
971: tree decl;
972: {
973: dbxout_symbol (decl, 0);
974: dbxout_parms (DECL_ARGUMENTS (decl));
975: dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
976: }
977:
978: #else /* NO_DBX_FORMAT */
979:
980: void
981: dbxout_init (asm_file, input_file_name)
982: FILE *asm_file;
983: char *input_file_name;
984: {}
985:
986: void
987: dbxout_symbol (decl, local)
988: tree decl;
989: int local;
990: {}
991:
992: void
993: dbxout_types (types)
994: register tree types;
995: {}
996:
997: void
998: dbxout_tags (tags)
999: tree tags;
1000: {}
1001:
1002: void
1003: dbxout_function (decl)
1004: tree decl;
1005: {}
1006:
1007: #endif /* NO_DBX_FORMAT */
1008:
1009: fprd(f, val)
1010: FILE *f;
1011: double val;
1012: {
1013: long *l = (long *)&val;
1014: fprintf (f, "\t.long 0x%x,0x%x\n", l[0], l[1]);
1015: }
1016:
1017: fprf(f, val)
1018: FILE *f;
1019: float val;
1020: {
1021: long *l = (long *)&val;
1022: fprintf (f, "\t.long 0x%x\n", l[0]);
1023: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.