xref: /openbsd-src/gnu/usr.bin/gcc/gcc/sdbout.c (revision c87b03e512fc05ed6e0222f6fb0ae86264b1d05b)
1 /* Output sdb-format symbol table information from GNU compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002 Free Software Foundation, Inc.
4 
5 This file is part of GCC.
6 
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11 
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21 
22 /*  mike@tredysvr.Tredydev.Unisys.COM says:
23 I modified the struct.c example and have a nm of a .o resulting from the
24 AT&T C compiler.  From the example below I would conclude the following:
25 
26 1. All .defs from structures are emitted as scanned.  The example below
27    clearly shows the symbol table entries for BoxRec2 are after the first
28    function.
29 
30 2. All functions and their locals (including statics) are emitted as scanned.
31 
32 3. All nested unnamed union and structure .defs must be emitted before
33    the structure in which they are nested.  The AT&T assembler is a
34    one pass beast as far as symbolics are concerned.
35 
36 4. All structure .defs are emitted before the typedefs that refer to them.
37 
38 5. All top level static and external variable definitions are moved to the
39    end of file with all top level statics occurring first before externs.
40 
41 6. All undefined references are at the end of the file.
42 */
43 
44 #include "config.h"
45 #include "system.h"
46 #include "debug.h"
47 #include "tree.h"
48 #include "ggc.h"
49 
50 static GTY(()) tree anonymous_types;
51 
52 #ifdef SDB_DEBUGGING_INFO
53 
54 #include "rtl.h"
55 #include "regs.h"
56 #include "flags.h"
57 #include "insn-config.h"
58 #include "reload.h"
59 #include "output.h"
60 #include "toplev.h"
61 #include "tm_p.h"
62 #include "gsyms.h"
63 #include "langhooks.h"
64 
65 /* 1 if PARM is passed to this function in memory.  */
66 
67 #define PARM_PASSED_IN_MEMORY(PARM) \
68  (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
69 
70 /* A C expression for the integer offset value of an automatic variable
71    (C_AUTO) having address X (an RTX).  */
72 #ifndef DEBUGGER_AUTO_OFFSET
73 #define DEBUGGER_AUTO_OFFSET(X) \
74   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
75 #endif
76 
77 /* A C expression for the integer offset value of an argument (C_ARG)
78    having address X (an RTX).  The nominal offset is OFFSET.  */
79 #ifndef DEBUGGER_ARG_OFFSET
80 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
81 #endif
82 
83 /* Line number of beginning of current function, minus one.
84    Negative means not in a function or not using sdb.  */
85 
86 int sdb_begin_function_line = -1;
87 
88 /* Counter to generate unique "names" for nameless struct members.  */
89 
90 static int unnamed_struct_number = 0;
91 
92 extern FILE *asm_out_file;
93 
94 extern tree current_function_decl;
95 
96 #include "sdbout.h"
97 
98 static void sdbout_init			PARAMS ((const char *));
99 static void sdbout_finish		PARAMS ((const char *));
100 static void sdbout_start_source_file	PARAMS ((unsigned int, const char *));
101 static void sdbout_end_source_file	PARAMS ((unsigned int));
102 static void sdbout_begin_block		PARAMS ((unsigned int, unsigned int));
103 static void sdbout_end_block		PARAMS ((unsigned int, unsigned int));
104 static void sdbout_source_line		PARAMS ((unsigned int, const char *));
105 static void sdbout_end_epilogue		PARAMS ((unsigned int, const char *));
106 static void sdbout_global_decl		PARAMS ((tree));
107 #ifndef MIPS_DEBUGGING_INFO
108 static void sdbout_begin_prologue	PARAMS ((unsigned int, const char *));
109 #endif
110 static void sdbout_end_prologue		PARAMS ((unsigned int, const char *));
111 static void sdbout_begin_function	PARAMS ((tree));
112 static void sdbout_end_function		PARAMS ((unsigned int));
113 static void sdbout_toplevel_data	PARAMS ((tree));
114 static void sdbout_label		PARAMS ((rtx));
115 static char *gen_fake_label		PARAMS ((void));
116 static int plain_type			PARAMS ((tree));
117 static int template_name_p		PARAMS ((tree));
118 static void sdbout_record_type_name	PARAMS ((tree));
119 static int plain_type_1			PARAMS ((tree, int));
120 static void sdbout_block		PARAMS ((tree));
121 static void sdbout_syms			PARAMS ((tree));
122 #ifdef SDB_ALLOW_FORWARD_REFERENCES
123 static void sdbout_queue_anonymous_type	PARAMS ((tree));
124 static void sdbout_dequeue_anonymous_types PARAMS ((void));
125 #endif
126 static void sdbout_type			PARAMS ((tree));
127 static void sdbout_field_types		PARAMS ((tree));
128 static void sdbout_one_type		PARAMS ((tree));
129 static void sdbout_parms		PARAMS ((tree));
130 static void sdbout_reg_parms		PARAMS ((tree));
131 static void sdbout_global_decl		PARAMS ((tree));
132 
133 /* Random macros describing parts of SDB data.  */
134 
135 /* Put something here if lines get too long */
136 #define CONTIN
137 
138 /* Default value of delimiter is ";".  */
139 #ifndef SDB_DELIM
140 #define SDB_DELIM	";"
141 #endif
142 
143 /* Maximum number of dimensions the assembler will allow.  */
144 #ifndef SDB_MAX_DIM
145 #define SDB_MAX_DIM 4
146 #endif
147 
148 #ifndef PUT_SDB_SCL
149 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
150 #endif
151 
152 #ifndef PUT_SDB_INT_VAL
153 #define PUT_SDB_INT_VAL(a) \
154  do {									\
155    fputs ("\t.val\t", asm_out_file);		       			\
156    fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
157    fprintf (asm_out_file, "%s", SDB_DELIM);				\
158  } while (0)
159 
160 #endif
161 
162 #ifndef PUT_SDB_VAL
163 #define PUT_SDB_VAL(a)				\
164 ( fputs ("\t.val\t", asm_out_file),		\
165   output_addr_const (asm_out_file, (a)),	\
166   fprintf (asm_out_file, SDB_DELIM))
167 #endif
168 
169 #ifndef PUT_SDB_DEF
170 #define PUT_SDB_DEF(a)				\
171 do { fprintf (asm_out_file, "\t.def\t");	\
172      assemble_name (asm_out_file, a); 	\
173      fprintf (asm_out_file, SDB_DELIM); } while (0)
174 #endif
175 
176 #ifndef PUT_SDB_PLAIN_DEF
177 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
178 #endif
179 
180 #ifndef PUT_SDB_ENDEF
181 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
182 #endif
183 
184 #ifndef PUT_SDB_TYPE
185 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
186 #endif
187 
188 #ifndef PUT_SDB_SIZE
189 #define PUT_SDB_SIZE(a) \
190  do {									\
191    fputs ("\t.size\t", asm_out_file);					\
192    fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
193    fprintf (asm_out_file, "%s", SDB_DELIM);				\
194  } while(0)
195 #endif
196 
197 #ifndef PUT_SDB_START_DIM
198 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
199 #endif
200 
201 #ifndef PUT_SDB_NEXT_DIM
202 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
203 #endif
204 
205 #ifndef PUT_SDB_LAST_DIM
206 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
207 #endif
208 
209 #ifndef PUT_SDB_TAG
210 #define PUT_SDB_TAG(a)				\
211 do { fprintf (asm_out_file, "\t.tag\t");	\
212      assemble_name (asm_out_file, a);	\
213      fprintf (asm_out_file, SDB_DELIM); } while (0)
214 #endif
215 
216 #ifndef PUT_SDB_BLOCK_START
217 #define PUT_SDB_BLOCK_START(LINE)		\
218   fprintf (asm_out_file,			\
219 	   "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
220 	   SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
221 #endif
222 
223 #ifndef PUT_SDB_BLOCK_END
224 #define PUT_SDB_BLOCK_END(LINE)			\
225   fprintf (asm_out_file,			\
226 	   "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n",  \
227 	   SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
228 #endif
229 
230 #ifndef PUT_SDB_FUNCTION_START
231 #define PUT_SDB_FUNCTION_START(LINE)		\
232   fprintf (asm_out_file,			\
233 	   "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
234 	   SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
235 #endif
236 
237 #ifndef PUT_SDB_FUNCTION_END
238 #define PUT_SDB_FUNCTION_END(LINE)		\
239   fprintf (asm_out_file,			\
240 	   "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
241 	   SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
242 #endif
243 
244 #ifndef SDB_GENERATE_FAKE
245 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
246   sprintf ((BUFFER), ".%dfake", (NUMBER));
247 #endif
248 
249 /* Return the sdb tag identifier string for TYPE
250    if TYPE has already been defined; otherwise return a null pointer.  */
251 
252 #define KNOWN_TYPE_TAG(type)  TYPE_SYMTAB_POINTER (type)
253 
254 /* Set the sdb tag identifier string for TYPE to NAME.  */
255 
256 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
257   TYPE_SYMTAB_POINTER (TYPE) = (NAME)
258 
259 /* Return the name (a string) of the struct, union or enum tag
260    described by the TREE_LIST node LINK.  This is 0 for an anonymous one.  */
261 
262 #define TAG_NAME(link) \
263   (((link) && TREE_PURPOSE ((link)) \
264     && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
265    ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
266 
267 /* Ensure we don't output a negative line number.  */
268 #define MAKE_LINE_SAFE(line)  \
269   if ((int) line <= sdb_begin_function_line) \
270     line = sdb_begin_function_line + 1
271 
272 /* Perform linker optimization of merging header file definitions together
273    for targets with MIPS_DEBUGGING_INFO defined.  This won't work without a
274    post 960826 version of GAS.  Nothing breaks with earlier versions of GAS,
275    the optimization just won't be done.  The native assembler already has the
276    necessary support.  */
277 
278 #ifdef MIPS_DEBUGGING_INFO
279 
280 #ifndef PUT_SDB_SRC_FILE
281 #define PUT_SDB_SRC_FILE(FILENAME) \
282 output_file_directive (asm_out_file, (FILENAME))
283 #endif
284 
285 /* ECOFF linkers have an optimization that does the same kind of thing as
286    N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
287    executable.  To achieve this, GCC must output a .file for each file
288    name change.  */
289 
290 /* This is a stack of input files.  */
291 
292 struct sdb_file
293 {
294   struct sdb_file *next;
295   const char *name;
296 };
297 
298 /* This is the top of the stack.  */
299 
300 static struct sdb_file *current_file;
301 
302 #endif /* MIPS_DEBUGGING_INFO */
303 
304 /* The debug hooks structure.  */
305 const struct gcc_debug_hooks sdb_debug_hooks =
306 {
307   sdbout_init,			/* init */
308   sdbout_finish,		/* finish */
309   debug_nothing_int_charstar,	/* define */
310   debug_nothing_int_charstar,	/* undef */
311   sdbout_start_source_file,	/* start_source_file */
312   sdbout_end_source_file,	/* end_source_file */
313   sdbout_begin_block,		/* begin_block */
314   sdbout_end_block,		/* end_block */
315   debug_true_tree,		/* ignore_block */
316   sdbout_source_line,		/* source_line */
317 #ifdef MIPS_DEBUGGING_INFO
318   /* Defer on MIPS systems so that parameter descriptions follow
319      function entry.  */
320   debug_nothing_int_charstar,	/* begin_prologue */
321   sdbout_end_prologue,		/* end_prologue */
322 #else
323   sdbout_begin_prologue,	/* begin_prologue */
324   debug_nothing_int_charstar,	/* end_prologue */
325 #endif
326   sdbout_end_epilogue,		/* end_epilogue */
327   sdbout_begin_function,	/* begin_function */
328   sdbout_end_function,		/* end_function */
329   debug_nothing_tree,		/* function_decl */
330   sdbout_global_decl,		/* global_decl */
331   debug_nothing_tree,		/* deferred_inline_function */
332   debug_nothing_tree,		/* outlining_inline_function */
333   sdbout_label
334 };
335 
336 #if 0
337 
338 /* return the tag identifier for type
339  */
340 
341 char *
342 tag_of_ru_type (type,link)
343      tree type,link;
344 {
345   if (TYPE_SYMTAB_ADDRESS (type))
346     return TYPE_SYMTAB_ADDRESS (type);
347   if (link && TREE_PURPOSE (link)
348       && IDENTIFIER_POINTER (TREE_PURPOSE (link)))
349     TYPE_SYMTAB_ADDRESS (type) = IDENTIFIER_POINTER (TREE_PURPOSE (link));
350   else
351     return (char *) TYPE_SYMTAB_ADDRESS (type);
352 }
353 #endif
354 
355 /* Return a unique string to name an anonymous type.  */
356 
357 static char *
gen_fake_label()358 gen_fake_label ()
359 {
360   char label[10];
361   char *labelstr;
362   SDB_GENERATE_FAKE (label, unnamed_struct_number);
363   unnamed_struct_number++;
364   labelstr = xstrdup (label);
365   return labelstr;
366 }
367 
368 /* Return the number which describes TYPE for SDB.
369    For pointers, etc., this function is recursive.
370    Each record, union or enumeral type must already have had a
371    tag number output.  */
372 
373 /* The number is given by d6d5d4d3d2d1bbbb
374    where bbbb is 4 bit basic type, and di indicate  one of notype,ptr,fn,array.
375    Thus, char *foo () has bbbb=T_CHAR
376 			  d1=D_FCN
377 			  d2=D_PTR
378  N_BTMASK=     017       1111     basic type field.
379  N_TSHIFT=       2                derived type shift
380  N_BTSHFT=       4                Basic type shift */
381 
382 /* Produce the number that describes a pointer, function or array type.
383    PREV is the number describing the target, value or element type.
384    DT_type describes how to transform that type.  */
385 #define PUSH_DERIVED_LEVEL(DT_type,PREV)		\
386   ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT)		\
387    | ((int) DT_type << (int) N_BTSHFT)			\
388    | ((PREV) & (int) N_BTMASK))
389 
390 /* Number of elements used in sdb_dims.  */
391 static int sdb_n_dims = 0;
392 
393 /* Table of array dimensions of current type.  */
394 static int sdb_dims[SDB_MAX_DIM];
395 
396 /* Size of outermost array currently being processed.  */
397 static int sdb_type_size = -1;
398 
399 static int
plain_type(type)400 plain_type (type)
401      tree type;
402 {
403   int val = plain_type_1 (type, 0);
404 
405   /* If we have already saved up some array dimensions, print them now.  */
406   if (sdb_n_dims > 0)
407     {
408       int i;
409       PUT_SDB_START_DIM;
410       for (i = sdb_n_dims - 1; i > 0; i--)
411 	PUT_SDB_NEXT_DIM (sdb_dims[i]);
412       PUT_SDB_LAST_DIM (sdb_dims[0]);
413       sdb_n_dims = 0;
414 
415       sdb_type_size = int_size_in_bytes (type);
416       /* Don't kill sdb if type is not laid out or has variable size.  */
417       if (sdb_type_size < 0)
418 	sdb_type_size = 0;
419     }
420   /* If we have computed the size of an array containing this type,
421      print it now.  */
422   if (sdb_type_size >= 0)
423     {
424       PUT_SDB_SIZE (sdb_type_size);
425       sdb_type_size = -1;
426     }
427   return val;
428 }
429 
430 static int
template_name_p(name)431 template_name_p (name)
432      tree name;
433 {
434   const char *ptr = IDENTIFIER_POINTER (name);
435   while (*ptr && *ptr != '<')
436     ptr++;
437 
438   return *ptr != '\0';
439 }
440 
441 static void
sdbout_record_type_name(type)442 sdbout_record_type_name (type)
443      tree type;
444 {
445   const char *name = 0;
446   int no_name;
447 
448   if (KNOWN_TYPE_TAG (type))
449     return;
450 
451   if (TYPE_NAME (type) != 0)
452     {
453       tree t = 0;
454 
455       /* Find the IDENTIFIER_NODE for the type name.  */
456       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
457 	t = TYPE_NAME (type);
458       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
459 	{
460 	  t = DECL_NAME (TYPE_NAME (type));
461 	  /* The DECL_NAME for templates includes "<>", which breaks
462 	     most assemblers.  Use its assembler name instead, which
463 	     has been mangled into being safe.  */
464 	  if (t && template_name_p (t))
465 	    t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
466 	}
467 
468       /* Now get the name as a string, or invent one.  */
469       if (t != NULL_TREE)
470 	name = IDENTIFIER_POINTER (t);
471     }
472 
473   no_name = (name == 0 || *name == 0);
474   if (no_name)
475     name = gen_fake_label ();
476 
477   SET_KNOWN_TYPE_TAG (type, name);
478 #ifdef SDB_ALLOW_FORWARD_REFERENCES
479   if (no_name)
480     sdbout_queue_anonymous_type (type);
481 #endif
482 }
483 
484 /* Return the .type value for type TYPE.
485 
486    LEVEL indicates how many levels deep we have recursed into the type.
487    The SDB debug format can only represent 6 derived levels of types.
488    After that, we must output inaccurate debug info.  We deliberately
489    stop before the 7th level, so that ADA recursive types will not give an
490    infinite loop.  */
491 
492 static int
plain_type_1(type,level)493 plain_type_1 (type, level)
494      tree type;
495      int level;
496 {
497   if (type == 0)
498     type = void_type_node;
499   else if (type == error_mark_node)
500     type = integer_type_node;
501   else
502     type = TYPE_MAIN_VARIANT (type);
503 
504   switch (TREE_CODE (type))
505     {
506     case VOID_TYPE:
507       return T_VOID;
508     case BOOLEAN_TYPE:
509     case INTEGER_TYPE:
510       {
511 	int size = int_size_in_bytes (type) * BITS_PER_UNIT;
512 
513 	/* Carefully distinguish all the standard types of C,
514 	   without messing up if the language is not C.
515 	   Note that we check only for the names that contain spaces;
516 	   other names might occur by coincidence in other languages.  */
517 	if (TYPE_NAME (type) != 0
518 	    && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
519 	    && DECL_NAME (TYPE_NAME (type)) != 0
520 	    && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
521 	  {
522 	    const char *const name
523 	      = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
524 
525 	    if (!strcmp (name, "char"))
526 	      return T_CHAR;
527 	    if (!strcmp (name, "unsigned char"))
528 	      return T_UCHAR;
529 	    if (!strcmp (name, "signed char"))
530 	      return T_CHAR;
531 	    if (!strcmp (name, "int"))
532 	      return T_INT;
533 	    if (!strcmp (name, "unsigned int"))
534 	      return T_UINT;
535 	    if (!strcmp (name, "short int"))
536 	      return T_SHORT;
537 	    if (!strcmp (name, "short unsigned int"))
538 	      return T_USHORT;
539 	    if (!strcmp (name, "long int"))
540 	      return T_LONG;
541 	    if (!strcmp (name, "long unsigned int"))
542 	      return T_ULONG;
543 	  }
544 
545 	if (size == INT_TYPE_SIZE)
546 	  return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
547 	if (size == CHAR_TYPE_SIZE)
548 	  return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
549 	if (size == SHORT_TYPE_SIZE)
550 	  return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
551 	if (size == LONG_TYPE_SIZE)
552 	  return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
553 	if (size == LONG_LONG_TYPE_SIZE)	/* better than nothing */
554 	  return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
555 	return 0;
556       }
557 
558     case REAL_TYPE:
559       {
560 	int precision = TYPE_PRECISION (type);
561 	if (precision == FLOAT_TYPE_SIZE)
562 	  return T_FLOAT;
563 	if (precision == DOUBLE_TYPE_SIZE)
564 	  return T_DOUBLE;
565 #ifdef EXTENDED_SDB_BASIC_TYPES
566 	if (precision == LONG_DOUBLE_TYPE_SIZE)
567 	  return T_LNGDBL;
568 #else
569 	if (precision == LONG_DOUBLE_TYPE_SIZE)
570 	  return T_DOUBLE;	/* better than nothing */
571 #endif
572 	return 0;
573       }
574 
575     case ARRAY_TYPE:
576       {
577 	int m;
578 	if (level >= 6)
579 	  return T_VOID;
580 	else
581 	  m = plain_type_1 (TREE_TYPE (type), level+1);
582 	if (sdb_n_dims < SDB_MAX_DIM)
583 	  sdb_dims[sdb_n_dims++]
584 	    = (TYPE_DOMAIN (type)
585 	       && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
586 	       && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
587 	       && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
588 	       && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
589 	       ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
590 		  - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
591 	       : 0);
592 
593 	return PUSH_DERIVED_LEVEL (DT_ARY, m);
594       }
595 
596     case RECORD_TYPE:
597     case UNION_TYPE:
598     case QUAL_UNION_TYPE:
599     case ENUMERAL_TYPE:
600       {
601 	char *tag;
602 #ifdef SDB_ALLOW_FORWARD_REFERENCES
603 	sdbout_record_type_name (type);
604 #endif
605 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
606 	if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
607 #ifdef SDB_ALLOW_FORWARD_REFERENCES
608 	    || TYPE_MODE (type) != VOIDmode
609 #endif
610 	    )
611 #endif
612 	  {
613 	    /* Output the referenced structure tag name
614 	       only if the .def has already been finished.
615 	       At least on 386, the Unix assembler
616 	       cannot handle forward references to tags.  */
617 	    /* But the 88100, it requires them, sigh...  */
618 	    /* And the MIPS requires unknown refs as well...  */
619 	    tag = KNOWN_TYPE_TAG (type);
620 	    PUT_SDB_TAG (tag);
621 	    /* These 3 lines used to follow the close brace.
622 	       However, a size of 0 without a tag implies a tag of 0,
623 	       so if we don't know a tag, we can't mention the size.  */
624 	    sdb_type_size = int_size_in_bytes (type);
625 	    if (sdb_type_size < 0)
626 	      sdb_type_size = 0;
627 	  }
628 	return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
629 		: (TREE_CODE (type) == UNION_TYPE) ? T_UNION
630 		: (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
631 		: T_ENUM);
632       }
633     case POINTER_TYPE:
634     case REFERENCE_TYPE:
635       {
636 	int m;
637 	if (level >= 6)
638 	  return T_VOID;
639 	else
640 	  m = plain_type_1 (TREE_TYPE (type), level+1);
641 	return PUSH_DERIVED_LEVEL (DT_PTR, m);
642       }
643     case FUNCTION_TYPE:
644     case METHOD_TYPE:
645       {
646 	int m;
647 	if (level >= 6)
648 	  return T_VOID;
649 	else
650 	  m = plain_type_1 (TREE_TYPE (type), level+1);
651 	return PUSH_DERIVED_LEVEL (DT_FCN, m);
652       }
653     default:
654       return 0;
655     }
656 }
657 
658 /* Output the symbols defined in block number DO_BLOCK.
659 
660    This function works by walking the tree structure of blocks,
661    counting blocks until it finds the desired block.  */
662 
663 static int do_block = 0;
664 
665 static void
sdbout_block(block)666 sdbout_block (block)
667      tree block;
668 {
669   while (block)
670     {
671       /* Ignore blocks never expanded or otherwise marked as real.  */
672       if (TREE_USED (block))
673 	{
674 	  /* When we reach the specified block, output its symbols.  */
675 	  if (BLOCK_NUMBER (block) == do_block)
676 	    sdbout_syms (BLOCK_VARS (block));
677 
678 	  /* If we are past the specified block, stop the scan.  */
679 	  if (BLOCK_NUMBER (block) > do_block)
680 	    return;
681 
682 	  /* Scan the blocks within this block.  */
683 	  sdbout_block (BLOCK_SUBBLOCKS (block));
684 	}
685 
686       block = BLOCK_CHAIN (block);
687     }
688 }
689 
690 /* Call sdbout_symbol on each decl in the chain SYMS.  */
691 
692 static void
sdbout_syms(syms)693 sdbout_syms (syms)
694      tree syms;
695 {
696   while (syms)
697     {
698       if (TREE_CODE (syms) != LABEL_DECL)
699 	sdbout_symbol (syms, 1);
700       syms = TREE_CHAIN (syms);
701     }
702 }
703 
704 /* Output SDB information for a symbol described by DECL.
705    LOCAL is nonzero if the symbol is not file-scope.  */
706 
707 void
sdbout_symbol(decl,local)708 sdbout_symbol (decl, local)
709      tree decl;
710      int local;
711 {
712   tree type = TREE_TYPE (decl);
713   tree context = NULL_TREE;
714   rtx value;
715   int regno = -1;
716   const char *name;
717 
718   sdbout_one_type (type);
719 
720 #if 0 /* This loses when functions are marked to be ignored,
721 	 which happens in the C++ front end.  */
722   if (DECL_IGNORED_P (decl))
723     return;
724 #endif
725 
726   switch (TREE_CODE (decl))
727     {
728     case CONST_DECL:
729       /* Enum values are defined by defining the enum type.  */
730       return;
731 
732     case FUNCTION_DECL:
733       /* Don't mention a nested function under its parent.  */
734       context = decl_function_context (decl);
735       if (context == current_function_decl)
736 	return;
737       /* Check DECL_INITIAL to distinguish declarations from definitions.
738 	 Don't output debug info here for declarations; they will have
739 	 a DECL_INITIAL value of 0.  */
740       if (! DECL_INITIAL (decl))
741 	return;
742       if (GET_CODE (DECL_RTL (decl)) != MEM
743 	  || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
744 	return;
745       PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
746       PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
747       PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
748       break;
749 
750     case TYPE_DECL:
751       /* Done with tagged types.  */
752       if (DECL_NAME (decl) == 0)
753 	return;
754       if (DECL_IGNORED_P (decl))
755 	return;
756 
757       /* Output typedef name.  */
758       if (template_name_p (DECL_NAME (decl)))
759 	PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
760       else
761 	PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
762       PUT_SDB_SCL (C_TPDEF);
763       break;
764 
765     case PARM_DECL:
766       /* Parm decls go in their own separate chains
767 	 and are output by sdbout_reg_parms and sdbout_parms.  */
768       abort ();
769 
770     case VAR_DECL:
771       /* Don't mention a variable that is external.
772 	 Let the file that defines it describe it.  */
773       if (DECL_EXTERNAL (decl))
774 	return;
775 
776       /* Ignore __FUNCTION__, etc.  */
777       if (DECL_IGNORED_P (decl))
778 	return;
779 
780       /* If there was an error in the declaration, don't dump core
781 	 if there is no RTL associated with the variable doesn't
782 	 exist.  */
783       if (!DECL_RTL_SET_P (decl))
784 	return;
785 
786       SET_DECL_RTL (decl,
787 		    eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
788 #ifdef LEAF_REG_REMAP
789       if (current_function_uses_only_leaf_regs)
790 	leaf_renumber_regs_insn (DECL_RTL (decl));
791 #endif
792       value = DECL_RTL (decl);
793 
794       /* Don't mention a variable at all
795 	 if it was completely optimized into nothingness.
796 
797 	 If DECL was from an inline function, then its rtl
798 	 is not identically the rtl that was used in this
799 	 particular compilation.  */
800       if (GET_CODE (value) == REG)
801 	{
802 	  regno = REGNO (value);
803 	  if (regno >= FIRST_PSEUDO_REGISTER)
804 	    return;
805 	}
806       else if (GET_CODE (value) == SUBREG)
807 	{
808 	  while (GET_CODE (value) == SUBREG)
809 	    value = SUBREG_REG (value);
810 	  if (GET_CODE (value) == REG)
811 	    {
812 	      if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
813 		return;
814 	    }
815 	  regno = REGNO (alter_subreg (&value));
816 	  SET_DECL_RTL (decl, value);
817 	}
818       /* Don't output anything if an auto variable
819 	 gets RTL that is static.
820 	 GAS version 2.2 can't handle such output.  */
821       else if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0))
822 	       && ! TREE_STATIC (decl))
823 	return;
824 
825       /* Emit any structure, union, or enum type that has not been output.
826 	 This occurs for tag-less structs (et al) used to declare variables
827 	 within functions.  */
828       if (TREE_CODE (type) == ENUMERAL_TYPE
829 	  || TREE_CODE (type) == RECORD_TYPE
830 	  || TREE_CODE (type) == UNION_TYPE
831 	  || TREE_CODE (type) == QUAL_UNION_TYPE)
832 	{
833 	  if (COMPLETE_TYPE_P (type)		/* not a forward reference */
834 	      && KNOWN_TYPE_TAG (type) == 0)	/* not yet declared */
835 	    sdbout_one_type (type);
836 	}
837 
838       /* Defer SDB information for top-level initialized variables! */
839       if (! local
840 	  && GET_CODE (value) == MEM
841 	  && DECL_INITIAL (decl))
842 	return;
843 
844       /* C++ in 2.3 makes nameless symbols.  That will be fixed later.
845 	 For now, avoid crashing.  */
846       if (DECL_NAME (decl) == NULL_TREE)
847 	return;
848 
849       /* Record the name for, starting a symtab entry.  */
850       if (local)
851 	name = IDENTIFIER_POINTER (DECL_NAME (decl));
852       else
853 	name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
854 
855       if (GET_CODE (value) == MEM
856 	  && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
857 	{
858 	  PUT_SDB_DEF (name);
859 	  if (TREE_PUBLIC (decl))
860 	    {
861 	      PUT_SDB_VAL (XEXP (value, 0));
862 	      PUT_SDB_SCL (C_EXT);
863 	    }
864 	  else
865 	    {
866 	      PUT_SDB_VAL (XEXP (value, 0));
867 	      PUT_SDB_SCL (C_STAT);
868 	    }
869 	}
870       else if (regno >= 0)
871 	{
872 	  PUT_SDB_DEF (name);
873 	  PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
874 	  PUT_SDB_SCL (C_REG);
875 	}
876       else if (GET_CODE (value) == MEM
877 	       && (GET_CODE (XEXP (value, 0)) == MEM
878 		   || (GET_CODE (XEXP (value, 0)) == REG
879 		       && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
880 		       && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
881 	/* If the value is indirect by memory or by a register
882 	   that isn't the frame pointer
883 	   then it means the object is variable-sized and address through
884 	   that register or stack slot.  COFF has no way to represent this
885 	   so all we can do is output the variable as a pointer.  */
886 	{
887 	  PUT_SDB_DEF (name);
888 	  if (GET_CODE (XEXP (value, 0)) == REG)
889 	    {
890 	      PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
891 	      PUT_SDB_SCL (C_REG);
892 	    }
893 	  else
894 	    {
895 	      /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
896 		 (CONST_INT...)))).
897 		 We want the value of that CONST_INT.  */
898 	      /* Encore compiler hates a newline in a macro arg, it seems.  */
899 	      PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
900 			       (XEXP (XEXP (value, 0), 0)));
901 	      PUT_SDB_SCL (C_AUTO);
902 	    }
903 
904 	  /* Effectively do build_pointer_type, but don't cache this type,
905 	     since it might be temporary whereas the type it points to
906 	     might have been saved for inlining.  */
907 	  /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
908 	  type = make_node (POINTER_TYPE);
909 	  TREE_TYPE (type) = TREE_TYPE (decl);
910 	}
911       else if (GET_CODE (value) == MEM
912 	       && ((GET_CODE (XEXP (value, 0)) == PLUS
913 		    && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
914 		    && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
915 		   /* This is for variables which are at offset zero from
916 		      the frame pointer.  This happens on the Alpha.
917 		      Non-frame pointer registers are excluded above.  */
918 		   || (GET_CODE (XEXP (value, 0)) == REG)))
919 	{
920 	  /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
921 	     or (MEM (REG...)).  We want the value of that CONST_INT
922 	     or zero.  */
923 	  PUT_SDB_DEF (name);
924 	  PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
925 	  PUT_SDB_SCL (C_AUTO);
926 	}
927       else
928 	{
929 	  /* It is something we don't know how to represent for SDB.  */
930 	  return;
931 	}
932       break;
933 
934     default:
935       break;
936     }
937   PUT_SDB_TYPE (plain_type (type));
938   PUT_SDB_ENDEF;
939 }
940 
941 /* Output SDB information for a top-level initialized variable
942    that has been delayed.  */
943 
944 static void
sdbout_toplevel_data(decl)945 sdbout_toplevel_data (decl)
946      tree decl;
947 {
948   tree type = TREE_TYPE (decl);
949 
950   if (DECL_IGNORED_P (decl))
951     return;
952 
953   if (! (TREE_CODE (decl) == VAR_DECL
954 	 && GET_CODE (DECL_RTL (decl)) == MEM
955 	 && DECL_INITIAL (decl)))
956     abort ();
957 
958   PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
959   PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
960   if (TREE_PUBLIC (decl))
961     {
962       PUT_SDB_SCL (C_EXT);
963     }
964   else
965     {
966       PUT_SDB_SCL (C_STAT);
967     }
968   PUT_SDB_TYPE (plain_type (type));
969   PUT_SDB_ENDEF;
970 }
971 
972 #ifdef SDB_ALLOW_FORWARD_REFERENCES
973 
974 /* Machinery to record and output anonymous types.  */
975 
976 static void
sdbout_queue_anonymous_type(type)977 sdbout_queue_anonymous_type (type)
978      tree type;
979 {
980   anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
981 }
982 
983 static void
sdbout_dequeue_anonymous_types()984 sdbout_dequeue_anonymous_types ()
985 {
986   tree types, link;
987 
988   while (anonymous_types)
989     {
990       types = nreverse (anonymous_types);
991       anonymous_types = NULL_TREE;
992 
993       for (link = types; link; link = TREE_CHAIN (link))
994 	{
995 	  tree type = TREE_VALUE (link);
996 
997 	  if (type && ! TREE_ASM_WRITTEN (type))
998 	    sdbout_one_type (type);
999 	}
1000     }
1001 }
1002 
1003 #endif
1004 
1005 /* Given a chain of ..._TYPE nodes, all of which have names,
1006    output definitions of those names, as typedefs.  */
1007 
1008 void
sdbout_types(types)1009 sdbout_types (types)
1010      tree types;
1011 {
1012   tree link;
1013 
1014   for (link = types; link; link = TREE_CHAIN (link))
1015     sdbout_one_type (link);
1016 
1017 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1018   sdbout_dequeue_anonymous_types ();
1019 #endif
1020 }
1021 
1022 static void
sdbout_type(type)1023 sdbout_type (type)
1024      tree type;
1025 {
1026   if (type == error_mark_node)
1027     type = integer_type_node;
1028   PUT_SDB_TYPE (plain_type (type));
1029 }
1030 
1031 /* Output types of the fields of type TYPE, if they are structs.
1032 
1033    Formerly did not chase through pointer types, since that could be circular.
1034    They must come before TYPE, since forward refs are not allowed.
1035    Now james@bigtex.cactus.org says to try them.  */
1036 
1037 static void
sdbout_field_types(type)1038 sdbout_field_types (type)
1039      tree type;
1040 {
1041   tree tail;
1042 
1043   for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1044     /* This condition should match the one for emitting the actual
1045        members below.  */
1046     if (TREE_CODE (tail) == FIELD_DECL
1047 	&& DECL_NAME (tail)
1048 	&& DECL_SIZE (tail)
1049 	&& host_integerp (DECL_SIZE (tail), 1)
1050 	&& host_integerp (bit_position (tail), 0))
1051       {
1052 	if (POINTER_TYPE_P (TREE_TYPE (tail)))
1053 	  sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1054 	else
1055 	  sdbout_one_type (TREE_TYPE (tail));
1056       }
1057 }
1058 
1059 /* Use this to put out the top level defined record and union types
1060    for later reference.  If this is a struct with a name, then put that
1061    name out.  Other unnamed structs will have .xxfake labels generated so
1062    that they may be referred to later.
1063    The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1064    It may NOT be called recursively.  */
1065 
1066 static void
sdbout_one_type(type)1067 sdbout_one_type (type)
1068      tree type;
1069 {
1070   if (current_function_decl != NULL_TREE
1071       && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1072     ; /* Don't change section amid function.  */
1073   else
1074     text_section ();
1075 
1076   switch (TREE_CODE (type))
1077     {
1078     case RECORD_TYPE:
1079     case UNION_TYPE:
1080     case QUAL_UNION_TYPE:
1081     case ENUMERAL_TYPE:
1082       type = TYPE_MAIN_VARIANT (type);
1083       /* Don't output a type twice.  */
1084       if (TREE_ASM_WRITTEN (type))
1085 	/* James said test TREE_ASM_BEING_WRITTEN here.  */
1086 	return;
1087 
1088       /* Output nothing if type is not yet defined.  */
1089       if (!COMPLETE_TYPE_P (type))
1090 	return;
1091 
1092       TREE_ASM_WRITTEN (type) = 1;
1093 #if 1
1094       /* This is reputed to cause trouble with the following case,
1095 	 but perhaps checking TYPE_SIZE above will fix it.  */
1096 
1097       /* Here is a test case:
1098 
1099 	struct foo {
1100 	  struct badstr *bbb;
1101 	} forwardref;
1102 
1103 	typedef struct intermediate {
1104 	  int aaaa;
1105 	} intermediate_ref;
1106 
1107 	typedef struct badstr {
1108 	  int ccccc;
1109 	} badtype;   */
1110 
1111 #if 0
1112       TREE_ASM_BEING_WRITTEN (type) = 1;
1113 #endif
1114       /* This change, which ought to make better output,
1115 	 used to make the COFF assembler unhappy.
1116 	 Changes involving KNOWN_TYPE_TAG may fix the problem.  */
1117       /* Before really doing anything, output types we want to refer to.  */
1118       /* Note that in version 1 the following two lines
1119 	 are not used if forward references are in use.  */
1120       if (TREE_CODE (type) != ENUMERAL_TYPE)
1121 	sdbout_field_types (type);
1122 #if 0
1123       TREE_ASM_WRITTEN (type) = 1;
1124 #endif
1125 #endif
1126 
1127       /* Output a structure type.  */
1128       {
1129 	int size = int_size_in_bytes (type);
1130 	int member_scl = 0;
1131 	tree tem;
1132 	int i, n_baseclasses = 0;
1133 
1134 	/* Record the type tag, but not in its permanent place just yet.  */
1135 	sdbout_record_type_name (type);
1136 
1137 	PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1138 
1139 	switch (TREE_CODE (type))
1140 	  {
1141 	  case UNION_TYPE:
1142 	  case QUAL_UNION_TYPE:
1143 	    PUT_SDB_SCL (C_UNTAG);
1144 	    PUT_SDB_TYPE (T_UNION);
1145 	    member_scl = C_MOU;
1146 	    break;
1147 
1148 	  case RECORD_TYPE:
1149 	    PUT_SDB_SCL (C_STRTAG);
1150 	    PUT_SDB_TYPE (T_STRUCT);
1151 	    member_scl = C_MOS;
1152 	    break;
1153 
1154 	  case ENUMERAL_TYPE:
1155 	    PUT_SDB_SCL (C_ENTAG);
1156 	    PUT_SDB_TYPE (T_ENUM);
1157 	    member_scl = C_MOE;
1158 	    break;
1159 
1160 	  default:
1161 	    break;
1162 	  }
1163 
1164 	PUT_SDB_SIZE (size);
1165 	PUT_SDB_ENDEF;
1166 
1167 	/* Print out the base class information with fields
1168 	   named after the types they hold.  */
1169 	/* This is only relevant to aggregate types.  TYPE_BINFO is used
1170 	   for other purposes in an ENUMERAL_TYPE, so we must exclude that
1171 	   case.  */
1172 	if (TREE_CODE (type) != ENUMERAL_TYPE)
1173 	  {
1174 	    if (TYPE_BINFO (type)
1175 		&& TYPE_BINFO_BASETYPES (type))
1176 	      n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1177 	    for (i = 0; i < n_baseclasses; i++)
1178 	      {
1179 		tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)),
1180 					   i);
1181 		tree child_type = BINFO_TYPE (child);
1182 		tree child_type_name;
1183 		if (TYPE_NAME (child_type) == 0)
1184 		  continue;
1185 		if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1186 		  child_type_name = TYPE_NAME (child_type);
1187 		else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1188 		  {
1189 		    child_type_name = DECL_NAME (TYPE_NAME (child_type));
1190 		    if (child_type_name && template_name_p (child_type_name))
1191 		      child_type_name
1192 			= DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1193 		  }
1194 		else
1195 		  continue;
1196 
1197 		CONTIN;
1198 		PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1199 		PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1200 		PUT_SDB_SCL (member_scl);
1201 		sdbout_type (BINFO_TYPE (child));
1202 		PUT_SDB_ENDEF;
1203 	      }
1204 	  }
1205 
1206 	/* output the individual fields */
1207 
1208 	if (TREE_CODE (type) == ENUMERAL_TYPE)
1209 	  {
1210 	    for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1211 	      if (host_integerp (TREE_VALUE (tem), 0))
1212 		{
1213 		  PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1214 		  PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1215 		  PUT_SDB_SCL (C_MOE);
1216 		  PUT_SDB_TYPE (T_MOE);
1217 		  PUT_SDB_ENDEF;
1218 		}
1219 	  }
1220 	else			/* record or union type */
1221 	  for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1222 	    /* Output the name, type, position (in bits), size (in bits)
1223 	       of each field.  */
1224 
1225 	    /* Omit here the nameless fields that are used to skip bits.
1226 	       Also omit fields with variable size or position.
1227 	       Also omit non FIELD_DECL nodes that GNU C++ may put here.  */
1228 	    if (TREE_CODE (tem) == FIELD_DECL
1229 		&& DECL_NAME (tem)
1230 		&& DECL_SIZE (tem)
1231 		&& host_integerp (DECL_SIZE (tem), 1)
1232 		&& host_integerp (bit_position (tem), 0))
1233 	      {
1234 		const char *name;
1235 
1236 		CONTIN;
1237 		name = IDENTIFIER_POINTER (DECL_NAME (tem));
1238 		PUT_SDB_DEF (name);
1239 		if (DECL_BIT_FIELD_TYPE (tem))
1240 		  {
1241 		    PUT_SDB_INT_VAL (int_bit_position (tem));
1242 		    PUT_SDB_SCL (C_FIELD);
1243 		    sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1244 		    PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1245 		  }
1246 		else
1247 		  {
1248 		    PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1249 		    PUT_SDB_SCL (member_scl);
1250 		    sdbout_type (TREE_TYPE (tem));
1251 		  }
1252 		PUT_SDB_ENDEF;
1253 	      }
1254 	/* output end of a structure,union, or enumeral definition */
1255 
1256 	PUT_SDB_PLAIN_DEF ("eos");
1257 	PUT_SDB_INT_VAL (size);
1258 	PUT_SDB_SCL (C_EOS);
1259 	PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1260 	PUT_SDB_SIZE (size);
1261 	PUT_SDB_ENDEF;
1262 	break;
1263 
1264       default:
1265 	break;
1266       }
1267     }
1268 }
1269 
1270 /* The following two functions output definitions of function parameters.
1271    Each parameter gets a definition locating it in the parameter list.
1272    Each parameter that is a register variable gets a second definition
1273    locating it in the register.
1274 
1275    Printing or argument lists in gdb uses the definitions that
1276    locate in the parameter list.  But reference to the variable in
1277    expressions uses preferentially the definition as a register.  */
1278 
1279 /* Output definitions, referring to storage in the parmlist,
1280    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
1281 
1282 static void
sdbout_parms(parms)1283 sdbout_parms (parms)
1284      tree parms;
1285 {
1286   for (; parms; parms = TREE_CHAIN (parms))
1287     if (DECL_NAME (parms))
1288       {
1289 	int current_sym_value = 0;
1290 	const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1291 
1292 	if (name == 0 || *name == 0)
1293 	  name = gen_fake_label ();
1294 
1295 	/* Perform any necessary register eliminations on the parameter's rtl,
1296 	   so that the debugging output will be accurate.  */
1297 	DECL_INCOMING_RTL (parms)
1298 	  = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1299 	SET_DECL_RTL (parms,
1300 		      eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1301 
1302 	if (PARM_PASSED_IN_MEMORY (parms))
1303 	  {
1304 	    rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1305 	    tree type;
1306 
1307 	    /* ??? Here we assume that the parm address is indexed
1308 	       off the frame pointer or arg pointer.
1309 	       If that is not true, we produce meaningless results,
1310 	       but do not crash.  */
1311 	    if (GET_CODE (addr) == PLUS
1312 		&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
1313 	      current_sym_value = INTVAL (XEXP (addr, 1));
1314 	    else
1315 	      current_sym_value = 0;
1316 
1317 	    if (GET_CODE (DECL_RTL (parms)) == REG
1318 		&& REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1319 	      type = DECL_ARG_TYPE (parms);
1320 	    else
1321 	      {
1322 		int original_sym_value = current_sym_value;
1323 
1324 		/* This is the case where the parm is passed as an int or
1325 		   double and it is converted to a char, short or float
1326 		   and stored back in the parmlist.  In this case, describe
1327 		   the parm with the variable's declared type, and adjust
1328 		   the address if the least significant bytes (which we are
1329 		   using) are not the first ones.  */
1330 		if (BYTES_BIG_ENDIAN
1331 		    && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1332 		  current_sym_value +=
1333 		    (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1334 		     - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1335 
1336 		if (GET_CODE (DECL_RTL (parms)) == MEM
1337 		    && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1338 		    && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1339 			== CONST_INT)
1340 		    && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1341 			== current_sym_value))
1342 		  type = TREE_TYPE (parms);
1343 		else
1344 		  {
1345 		    current_sym_value = original_sym_value;
1346 		    type = DECL_ARG_TYPE (parms);
1347 		  }
1348 	      }
1349 
1350 	    PUT_SDB_DEF (name);
1351 	    PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1352 	    PUT_SDB_SCL (C_ARG);
1353 	    PUT_SDB_TYPE (plain_type (type));
1354 	    PUT_SDB_ENDEF;
1355 	  }
1356 	else if (GET_CODE (DECL_RTL (parms)) == REG)
1357 	  {
1358 	    rtx best_rtl;
1359 	    /* Parm passed in registers and lives in registers or nowhere.  */
1360 
1361 	    /* If parm lives in a register, use that register;
1362 	       pretend the parm was passed there.  It would be more consistent
1363 	       to describe the register where the parm was passed,
1364 	       but in practice that register usually holds something else.  */
1365 	    if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1366 	      best_rtl = DECL_RTL (parms);
1367 	    /* If the parm lives nowhere,
1368 	       use the register where it was passed.  */
1369 	    else
1370 	      best_rtl = DECL_INCOMING_RTL (parms);
1371 
1372 	    PUT_SDB_DEF (name);
1373 	    PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1374 	    PUT_SDB_SCL (C_REGPARM);
1375 	    PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1376 	    PUT_SDB_ENDEF;
1377 	  }
1378 	else if (GET_CODE (DECL_RTL (parms)) == MEM
1379 		 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1380 	  {
1381 	    /* Parm was passed in registers but lives on the stack.  */
1382 
1383 	    /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1384 	       in which case we want the value of that CONST_INT,
1385 	       or (MEM (REG ...)) or (MEM (MEM ...)),
1386 	       in which case we use a value of zero.  */
1387 	    if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1388 		|| GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1389 	      current_sym_value = 0;
1390 	    else
1391 	      current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1392 
1393 	    /* Again, this assumes the offset is based on the arg pointer.  */
1394 	    PUT_SDB_DEF (name);
1395 	    PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1396 						  XEXP (DECL_RTL (parms), 0)));
1397 	    PUT_SDB_SCL (C_ARG);
1398 	    PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1399 	    PUT_SDB_ENDEF;
1400 	  }
1401       }
1402 }
1403 
1404 /* Output definitions for the places where parms live during the function,
1405    when different from where they were passed, when the parms were passed
1406    in memory.
1407 
1408    It is not useful to do this for parms passed in registers
1409    that live during the function in different registers, because it is
1410    impossible to look in the passed register for the passed value,
1411    so we use the within-the-function register to begin with.
1412 
1413    PARMS is a chain of PARM_DECL nodes.  */
1414 
1415 static void
sdbout_reg_parms(parms)1416 sdbout_reg_parms (parms)
1417      tree parms;
1418 {
1419   for (; parms; parms = TREE_CHAIN (parms))
1420     if (DECL_NAME (parms))
1421       {
1422 	const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1423 
1424 	/* Report parms that live in registers during the function
1425 	   but were passed in memory.  */
1426 	if (GET_CODE (DECL_RTL (parms)) == REG
1427 	    && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1428 	    && PARM_PASSED_IN_MEMORY (parms))
1429 	  {
1430 	    if (name == 0 || *name == 0)
1431 	      name = gen_fake_label ();
1432 	    PUT_SDB_DEF (name);
1433 	    PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1434 	    PUT_SDB_SCL (C_REG);
1435 	    PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1436 	    PUT_SDB_ENDEF;
1437 	  }
1438 	/* Report parms that live in memory but not where they were passed.  */
1439 	else if (GET_CODE (DECL_RTL (parms)) == MEM
1440 		 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1441 		 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1442 		 && PARM_PASSED_IN_MEMORY (parms)
1443 		 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1444 	  {
1445 #if 0 /* ??? It is not clear yet what should replace this.  */
1446 	    int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1447 	    /* A parm declared char is really passed as an int,
1448 	       so it occupies the least significant bytes.
1449 	       On a big-endian machine those are not the low-numbered ones.  */
1450 	    if (BYTES_BIG_ENDIAN
1451 		&& offset != -1
1452 		&& TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1453 	      offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1454 			 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1455 	    if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1456 #endif
1457 	      {
1458 		if (name == 0 || *name == 0)
1459 		  name = gen_fake_label ();
1460 		PUT_SDB_DEF (name);
1461 		PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1462 				 (XEXP (DECL_RTL (parms), 0)));
1463 		PUT_SDB_SCL (C_AUTO);
1464 		PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1465 		PUT_SDB_ENDEF;
1466 	      }
1467 	  }
1468       }
1469 }
1470 
1471 /* Output debug information for a global DECL.  Called from toplev.c
1472    after compilation proper has finished.  */
1473 
1474 static void
sdbout_global_decl(decl)1475 sdbout_global_decl (decl)
1476      tree decl;
1477 {
1478   if (TREE_CODE (decl) == VAR_DECL
1479       && !DECL_EXTERNAL (decl)
1480       && DECL_RTL_SET_P (decl))
1481     {
1482       /* The COFF linker can move initialized global vars to the end.
1483 	 And that can screw up the symbol ordering.  Defer those for
1484 	 sdbout_finish ().  */
1485       if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1486 	sdbout_symbol (decl, 0);
1487 
1488       /* Output COFF information for non-global file-scope initialized
1489 	 variables.  */
1490       if (DECL_INITIAL (decl) && GET_CODE (DECL_RTL (decl)) == MEM)
1491 	sdbout_toplevel_data (decl);
1492     }
1493 }
1494 
1495 /* Output initialized global vars at the end, in the order of
1496    definition.  See comment in sdbout_global_decl.  */
1497 
1498 static void
sdbout_finish(main_filename)1499 sdbout_finish (main_filename)
1500      const char *main_filename ATTRIBUTE_UNUSED;
1501 {
1502   tree decl = (*lang_hooks.decls.getdecls) ();
1503   unsigned int len = list_length (decl);
1504   tree *vec = (tree *) xmalloc (sizeof (tree) * len);
1505   unsigned int i;
1506 
1507   /* Process the decls in reverse order--earliest first.  Put them
1508      into VEC from back to front, then take out from front.  */
1509 
1510   for (i = 0; i < len; i++, decl = TREE_CHAIN (decl))
1511     vec[len - i - 1] = decl;
1512 
1513   for (i = 0; i < len; i++)
1514     {
1515       decl = vec[i];
1516       if (TREE_CODE (decl) == VAR_DECL
1517 	  && ! DECL_EXTERNAL (decl)
1518 	  && DECL_INITIAL (decl)
1519 	  && TREE_PUBLIC (decl)
1520 	  && DECL_RTL_SET_P (decl))
1521 	sdbout_symbol (decl, 0);
1522     }
1523 
1524   free (vec);
1525 }
1526 
1527 /* Describe the beginning of an internal block within a function.
1528    Also output descriptions of variables defined in this block.
1529 
1530    N is the number of the block, by order of beginning, counting from 1,
1531    and not counting the outermost (function top-level) block.
1532    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1533    if the count starts at 0 for the outermost one.  */
1534 
1535 static void
sdbout_begin_block(line,n)1536 sdbout_begin_block (line, n)
1537      unsigned int line;
1538      unsigned int n;
1539 {
1540   tree decl = current_function_decl;
1541   MAKE_LINE_SAFE (line);
1542 
1543   /* The SCO compiler does not emit a separate block for the function level
1544      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1545      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1546 #ifndef MIPS_DEBUGGING_INFO
1547   if (n != 1)
1548 #endif
1549     PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1550 
1551   if (n == 1)
1552     {
1553       /* Include the outermost BLOCK's variables in block 1.  */
1554       do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1555       sdbout_block (DECL_INITIAL (decl));
1556     }
1557   /* If -g1, suppress all the internal symbols of functions
1558      except for arguments.  */
1559   if (debug_info_level != DINFO_LEVEL_TERSE)
1560     {
1561       do_block = n;
1562       sdbout_block (DECL_INITIAL (decl));
1563     }
1564 
1565 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1566   sdbout_dequeue_anonymous_types ();
1567 #endif
1568 }
1569 
1570 /* Describe the end line-number of an internal block within a function.  */
1571 
1572 static void
sdbout_end_block(line,n)1573 sdbout_end_block (line, n)
1574      unsigned int line;
1575      unsigned int n ATTRIBUTE_UNUSED;
1576 {
1577   MAKE_LINE_SAFE (line);
1578 
1579   /* The SCO compiler does not emit a separate block for the function level
1580      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1581      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1582 #ifndef MIPS_DEBUGGING_INFO
1583   if (n != 1)
1584 #endif
1585   PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1586 }
1587 
1588 static void
sdbout_source_line(line,filename)1589 sdbout_source_line (line, filename)
1590      unsigned int line;
1591      const char *filename ATTRIBUTE_UNUSED;
1592 {
1593   /* COFF relative line numbers must be positive.  */
1594   if ((int) line > sdb_begin_function_line)
1595     {
1596 #ifdef ASM_OUTPUT_SOURCE_LINE
1597       ASM_OUTPUT_SOURCE_LINE (asm_out_file, line);
1598 #else
1599       fprintf (asm_out_file, "\t.ln\t%d\n",
1600 	       ((sdb_begin_function_line > -1)
1601 		? line - sdb_begin_function_line : 1));
1602 #endif
1603     }
1604 }
1605 
1606 /* Output sdb info for the current function name.
1607    Called from assemble_start_function.  */
1608 
1609 static void
sdbout_begin_function(decl)1610 sdbout_begin_function (decl)
1611      tree decl ATTRIBUTE_UNUSED;
1612 {
1613   sdbout_symbol (current_function_decl, 0);
1614 }
1615 
1616 /* Called at beginning of function body (before or after prologue,
1617    depending on MIPS_DEBUGGING_INFO).  Record the function's starting
1618    line number, so we can output relative line numbers for the other
1619    lines.  Describe beginning of outermost block.  Also describe the
1620    parameter list.  */
1621 
1622 #ifndef MIPS_DEBUGGING_INFO
1623 static void
sdbout_begin_prologue(line,file)1624 sdbout_begin_prologue (line, file)
1625      unsigned int line;
1626      const char *file ATTRIBUTE_UNUSED;
1627 {
1628   sdbout_end_prologue (line, file);
1629 }
1630 #endif
1631 
1632 static void
sdbout_end_prologue(line,file)1633 sdbout_end_prologue (line, file)
1634      unsigned int line;
1635      const char *file ATTRIBUTE_UNUSED;
1636 {
1637   sdb_begin_function_line = line - 1;
1638   PUT_SDB_FUNCTION_START (line);
1639   sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1640   sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1641 }
1642 
1643 /* Called at end of function (before epilogue).
1644    Describe end of outermost block.  */
1645 
1646 static void
sdbout_end_function(line)1647 sdbout_end_function (line)
1648      unsigned int line;
1649 {
1650 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1651   sdbout_dequeue_anonymous_types ();
1652 #endif
1653 
1654   MAKE_LINE_SAFE (line);
1655   PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1656 
1657   /* Indicate we are between functions, for line-number output.  */
1658   sdb_begin_function_line = -1;
1659 }
1660 
1661 /* Output sdb info for the absolute end of a function.
1662    Called after the epilogue is output.  */
1663 
1664 static void
sdbout_end_epilogue(line,file)1665 sdbout_end_epilogue (line, file)
1666      unsigned int line ATTRIBUTE_UNUSED;
1667      const char *file ATTRIBUTE_UNUSED;
1668 {
1669   const char *const name ATTRIBUTE_UNUSED
1670     = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1671 
1672 #ifdef PUT_SDB_EPILOGUE_END
1673   PUT_SDB_EPILOGUE_END (name);
1674 #else
1675   fprintf (asm_out_file, "\t.def\t");
1676   assemble_name (asm_out_file, name);
1677   fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1678 	   SDB_DELIM, SDB_DELIM, SDB_DELIM);
1679 #endif
1680 }
1681 
1682 /* Output sdb info for the given label.  Called only if LABEL_NAME (insn)
1683    is present.  */
1684 
1685 static void
sdbout_label(insn)1686 sdbout_label (insn)
1687      rtx insn;
1688 {
1689   PUT_SDB_DEF (LABEL_NAME (insn));
1690   PUT_SDB_VAL (insn);
1691   PUT_SDB_SCL (C_LABEL);
1692   PUT_SDB_TYPE (T_NULL);
1693   PUT_SDB_ENDEF;
1694 }
1695 
1696 /* Change to reading from a new source file.  */
1697 
1698 static void
sdbout_start_source_file(line,filename)1699 sdbout_start_source_file (line, filename)
1700      unsigned int line ATTRIBUTE_UNUSED;
1701      const char *filename ATTRIBUTE_UNUSED;
1702 {
1703 #ifdef MIPS_DEBUGGING_INFO
1704   struct sdb_file *n = (struct sdb_file *) xmalloc (sizeof *n);
1705 
1706   n->next = current_file;
1707   n->name = filename;
1708   current_file = n;
1709   PUT_SDB_SRC_FILE (filename);
1710 #endif
1711 }
1712 
1713 /* Revert to reading a previous source file.  */
1714 
1715 static void
sdbout_end_source_file(line)1716 sdbout_end_source_file (line)
1717      unsigned int line ATTRIBUTE_UNUSED;
1718 {
1719 #ifdef MIPS_DEBUGGING_INFO
1720   struct sdb_file *next;
1721 
1722   next = current_file->next;
1723   free (current_file);
1724   current_file = next;
1725   PUT_SDB_SRC_FILE (current_file->name);
1726 #endif
1727 }
1728 
1729 /* Set up for SDB output at the start of compilation.  */
1730 
1731 static void
sdbout_init(input_file_name)1732 sdbout_init (input_file_name)
1733      const char *input_file_name ATTRIBUTE_UNUSED;
1734 {
1735 #ifdef MIPS_DEBUGGING_INFO
1736   current_file = (struct sdb_file *) xmalloc (sizeof *current_file);
1737   current_file->next = NULL;
1738   current_file->name = input_file_name;
1739 #endif
1740 
1741 #ifdef RMS_QUICK_HACK_1
1742   tree t;
1743   for (t = (*lang_hooks.decls.getdecls) (); t; t = TREE_CHAIN (t))
1744     if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0
1745 	&& !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type"))
1746       sdbout_symbol (t, 0);
1747 #endif
1748 }
1749 
1750 #else  /* SDB_DEBUGGING_INFO */
1751 
1752 /* This should never be used, but its address is needed for comparisons.  */
1753 const struct gcc_debug_hooks sdb_debug_hooks;
1754 
1755 #endif /* SDB_DEBUGGING_INFO */
1756 
1757 #include "gt-sdbout.h"
1758