gcc/dbxout.c

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