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