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