gcc/sdbout.c

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