gcc/dbxout.c

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